The Prompt Hygiene Checklist (10 Checks Before You Send)

TL;DR: A prompt hygiene checklist is ten yes-or-no checks you run in the sixty seconds before you send a prompt: referents, audience, format, length, buried instructions, hidden assumptions, examples, conflicting asks, a failure instruction, and stale context. Each takes five seconds to check and costs real output quality to skip.

What Is a Prompt Hygiene Checklist, and When Do You Run It?

It is not a framework you memorize before you start writing, and it is not a diagnosis you run after the model has already disappointed you. It sits in between: the last sixty seconds before you hit enter, when the prompt is finished and you have exactly one chance to catch what you missed.

If a framework is what you want, ChatGPT Prompt Structure Explained covers the four slots, Role, Task, Format, Constraints, that every named framework rearranges. If the prompt already came back wrong, Prompt Not Working? A Diagnostic Flowchart matches symptom to cause after the fact. This page is neither: ten questions to run against a finished prompt before you know whether it worked.

Would a Stranger Reading This Prompt Know Exactly What "It" Means?

Because a pronoun with two possible targets isn't ambiguous to you, only to the model. It has your words, not your intent, and every unresolved "it," "this," or "that" is a fork where it silently picks a branch and moves on.

Why it matters: the failure is invisible until the output arrives, already built on the wrong reading. You get a confident, well-written answer to a question you didn't ask.

5-second version: read your prompt like a stranger who wasn't in your head a minute ago. Every "it" needs one obvious target. Name two candidates, and the model can too, silently.

BEFORE:
Compare our onboarding flow to Competitor X's signup process, and
tell me what to fix about it.

AFTER:
Compare our onboarding flow to Competitor X's signup process. Then
tell me what to fix about OUR onboarding flow specifically, not
Competitor X's process.

Ask ten people what "it" means in the BEFORE version and you'll get at least two different answers. The model picks one, silently, and you find out only when the fix it recommends doesn't apply to the flow you actually meant.

Have You Told the Model Who Is Actually Going to Read This?

Because audience sets vocabulary, depth, and what can be assumed as already known. Without it, the model defaults to a generic professional reader who describes no one specifically.

Why it matters: the same question from a beginner and an expert deserves a different answer. An unnamed reader gets an answer aimed at the average of both, useful to neither.

5-second version: delete your one sentence about who reads this. Would the ideal answer change? If yes and it isn't in your prompt, you have a gap.

Audience is the other half of what persona prompting covers: who the model answers as changes vocabulary; who it answers for changes what it can assume you know.

BEFORE:
Explain how our API rate limiting works.

AFTER:
Explain how our API rate limiting works, for a backend engineer who
has never touched our API before and needs to know how to catch and
retry a 429 response in their own code.

The first version could be answered by paraphrasing the docs. The second forces the specific detail, catching and retrying a 429, that decides whether this becomes working code or another paragraph to reread tomorrow.

Did You Show the Shape You Want, or Just Describe It?

Because a format described in prose is optional, and a format shown is a contract. Left to guess, the model produces whatever shape it defaults to, and that default isn't always the one in your head.

Why it matters: the substance can be exactly right and still cost you a round-trip because it arrived as paragraphs when you needed a table.

5-second version: look for a template, a column header, or a literal word like "table" or "JSON" in your prompt. If the shape lives only in your head, it isn't in the prompt.

If you're not sure which shape fits the deliverable, How to Decide What Output Format You Actually Need covers that tradeoff; this check just asks whether you decided at all.

BEFORE:
Give me a comparison of these three vendors for a 20-person team.

AFTER:
Compare these three vendors for a 20-person team as a Markdown table
with exactly these columns: Vendor | Price per seat | Support quality
| Best for. One row per vendor. Nothing before or after the table.

The BEFORE version might come back as paragraphs, a bulleted list, or a table, and you won't know which until you've already read it once.

Did You Name a Length or Depth Target, or Are You Just Hoping for One?

Because without any length signal, the model matches the size of deliverable it thinks you want, and "explain X" reads as a small ask no matter how much depth you meant.

Why it matters: a bare word count helps a little. Naming the sections required helps more, since the model isn't literally counting words as it writes; depth produces length, not the reverse.

