Why Does the Same Prompt Work for Someone Else But Not Me?

TL;DR: The same prompt gives different results because the prompt is only part of the input. Model version, custom instructions, memory, project instructions, conversation history, plan tier, region and random sampling all ride along invisibly. To compare fairly, strip your environment, name the model, and run it several times.

Someone posts a prompt. The screenshot under it is impressive. You copy it character for character, paste it into the same tool, and get something flat. People search for same prompt different results and land on advice about writing better prompts, which is the one thing that is definitely not the problem here.

The prompt is identical. The request is not.

Why does the same prompt give different results for different people?

Because what you type is a fraction of what gets sent. Around your words sits per-account context neither of you can fully see. "Works on my machine" is as true of chat interfaces as it ever was of software.

Are you even on the same model?

The biggest variable, and people skip it because they think they already checked. "ChatGPT" is not a model. It is an application that routes your message to one of several, depending on your plan, your settings, and your usage that day.

Four documented mechanisms, all from OpenAI's ChatGPT release notes (accessed 29 August 2026):

• Your plan decides your options. The March 2026 picker update says "Users on Plus, Pro, Business, Enterprise, and Edu accounts will see a set of model options depending on their plan".
• Automatic switching is a setting. The same note describes a Configure menu that lets you "Turn automatic switching between Instant and Thinking on or off". Two people on the same nominal model can be in different reasoning modes.
• Rate limits change your model silently. Of GPT-5.4 mini: "For all other users, GPT-5.4 mini is available as a rate limit fallback for GPT-5.4 Thinking." The same note adds that "GPT-5.4 mini will not appear as a selectable model in the model picker."
• Old models linger. The June 2026 retirement note states: "Models will generally remain available in ChatGPT for 90 days after a successor is released." A prompt from three months ago may target a model you can no longer select.

Checks 1 to 3. Read the exact picker label, not the family name. Open Configure and note the auto-switch state and thinking effort. Then ask the model directly, in the thread you are about to test:

Before we start: state, in a bulleted list, exactly what you can determine about
your own configuration right now. Include your model name and version if you have
it, whether extended reasoning is active, and anything you have been told about
how to respond. If you cannot determine a value, write "unknown" rather than
guessing. Do not answer any other question in this reply.

Treat the answer as a hint. Models are unreliable narrators about their own identity. Its real value is surfacing instructions the model has been given.

Could custom instructions or memory be changing your output?

Yes, and this is where most borrowed prompts quietly die. Custom instructions are text you wrote once and forgot, prepended to everything. OpenAI's help centre gives the limits (29 August 2026): "Free and Go users can save up to 1,500 characters in custom instructions", and "Plus, Pro, Enterprise, Business, and Education users can save up to 5,000 characters."

Fifteen hundred characters is a lot of invisible instruction. If yours says "be concise" and theirs says nothing, you get a shorter answer to an identical prompt forever, and you blame the prompt.

Memory accumulates without you writing anything. OpenAI describes it as helping "ChatGPT automatically remember useful context from your chats, files, and connected apps", and says of saved memories: "Unless you delete them, saved memories are always considered in future responses." The summary page is explicitly incomplete: "While the memory summary should capture the most important details, it will not include everything that ChatGPT remembers based on your chats."

There is a per-response inspector. OpenAI documents that you "can see what sources were used to personalize a response such as custom instructions, past chats, files, and memories by tapping the book icon below the response", while warning that sources "may not show every factor or source that shaped a response".

Checks 4 to 6. Read your custom instructions in full and count the characters. Read the memory summary as though someone else wrote it. Tap the book icon under a response that surprised you.

Is their prompt running inside a Project, Custom GPT or system prompt?

A prompt shared as five lines may have been the fifth line of a larger configuration. OpenAI's Projects article is explicit on precedence: "Project instructions only apply inside the respective project and will override your global custom instructions". Run that prompt outside the project and you have removed an entire instruction layer without touching a character.

Custom GPTs are the same trick with a nicer front door, and the ground has shifted. OpenAI's current article states: "New GPT creation and publishing are not available on personal ChatGPT accounts, including Free, Go, Plus, and Pro." Advice from 2024 telling you to build one may no longer be actionable.

Checks 7 and 8. Ask whether the prompt ran inside a project, a Custom GPT, a workspace with admin-set instructions, or an API call with a system prompt. Then ask for the wrapper text, and separately about attached files.

