The model didn't get smarter between your flat result and your colleague's good one. The prompt did the work.
A language model fills in whatever you leave unspecified with the statistical average of everything similar it has seen, which is why vague prompts produce competent, forgettable output. Specificity, context, constraints, structure and examples each narrow that gap in a different way. Real research backs this up: adding one phrase to an otherwise unchanged prompt took a model’s accuracy on a reasoning task from 17.7% to 78.7%. Prompting has real limits too. It can’t hand a model facts it was never given, and it doesn’t replace judgment about whether the output is actually true or appropriate to send.
Picture a marketing coordinator wrapping up a Friday afternoon. She needs a LinkedIn post announcing a client win before she logs off, so she opens ChatGPT and types something close to “write a LinkedIn post about our new client, Meridian Health.” What comes back opens with “In today’s competitive healthcare landscape” and reads like it could belong to any agency on earth. She’s tired, it’s fine, she posts it.
On Monday, a colleague on her team shares a LinkedIn post he wrote for a nearly identical situation, and it’s genuinely good. Specific, a little dry, clearly about a real client and a real problem. Her first thought is that he must have the paid version, or a better tool, or some setting she doesn’t have access to.
He doesn’t.
Same tool, same free plan, same day of the week. The only thing that was different between his result and hers was what he typed into the box.
That gap, between two people using the identical model and landing on wildly different quality, is the actual subject of this article. Not “AI is inconsistent,” and not “you need the expensive plan.” The model was constant in both cases. The only variable either of them controlled was the prompt, and it turns out that variable does most of the work.
Here’s the part worth understanding, because it changes how you write every prompt after this one. A language model doesn’t know anything about Meridian Health, or your company’s voice, or what “good” means for this specific post. It only knows what’s sitting in front of it in that exact conversation: your instructions, any examples you’ve given it, and the shape of the request itself.
When you leave something out, the model doesn’t stop and ask a clarifying question. It fills the gap with whatever is statistically most likely to satisfy a request that looks like yours, based on everything similar it was trained on. That’s close to the average of every LinkedIn announcement post ever written, which is exactly why it opens with “In today’s competitive landscape.” Nobody told it who this was for, what tone fit, or what to leave out, so it reached for the safest, most generic version of the task.
A vague prompt doesn’t fail. It succeeds at being average.
The mechanism behind every example in this article: whatever you leave unspecified gets filled in with the statistical average.
A short, unspecific prompt forces the model to guess at several things at once, and every guess it makes pulls the output back toward that average:
Ask a sharp new freelancer for “a LinkedIn post” with nothing else, and they’d hand you something similarly safe, then come find you to ask what you actually meant. A model does the first part and skips the second, which is exactly why the gap it leaves is yours to close.
Go back to that LinkedIn post. Here’s the actual weak prompt the marketing coordinator used, and what it produced.
Weak prompt: “Write a LinkedIn post about our new client, Meridian Health.”
What came back: “In today’s competitive healthcare landscape, we are thrilled to announce an exciting new partnership! We’re proud to welcome Meridian Health to our growing family of clients. This collaboration represents a significant milestone in our journey, and we look forward to the incredible results we’ll achieve together. Stay tuned for more updates!”
Nothing in that prompt told the model who would read this, what “good” meant, or what to avoid. So it reached for the safest version of a partnership announcement, complete with the opening line most readers have learned to scroll past.
Strong prompt, same model, same day: “Write a LinkedIn post announcing our new work with Meridian Health, a regional hospital network. It’s for hospital administrators and healthcare marketing leads who follow our page. Confident tone, no hype words like ‘thrilled’ or ‘excited.’ Open with the specific problem Meridian came to us with, their patient intake process was losing referrals to phone tag, not with the announcement itself. 60 to 90 words. End on one concrete detail about the actual work, not a general statement about the future.”
What came back: “Meridian Health’s regional hospital network was losing referrals to phone tag: patients calling in, getting bounced between departments, and giving up before they booked. We’re now working with their team to rebuild that intake flow around a single AI-assisted scheduling line that routes callers correctly on the first try. It’s a narrow fix for a specific, expensive problem, which is the kind of project we like taking on.”
Same underlying model. Same day. The only thing that changed was how much of the actual job got specified before the model started guessing.
| Weak prompt | Strong prompt | Why the output changes |
|---|---|---|
| “Write a LinkedIn post about our new client, Meridian Health.” | Names the audience, the real problem Meridian brought, a banned word list, a length, and what to end on. | Every detail you add removes a decision the model would otherwise make for you, by default, toward the average version of the task. |
| “Summarize this client call.” | “Summarize this call for our project lead who wasn’t on it. Lead with the one decision that changed, list open questions as bullets, skip small talk and scheduling logistics entirely.” | Without a stated reader and a definition of “useful,” the model can’t tell a decision from small talk, so it keeps both. |
Two versions of the same pattern: naming the audience, adding constraints, and defining “good” changes what the model treats as relevant.
The same pattern shows up under lab conditions, not just in a marketing team’s Slack channel. Kojima and colleagues tested the same reasoning task on the same model twice: once with a plain question, once with the exact same question plus one added sentence, “Let’s think step by step.” Nothing else changed. Accuracy went from 17.7% to 78.7%.[1] One phrase, same model, same question, and the gap was that large.
It’s tempting to read that jump as the phrase “think step by step” carrying some kind of magic. It doesn’t. What it does is force the model to generate its reasoning out loud, one step at a time, instead of jumping straight to an answer the way a rushed guess would. Each step narrows what a plausible next step could be, so by the time it reaches an answer, most of the wrong paths have already been ruled out.
Every specific detail you add removes one guess the model would otherwise make for you.
That’s really what every lever in a well-built prompt is doing: narrowing the range of what counts as a reasonable answer, so the model has less room to default to average. A few of the ones that matter most:
That last one is worth its own number. In the original GPT-3 paper, the same 175-billion-parameter model was tested on a reading comprehension benchmark two ways: once with a plain instruction, once with a small number of worked examples included in the prompt. Accuracy went from 76.2% to 86.4%, on the same model, on the same benchmark.[2] Showing the model what “done” looks like did more than describing it in more words would have.
GPT-3 175B accuracy on the LAMBADA benchmark, zero-shot versus few-shot prompting, same model. Source: Brown et al., “Language Models are Few-Shot Learners,” 2020.
None of this means longer prompts automatically win. A hundred rambling words with no stated audience will still land close to average. The lever isn’t length. It’s how much of the decision you’ve made for the model instead of leaving it to guess.
By this point the pattern should feel familiar: same model, sharper instruction, better result, across genuinely different tasks and different teams. The clearest single number comes from a paper that tested the step-by-step approach specifically on math.
A team at Google combined that step-by-step prompting method with a 540-billion-parameter model called PaLM and reached 58% accuracy on a set of grade-school math word problems, a new best result at the time, ahead of the previous approach of fine-tuning a separate model on thousands of examples, which had topped out around 55%.[3] The model wasn’t retrained. It wasn’t given more data. It was asked the same kind of question, with a prompt that walked it through showing its work.
Worth saying plainly: this is evidence about specific tasks and models, from published papers, not a guarantee about your exact prompt tomorrow. A technique that helps one model reason through arithmetic doesn’t automatically transfer to writing tone or legal nuance. What’s consistent across these three papers isn’t the exact percentage. It’s that changing only the prompt, on the same model, produced a meaningfully different result each time.
OpenAI’s own guidance to developers backs the same instinct from the vendor side: be specific and detailed about the outcome, length, format and style you want, and show the model an example of the output shape rather than only describing it.[4] That’s a vendor telling you how its own product responds best, which is a different kind of evidence than an independent academic paper, and both happen to point the same direction.
“Just write better prompts” isn’t the same advice for everyone, because the risk of getting it wrong isn’t the same for everyone either.
An HR benefits coordinator drafting an internal FAQ about a new health plan is working with AI on something employees will read literally and act on, so a vague or overconfident answer can send someone toward the wrong deadline or the wrong form. Being specific there means feeding it the actual plan document and asking it to quote from that document, not summarize from memory.
A marketing coordinator, like the one from the opening, usually carries lower stakes per individual post but higher volume, so the return on a sharper prompt compounds. The same three or four details, audience, tone, banned words, what to open with, apply to the next twenty posts, not just this one.
A solo consultant drafting a client proposal sits somewhere in between. The cost of a generic paragraph is reputational, not factual, but it’s usually the first thing a prospect reads, so the specificity that matters most is the one only the consultant has: the client’s stated problem, in their own words.
| What AI does | What the person still owns | How it gets checked |
|---|---|---|
| Drafts the first version of the LinkedIn post, email, or summary from the details you gave it | Decides whether the client name, numbers and claims in the draft are actually correct, and whether the tone fits this specific relationship | Read once, out loud, before it’s sent. That’s the one step worth protecting, even on the tenth post this month. |
| Reorganizes a messy transcript into decisions and open questions, once you’ve told it what counts as each | Judges whether a “decision” the model flagged was genuinely agreed, or just discussed | Whoever was in the room glances at the decisions list before it’s sent, not the full transcript summary |
A sharper prompt changes the quality of the first draft. It doesn’t remove the review step.
You don’t need a formula to catch most weak prompts before you send them. You need one honest question, asked three ways. Call it the stranger test: if you handed this exact prompt, with no other context, to a stranger who’s good at the task but knows nothing about your company, would they know what to do?
| Ask yourself before you hit send | Score 1 if yes, 0 if no |
|---|---|
| Would a stranger know who’s actually going to read this? | |
| Would they know what “good” looks like here, specifically, not in general? | |
| Would they know at least one thing to avoid or leave out? |
Score 3: send it. Score 1 to 2: you’ll likely get something usable but generic, and spend the time you saved editing it back into shape. Score 0: you’re about to get the average, and you already know what that reads like.
If a stranger couldn’t run this prompt and get what you wanted, the model can’t either.
This isn’t about writing longer prompts. The Meridian Health example scored a 3 in five sentences. It’s about noticing, before you hit send, which of those three answers you’re leaving for the model to guess.
One more habit worth building in: if a prompt keeps producing something close but not quite right, ask the model directly what information it’s missing to do the task well, rather than rewriting the request from scratch each time. It can often name the gap itself.
Everything above assumes a single question and a single answer: you write a prompt, the model responds, you read it and decide what to do next. That’s most of what non-technical professionals do with AI day to day, and it’s worth getting good at before anything more advanced.
It’s also where prompting’s job ends. A precise prompt won’t hand a model facts it was never given access to, and it won’t replace your judgment about whether an answer is actually true, appropriate to send, or right for this specific client. Specificity narrows what the model guesses at. It doesn’t remove the need to check the output.
The other place prompting alone runs out is when you’re not asking for one answer anymore, but setting an AI system up to take several steps on its own: look something up, draft it, check it, act, without you reading every step in between. That’s closer to briefing a process than briefing a single request, and a small ambiguity that costs you one flat LinkedIn post in a single prompt can compound across a whole chain of them. We’ve written about exactly where that shift happens in Prompt Engineering vs. Loop Engineering, the piece to read once single prompts start feeling too small for what you’re asking AI to do.
The smaller move is the one worth making this week:
Because the model isn’t judging quality, it’s predicting the most likely continuation of whatever you gave it. The person who got the better result gave the model more to work with: a stated audience, a tone, something to avoid. There’s a small amount of randomness built into how these models pick between similarly likely words, which is why asking the exact same prompt twice can produce slightly different phrasing. That randomness is minor compared to what a specific versus a vague prompt does to the range of possible answers in the first place.
The baseline has gone up, so a lazy prompt on a newer model often produces something more usable than the same lazy prompt did a couple of years ago. That’s real, and it doesn’t close the gap between a lazy prompt and a specific one on the same model, it just moves both up together. The professionals getting the most out of AI right now aren’t the ones who found a secret prompt. They’re the ones who’ve made specifying the job a habit, the same way a good manager doesn’t stop writing clear briefs just because their team gets more experienced.
Add a stated reader and one thing to avoid. Those two details alone catch most of what makes an answer feel generic: who it’s for, and what not to include, whether that’s a hype word, a length, or an assumption that isn’t true. If it’s still off after that, ask the model what information it’s missing to do the task well. It usually names the gap, which is often faster than rewriting the whole request from scratch.
No. Length only helps if the extra words are doing something: naming an audience, adding an example, setting a real constraint. A three-line prompt that specifies who it is for, what good looks like, and what to skip will usually beat a two-paragraph prompt that describes the topic in more and more general language without ever getting specific. Specificity is the lever. Word count is not.
Yes, and the stakes go up. In a single chat exchange, an ambiguous instruction produces one so-so answer you read and correct immediately. In an agent that takes multiple steps on its own, researching and then drafting and then formatting, for example, an ambiguity in the first instruction can carry into every step after it before a person ever sees the output. That’s the actual dividing line between prompt engineering and what’s sometimes called loop engineering, covered in more depth in our piece on Prompt Engineering vs. Loop Engineering.
This piece draws on three independent, peer-reviewed studies on how prompt phrasing changes language model output (Kojima et al. 2022, Brown et al. 2020, and Wei et al. 2022 via Google Research), plus OpenAI’s own published guidance for developers, all linked in the sources below. The Meridian Health example is illustrative, written to show the mechanism clearly rather than reproduced from an actual client campaign.
Weekly tips. Real examples. Practical help for busy professionals.
We care about your data, check out our privacy policy.