5-second version: is there a number, a page limit, or required sections anywhere? "Keep it concise" or "go deep" is a feeling, not a target.

Why Does AI Ignore My Word Count? covers why a bare number is the weakest version of this fix, and what to name instead.

BEFORE:
Give me a thorough rundown of email deliverability best practices.

AFTER:
Write a 400-word rundown of email deliverability best practices.
Cover: SPF/DKIM/DMARC setup, the warm-up schedule for a new sending
domain, and the single most common mistake that gets a sender
blocklisted. Each of the 3 gets at least 100 words.

"Thorough" can mean two paragraphs or two thousand words depending on the day. Naming the three things it must cover, and how much room each gets, is what actually controls the depth.

Is Your One Hard Rule Sitting Inside a Paragraph Instead of Its Own Line?

Because a buried instruction reads as commentary, not a rule. The model treats a pulled-out constraint very differently from the same sentence inside a run-on about something else.

Why it matters: most of the response can be right while the one rule that mattered, a length cap, a tone note, quietly disappears, with nothing flagging that it was dropped.

5-second version: scan for the rule that must not break. Is it a standalone line, or clause four of a sentence about something else?

Prompt Not Working? A Diagnostic Flowchart covers what happens once this check fails and you're debugging after the fact. This one is about catching it before you send.

BEFORE:
Write a cover letter for this role, I have 3 years of experience in
social media, and please keep it under 250 words because the
application form has a hard character limit.

AFTER:
Write a cover letter for this role. Background: 3 years of experience
in social media. HARD CONSTRAINT: maximum 250 words. This is a form
limit, not a suggestion.

In the BEFORE version, the 250-word limit is the ninth word of a sentence about something else. Pulled out, it survives. Buried, it's the first thing dropped when the model runs long.

What Is This Prompt Assuming That Might Not Be True?

Because every prompt encodes assumptions invisible to the person who wrote it, and a wrong one breaks everything built on top of it even when the model follows every instruction perfectly.

Why it matters: this failure doesn't look like a failure. The answer is well-formed, on-topic, and confidently wrong for a reason that has nothing to do with the model.

5-second version: ask "what would have to be true for this to make sense?" Then check whether you actually know that, or just assumed it.

If you'd rather have the model surface these for you instead of hunting them yourself, How to Get ChatGPT to Ask You Questions First covers that pattern directly.

BEFORE:
Write a script for onboarding new customers to our product.

AFTER:
Write a script for onboarding new customers to our product, assuming
they signed up on a colleague's recommendation (not from an ad), have
used similar tools before, and will read this over email, not on a
call.

The BEFORE version assumes a single, generic new customer who doesn't exist. If your real customers are cold-ad traffic who have never touched a tool like yours, the tone and pacing that come back will be wrong in a way you'll only notice when it fails to convert.

Would One Example Beat Another Sentence of Description?

Because some things are easier to show than to describe, tone, an exact pattern, an edge case, and a worked example settles what three more adjectives can't.

Why it matters: words like "punchy" or "professional" describe a feeling the model has to guess at. One concrete example removes the guessing.

5-second version: is there a rule you're describing in adjectives that you could show in one line instead? If yes, you're paying in words for what an example settles in one shot.

This is the whole idea behind few-shot prompting: showing beats describing. Few-Shot vs Zero-Shot Prompting covers when the tradeoff is worth the extra length and when it isn't.

BEFORE:
Write 5 taglines for our water bottle brand: punchy, benefit-driven,
not corporate-sounding.

AFTER:
Write 5 taglines for our water bottle brand, following this exact
pattern: [benefit], not [tradeoff]. Example of the pattern only, do
not reuse it: "Cold all day, guilt never."

"Punchy" and "not corporate-sounding" are matters of taste the model has to guess at. One example of the actual pattern removes the guessing, and every tagline that comes back follows a shape you can defend to a client.

Are You Asking for Two Things That Can't Both Win?

Because contradictory constraints force the model to silently pick a winner, usually whichever instruction it read most recently, and you find out which one lost only by noticing what's missing.