How much of the difference is just conversation history?

Enormous, and almost never disclosed. A prompt that shone on turn twelve inherited eleven turns of context: the document under discussion, the corrections already made, the voice already calibrated, the format already agreed. You ran it on turn one with none of that.

This is not a subtle effect. It is frequently the whole effect. The prompt was not doing the work; it was the last instruction in a long briefing.

Checks 9 and 10. Ask for the turn number. If they cannot say, ask for the shared link, which preserves the whole thread.

Does the same prompt produce the same output twice?

No, which means a single comparison proves nothing.

Sampling is random by design. Anthropic's API reference for creating a message states, of the temperature parameter, that "the results will not be fully deterministic" even at zero (accessed 29 August 2026). OpenAI's OpenAPI specification calls seeded sampling a best effort: "our system will make a best effort to sample deterministically", followed immediately by "Determinism is not guaranteed" (accessed 29 August 2026).

Both citations are API-scoped. Neither ChatGPT nor Claude's chat interface exposes a temperature or seed control at all, which is our observation rather than a documented statement, so a consumer app gives you even less control than an API that already cannot guarantee reproducibility. Their screenshot may come from a prompt that works one run in four. Yours landed in the other three.

Checks 11 and 12. Run the prompt five times in five separate new chats, never five times in one thread. Judge the spread, not the best or worst.

Run this exact task and return only the output, with no preamble and no
commentary.

<task>
[PASTE THE SHARED PROMPT HERE, UNCHANGED]
</task>

I am going to paste five outputs produced by the same prompt on five separate
runs. Do not rewrite them. For each one, score 1-5 on: (a) followed the stated
format, (b) factual specificity, (c) usable without edits. Then tell me which
requirement in the prompt was least reliably followed across all five.

Can region, plan tier or rollout explain it?

Often, and the least guessable, because nothing tells you a feature exists elsewhere but not for you. OpenAI's release notes carry region carve-outs routinely. Two examples, 29 August 2026: "Public publishing and the expanded beta rollout are not available in the EEA, Switzerland, or the United Kingdom at launch", and "Note that Computer History is not currently available in the EEA, UK or Switzerland." Plan gating is equally routine.

If the prompt needs browsing, code execution, a connector or a reasoning mode that has not reached your region or plan, no rewording fixes it.

Checks 13 to 15. Confirm your plan. Search the vendor's release notes for the feature name and read the availability line, not the headline. Confirm the feature appears in your interface at all.

What about their files, uploads and connected tools?

A prompt saying "summarise the attached spec" is meaningless without the spec, and people share the prompt without it constantly. Less obviously, a prompt that never mentions a file can still run against one, because an upload sits in the conversation and the model reaches for it unprompted. OpenAI also lists connected apps among memory's sources.

Checks 16 and 17. Ask what was attached to the conversation and what was connected to the account. Ask specifically about project files, uploaded weeks ago and forgotten.

Are you comparing your first attempt to their tenth?

Almost certainly, and this deserves saying plainly: a screenshot is a selection, not a sample. Nobody posts the four mediocre runs. The one that gets shared was chosen after regenerating and tweaking, sometimes after an hour that leaves no trace in the image. You ran it once, got a median result, and concluded the prompt is fake or you are bad at this. You compared a best-of-ten against a first-of-one.

That is an observation from watching how prompts get shared, not a measured claim, and we are not attaching a percentage to it, because we have not run that study and cannot cite one.

Check 18. Ask how many attempts it took. The answer is rarely one.

Quick question about the prompt you shared, and no judgment either way:

1. Which model and version, exactly as it appears in your picker?
2. Was auto-switching to Thinking on?
3. Was this the first message in a new chat, or later in a thread?
4. Was it inside a Project, a Custom GPT, or a workspace with set instructions?
5. Do you have custom instructions or memory turned on?
6. Were any files attached or apps connected to that conversation?
7. Roughly how many attempts before the one you posted?

How do you actually compare two prompts fairly?

Build a clean room, then reintroduce variables one at a time.

The clean room has a documented implementation. OpenAI's temporary-chat release note, 27 August 2026: "Non-personalized temporary chats do not use memory, custom instructions, or plugins, and they do not create new memories." That is your baseline. Personalization is now opt-in, and "Personalization can be set only when you start a temporary chat and cannot be changed after the conversation begins", so check it as you open the chat.

