Most prompts describe the task and stop there. The ones that actually produce usable output on the first try end with something else entirely: a checklist for what counts as finished.

What you're actually building 🎯

A prompt is a job description. Most people write the "what" — the task, the topic, maybe a persona — and stop there. What they leave out is the "how you'll know it's right," so the model has to guess where the finish line is. It guesses wrong constantly, just quietly enough that you don't notice until the output's already back and something's off.

See the difference first

Here's a completely normal, completely vague prompt. Nothing wrong with it grammatically — it just gives the model no way to check its own work:

Write a LinkedIn post about why automation matters for small business owners.

The model will produce something. It'll sound fine. But "fine" was never defined, so you have no way to tell it apart from "actually good" until you read it and feel a vague sense that it's not quite there. Here's the same task with a definition of done attached:

You are a LinkedIn ghostwriter for [NICHE / ROLE]. Write a LinkedIn post arguing that automation matters for small business owners — specifically ones still doing [MANUAL TASK] by hand.

Definition of done — the post is only finished if all of these are true:
- Opens with a specific, concrete scenario, not a general statement
- Makes one clear argument, not three watered-down points
- Includes one real or plausible number or detail that makes it credible
- Ends with a line that invites a reply, not a generic CTA like "thoughts?"
- Under [WORD COUNT] words

If you can't hit all five, tell me which one you're compromising and why — don't silently ship a version that fails the checklist.

Notice what changed: the task is the same, but now the model has a checkable target, and permission to flag a tradeoff instead of hiding it.

Add a second pass: the judge prompt

A definition of done doesn't guarantee the model hits every item — it just makes misses visible. That's what this second prompt is for: run it against the first draft, checklist in hand, before you accept the output.

You are a blunt editor reviewing a draft against a checklist.

Checklist it was supposed to meet:
[PASTE THE DEFINITION OF DONE FROM THE ORIGINAL PROMPT]

The draft:
[PASTE THE DRAFT]

Score each checklist item pass/fail. For anything that fails, name the specific sentence or gap that causes it — no vague notes like "could be stronger." Then give me one rewritten version that actually passes all of them.

This prompt barely changes between tasks — the checklist and the draft are the only variables. Keep it saved somewhere and reuse it across everything you write this way.

What this looks like end to end 📋

Run Prompt 1 with the niche and task filled in, and a typical first draft opens like this:

"Maria closed her bakery's books at 11pm again last night — by hand, in a spreadsheet, for the third time this week. She's not alone. Most small business owners aren't behind on automation because they don't see the value. They're behind because nobody showed them the one process worth fixing first..."

Run that through Prompt 2 against the five-item checklist, and a typical judge response flags the real gap: the piece opens strong (pass), makes one argument (pass), but the "invites a reply" line at the end reads as a generic CTA — a fail, with the exact sentence named. You fix that one line instead of rewriting the whole post.

How to get the most out of it 🎓

• Write the checklist yourself first, in plain words. If you can't say what "good" looks like before you prompt, the model can't hit it either.
• Keep it to five or fewer criteria. More than that and the model starts hedging across all of them instead of nailing any single one.
• Make at least one item falsifiable. A word count, a required element, a specific structure. "Sounds good" isn't checkable — "under 150 words" is.
• Reuse the same judge prompt everywhere. It's the constant. Only the checklist and the draft change per task.

The honest bit ✅

• A checklist doesn't guarantee compliance. Models still skip items sometimes, especially the third or fourth one down the list. That's exactly why the judge pass exists — to catch misses, not prevent them upfront.
• More criteria isn't automatically better. A ten-item checklist produces vague, hedged output that half-touches everything. Five sharp criteria beat ten soft ones.
• The judge pass costs you a second round trip. For genuinely throwaway, low-stakes prompts, doubling your token spend for a formal review isn't worth it.
• This doesn't fix a prompt that's vague about the actual task. A definition of done sharpens the finish line. It doesn't replace giving the model real context about where it's starting from.