Why it matters: this is the most expensive check to skip, because nothing looks wrong. The output is fluent and complete; it just quietly resolved a conflict you never noticed creating.

5-second version: read your constraints back to back, out loud. Do any two of them disagree, even partially?

BEFORE:
Summarize this report concisely, and make sure to cover every single
finding in detail.

AFTER:
Summarize this report in 150 words. If you can't cover every finding
at that length, prioritize the 3 findings with the largest financial
impact and name which ones you dropped.

"Concisely" and "every single finding in detail" cannot both be true past a certain report length. Left unresolved, you get either a padded 800 words or three findings quietly missing, with nothing telling you which contradiction got resolved and how.

Can the Model Tell You It Doesn't Know?

Because a model scored on a benchmark that treats "I don't know" as equally wrong as a false answer has no incentive to admit a gap, and your prompt isn't exempt just because you didn't ask about obscure facts.

Why it matters more than the other nine: without stated permission to abstain, silence isn't an option the model weighs against a guess. A guess fills the space, most often on the specific numbers and quotes you're least equipped to catch yourself. This is hallucination's entry point, not a random glitch.

5-second version: search your prompt for "if you don't know" or "if this isn't in the source." Missing, and the model was never told a gap is acceptable.

BEFORE:
What was Acme Corp's Q3 2026 revenue, and why did it change from Q2?

AFTER:
Using only the earnings excerpt below, state Acme Corp's Q3 2026
revenue and the stated reason for the change from Q2. If a number or
reason is not in the excerpt, write "not stated in this excerpt"
instead of estimating it.

[PASTE EXCERPT HERE]

Send the BEFORE version with nothing to check against and you'll get a specific, confident number. It might be right. It might be a plausible-sounding fabrication built from the shape of similar earnings reports, and nothing in the reply tells you which.

Is Anything Here Left Over From an Earlier Version of This Task?

Because reused templates and long chats accumulate instructions from an earlier draft, an earlier client, an earlier version of the task, and now sit in the prompt contradicting what you actually need this time.

Why it matters: stale context reads as current context to the model. It has no way to know a line is three revisions old unless you say so.

5-second version: if you copied this prompt from an earlier one, is every sentence in it still true for today's version of the task?

In a long chat specifically, an instruction from ten turns ago can be technically still inside the context window and completely irrelevant to what you're asking now. Why Does ChatGPT Forget What I Told It? covers the flip side of the same problem.

BEFORE:
Write the client email, keep the tone casual like we discussed, and
remember the deadline is Friday.

AFTER:
Write the email for [Client Name]. Tone: formal. Deadline mentioned
in the email: next Wednesday.

The BEFORE version is a template from a different client, with a different deadline and a different tone preference, still sitting in the prompt. Every one of those stale details is now actively wrong, and the model has no way to know which parts of your own prompt you no longer mean.

Want the Whole Checklist in One Copy-Paste Block?

Pin this wherever your prompts actually get written, a notes app, a text expander, the top of a shared doc, so running the check takes less time than typing the prompt itself. It's the same ten questions above, compressed to one screen.

PROMPT HYGIENE CHECKLIST — read before you hit enter

[ ] 1. Referents: does every "it," "this," "that" have one clear target?
[ ] 2. Audience: did I say who reads this and what they already know?
[ ] 3. Format: did I show the shape, not just name it?
[ ] 4. Length: did I name a depth target, not just a feeling?
[ ] 5. Buried rules: is my one hard constraint its own line?
[ ] 6. Assumptions: what am I assuming that might not be true?
[ ] 7. Examples: would one worked example beat more description?
[ ] 8. Conflicts: am I asking for two things that can't both win?
[ ] 9. Failure instruction: can the model say it doesn't know?
[ ] 10. Stale context: is anything here left from an earlier draft?

The Habit This Checklist Is Actually Training

None of these ten checks are hard to fix once spotted. The cost of skipping this list is in the noticing, not the fixing: a missing audience or a buried constraint reads exactly like a fine prompt right up until the output comes back wrong in a way specific to that one gap.

Run it against every prompt for a few weeks and it starts happening without the list, the same way you stopped consciously checking for a subject line before sending an email. Until then, five seconds a check beats rereading a wrong answer twice.