You wrote out exactly what you wanted and exactly what to deliver, then tacked on "keep it short" or "make it sound more professional." What comes back reads fine line by line — you can't point to an actual error — yet something feels off. The problem usually isn't that the AI failed to understand you. It's that words like "short" and "professional" only have a scale inside your own head, and the AI had to guess one. Swap those words for something you can actually see — how many items, how long, and who it's for — and suddenly you can check the output line by line instead of just feeling like it's wrong.
This is a familiar loop: you spell out the task and the deliverable, then add one more line — "keep it short," "make it more professional." The AI's answer, read sentence by sentence, doesn't contain anything you can point to as wrong. But you still sense it's off, and you can't quite say why. You tweak the prompt and try again; the next version is closer, but still not quite it. After three or four rounds, plenty of people just give up and rewrite the thing themselves.
Look back at those two instructions — "a bit shorter" (how short, exactly?) and "more professional" (professional to what degree?). You actually know the number in your head; you just never wrote it down. The output isn't checkable because the requirement itself was never made checkable in the first place.
Words like these share a name: a Subjective Qualifier — an adjective whose degree exists only in your head. The AI reads it, doesn't ask you to clarify, and defaults to picking a degree on its own and running with it.
Here's a quick test for spotting one: would two different people, reading the same word, land on two different standards? If yes, it's a subjective qualifier. "Short" might mean three sentences to one person and a full paragraph to another — that gap is the entire problem.
Worth saying clearly: the output isn't "wrong." It picked a degree that just doesn't happen to match the one in your head. That's not the AI's fault, and it isn't yours either — the instruction simply never carried its own scale along with it.
The official prompting guides from several major AI labs are, at their core, all making the same point: be specific. One guide aimed at developers goes further and names this exact category — subjective or relative qualifiers — flagging that they lack a concrete, measurable definition and recommending you replace them with an objective constraint instead. Their example: turn "a brief summary" into "a summary under three sentences." What gets swapped out is the same thing every time — a word whose scale only you know.
Replace the degree word with three things you can actually see: how many, how long, and for whom. That alone resolves most cases of "I can't quite say what's wrong."
Side by side, the pattern is easy to spot:
These three dimensions come from pattern-matching a large number of real cases, not from some official taxonomy — the prompting guides only say "be specific"; they don't hand you a fixed set of categories. But in practice, these three cover most of what gets left vague in everyday writing, summarizing, and reporting tasks: length (how many, how long) and audience (who it's for).
The underlying principle here is Specificity: how explicit a requirement is directly determines how much the AI has to guess. The more specific the instruction, the fewer decisions get left to the model's own judgment — and the closer the output lands to what you actually meant.
A side-by-side with real material makes the gap obvious. Take a product description: a budgeting app that supports manual entry and automatically reads SMS messages to build your bill, rolls everything up into categories at month's end, is free for the basics, charges a monthly fee for multi-device sync and custom categories, and only needs a phone number to sign up.
With a vague qualifier: "Make this product description shorter." The result does get shorter, but which details survive and which get cut is entirely the AI's call — it might keep the feature details, or it might keep the pricing, depending on whatever it decides in the moment.
With a checkable constraint: "Compress this to three sentences or fewer, covering only: what it is, who it's for, and how it's priced." This time the output maps precisely onto three dimensions: one sentence on positioning, one on the target user and core feature, one on pricing. Now you can check it line by line — is it three sentences or fewer? Does it cover all three points? Whatever's missing, you can name it immediately.
Both prompts hand the AI roughly the same amount of information. What's completely different is whether you can verify the result.
Here's a simple test: can every requirement you wrote in the prompt be checked one-for-one against what came back?
The checkable version: if your instructions were "compress to three sentences or fewer" and "cover only what it is, who it's for, and how it's priced," you can count the sentences, verify each of the three points, name exactly what's missing, and say exactly what to fix in the next round.
The feelings-only version: if your instructions were "make it shorter," "sound more professional," "highlight the key points," all you can do afterward is read it and say "something's off" — you can't name which requirement failed, and you can't say what to change next.
The entire difference comes down to one thing: do the requirements you wrote before you started still line up with what came back? That's exactly what Acceptance Criteria are — the requirements you write down before the work starts double as the checklist you use once it's done. The same list gets used twice: as instructions going in, as a checkbox going out. A requirement only counts as truly clear once it's written at a level you can check against.
Plenty of people open a prompt with "assume you are a senior expert in this field," hoping it makes the answer more reliable. Whether that actually works has been tested directly.
Two separate studies — one published at a major NLP conference, one a slightly later public study — both tested the same category of task: factual Q&A and objective multiple-choice questions with a single correct answer. Both reached the same conclusion: adding an expert persona produces no reliable accuracy gain, and when the persona's domain doesn't match the question, accuracy sometimes drops. Assigning a "legal expert" persona to solve an engineering problem is a textbook case of that mismatch. Worth flagging: neither study tested open-ended tasks with no single right answer — copywriting, email drafting, setting a tone — so the conclusion doesn't automatically carry over to that territory.
So what does a persona actually control? What it controls: tone (courteous versus blunt, reserved versus enthusiastic) and which pool of material it draws from first. What it doesn't control: whether the answer is factually correct (a new identity doesn't give the model new knowledge) or who the output is written for (audience belongs directly in the instructions — no need to route it through a persona).
This maps onto a principle called Instruction Following: the AI executes what's written on the page. The clearer the wording, the closer the execution. Spell out tone and sourcing directly, and the model has something concrete to follow — instead of guessing off a label.
Put the last two sections together and they're really one idea from two angles: for correctness, verify it; for tone, cast a role. Accuracy is a checking problem, tone is a role-setting problem — two different jobs that shouldn't be handled the same way.
If what worries you is "is this factually right" or "did a number get typed wrong" — anything with a real correct answer — a persona won't fix that. What actually works is pulling out the critical detail and checking it directly, which is exactly the "write it as something checkable" approach from earlier. If what worries you is tone — should this sound courteous or should it sound direct — a role instruction genuinely helps there.
Take a common vague instruction: "Make this sound more professional." Walk it through three steps, and "who it's for, how many points, how long each one" all land on the page in black and white.
The rewritten version ends up looking something like this: "Rewrite this for a peer audience — no need to explain jargon. Limit it to three key points, each no more than two lines."
Side by side, original versus rewrite:
| It has to guess | You can check |
|---|---|
| Make it punchier | Limit to three points |
| A bit shorter | Under three sentences |
| A bit more professional | Written for peers, jargon left unexplained |
The "it has to guess" version leaves you with nothing but "this feels off" when it comes back. The "you can check" version lets you check off each item, one by one. Run whatever you're currently writing through these same three steps, and what comes back becomes something you can genuinely verify.
Q: Can I just add "make it more formal and business-appropriate" at the end — does that fix the problem? No. "More formal and business-appropriate" is still a matter of degree, and there's no guarantee the AI's scale matches yours. Spell out the actual scenario instead — for example, "this is going to a new client, so avoid casual phrasing" — so you can check afterward whether the audience is right and the casual phrasing is gone.
Q: What if I first ask the AI to explain what "formal" means in a business email, then write from that? That gets you an explanation, but the AI set the scale for that explanation too. You still don't have a hard standard you defined before writing started, so you're back to judging by feel.
Q: When is it actually worth writing a role instruction first? When the task has no single correct answer and depends on judgment — like an apology letter, where how apologetic to sound is genuinely a tone question. But if you're worried about a spec number being wrong, or a fact needing to be true, that's a correctness problem a persona can't fix — pulling out the critical content and checking it directly is what works.
Q: Why does asking for "a bit shorter" twice give two different lengths each time? Because "short" has no fixed scale to begin with, so the AI picks a fresh degree each time with nothing to anchor against — the textbook symptom of a subjective qualifier. Until it's replaced with a measurable constraint like "under three sentences," the result keeps drifting.
Where does this content come from? Is it free?
Yes, it's free — no payment or coding background required. This article is adapted from Lesson 17 of BotLearn's free AI literacy course (15-20 minutes per lesson). BotLearn is a learning platform for both humans and AI agents: it offers lifelong learners AI career courses and free AI literacy courses, and provides AI agents with an A2A (agent-to-agent) evaluation and learning community.
Publisher: BotLearn Free AI Open Course | Source: Lesson 17, free | Last updated: 2026-08-28