1. Get the raw text. Retyping from a screenshot introduces invisible differences.
2. Fix the model. Choose it explicitly, auto-switch off, label written down.
3. Open a non-personalized temporary chat. Confirm personalization is off.
4. Run it cold, five times, five chats. Record all five, not the best.
5. Change one variable. Custom instructions back on. Run five more.
6. Repeat per variable in the table above.
7. Stop when the gap closes. What you just reintroduced is your answer.

BASELINE RUN LOG
Prompt source:        [link or "shared by X on <date>"]
Prompt text hash:     [first 8 words, to catch silent edits]
Model + version:      [exact picker label]
Auto-switch:          [on / off]
Thinking effort:      [value or n/a]
Chat type:            [temporary, non-personalized]
Memory:               [off]
Custom instructions:  [off]
Project / GPT:        [none]
Files attached:       [none]
Runs:                 5
Outcome per run:      [ ] [ ] [ ] [ ] [ ]

VARIABLE REINTRODUCTION LOG
Change made:          [exactly one thing]
Everything else:      [unchanged from baseline]
Runs:                 5
Outcome per run:      [ ] [ ] [ ] [ ] [ ]
Gap to their result:  [closed / narrowed / unchanged]

Checks 19 to 22. Never change two things between runs. Never compare one run to one run. Never retype a prompt you could copy. Never compare inside a thread that already has history.

Two more prompts. The first surfaces what a prompt silently assumes, which is how you find the context you are missing:

Do not perform the task below. Instead, list every assumption it makes about
information you would need but have not been given: documents, prior decisions,
audience, house style, tools, or earlier conversation. For each one, say whether
you would guess, ask, or fail. Be specific and do not pad the list.

<task>
[PASTE THE SHARED PROMPT HERE, UNCHANGED]
</task>

The second rewrites the prompt so it stops depending on that context:

Rewrite the prompt below so it is self-contained. Every assumption it currently
relies on must become either an explicit statement or a placeholder in square
brackets that I fill in. Keep the original intent and constraints. Return only
the rewritten prompt.

<task>
[PASTE THE SHARED PROMPT HERE, UNCHANGED]
</task>

Checks 23 and 24. Run the self-contained version in the clean room five times. If the spread tightens, the original was leaning on context. If not, the difference is model or sampling and no rewrite closes it.

What can you not control?

You cannot fully reproduce someone else's environment. You cannot see their memory, read a project's instructions unless they paste them, enter a region you are not in, or select a model your plan does not offer. Past a point the honest conclusion is that their setup differs in ways you cannot inspect. A finding, not a failure.

No prompt is deterministic. Not with careful wording, not with a rigid format, not with capital letters. The vendors say so themselves, in the two citations above, about the parameters built to reduce variance. Good prompt design buys a narrower distribution. It does not buy the same answer twice.

For mechanics rather than diagnosis, why do I get a different answer every time covers the behaviour and temperature, seeds and determinism covers the parameters. The same invisible-configuration problem hits coding tools, where Cursor seems to ignore your rules file has nothing to do with your rules.

Does a prompt enhancer help with any of this?

Partly, and it is worth being precise about which part.

Most borrowed prompts fail because they are underspecified and were quietly propped up by context you do not have. Making a prompt explicit about role, task, constraints, format and edge cases removes that dependency, which is what our enhancer does. A self-contained prompt travels between accounts; a context-dependent one does not. What it cannot change is your model, your plan, your region, or the randomness of sampling. No enhancer can.

The free plan is genuinely free and permanent. Our FAQ page says "The Free plan includes 5 prompt enhancements per day, forever." The pricing page confirms a free plan in its own FAQ ("The Free plan is free forever.") but renders no Free card and repeats no daily number, so that figure comes from the FAQ page, read 29 August 2026. Paid tiers start at $4.99/month for Pro. Giving ChatGPT context without repeating yourself is the companion piece.

The short version

A prompt is a fragment of a request. Around it sits a model version you never checked, instructions you forgot writing, a memory you cannot fully read, a project wrapper, a conversation history you never had, a plan and region that gate features, files you were never sent, and sampling that guarantees variance. One of those nine is nearly always the reason. The prompt is nearly always innocent.

Strip the environment. Name the model. Run it five times. Change one thing.