Most people who meta-prompt do it intuitively, which works until it does not. The trouble with intuition is that it cannot be taught, audited, or improved deliberately. A named framework fixes that. It gives you stages to point at, a vocabulary to discuss what went wrong, and a structure newcomers can follow without absorbing years of feel.
The model presented here is deliberately simple: three stages arranged in a loop, plus a clear rule for when to exit. It is called the Draft-Critique-Refine loop, and its value is less in novelty than in being explicit. Naming the stages turns a vague habit into a repeatable process you can hand to someone else.
This is a thinking tool, not a rigid procedure. The stages map onto how good meta-prompting already feels when it goes well; the framework just makes that shape visible so you can apply it on purpose.
Stage One: Draft
The loop opens by producing a candidate prompt from a clear target.
What Happens Here
You describe the desired outcome and constraints, then ask the model to generate a prompt. The output is explicitly a first attempt, not a finished artifact. Treating it as a draft from the start sets the right expectations for everything that follows.
When to Apply It
Use the draft stage whenever you are starting fresh or whenever an existing prompt has drifted far enough that rebuilding beats patching. The cost of drafting is low, so reaching for it early is usually right, as shown in Build Prompts That Generate Better Prompts, Step by Step.
Stage Two: Critique
The second stage subjects the draft to deliberate scrutiny.
What Happens Here
You inspect the draft yourself and, separately, ask the model to critique it. Your inspection catches invented constraints and dropped requirements. The model's self-critique surfaces structural weaknesses you might miss. The two perspectives together are stronger than either alone.
The Critical Discipline
Critique must be a distinct act, not blurred into drafting. If you let the model revise while critiquing, you lose the clean read that catches silent errors, a failure detailed in Seven Ways Self-Writing Prompts Quietly Go Wrong.
When to Apply It
Always, on every draft, before any testing. Critique is cheap and catches the cheapest-to-fix problems. Skipping it is the single most common reason the loop fails.
Stage Three: Refine
The third stage turns critique into a concrete revision and tests it.
What Happens Here
You feed specific, case-named feedback to the model and ask for a targeted revision. Then you run the revised prompt on three to five real inputs and compare against a baseline. Refinement without testing is guessing; the test batch is what makes it empirical.
Feed It Specifics
The quality of a refinement tracks the specificity of your feedback. "Too formal on example two" produces a precise fix; "make it better" produces random change. Name the case, the failure, and the desired change every time.
Closing the Loop
A loop without an exit runs forever, so the framework includes a stopping rule.
The Exit Condition
Return to critique and refine until two consecutive rounds produce equal quality. That plateau is your signal to stop. It is observable and simple, which keeps you from optimizing past the point of return.
Locking the Result
Once the loop exits, the prompt graduates from experiment to asset. Store it with its purpose and boundaries so the work compounds, the practice that powered the result in How an Agency Cut Prompt Drafting Time by Half.
Why a Named Framework Helps
The structure earns its keep in three concrete ways.
It Makes Failure Diagnosable
When a meta-prompting effort goes wrong, you can locate the stage: weak target in drafting, skipped inspection in critique, vague feedback in refinement. Naming the stage names the fix.
It Transfers to Others
A framework is teachable in a way intuition is not. New team members can run Draft-Critique-Refine on their first day and produce sound prompts, because the structure carries the judgment.
It Resists Bad Habits
The explicit critique stage forces inspection, and the explicit exit condition forces a stop. The framework's structure pushes back against the two most common meta-prompting failures by design.
Applying the Loop to a Real Task
A framework is only as good as its behavior under pressure, so consider how Draft-Critique-Refine handles a concrete job.
Drafting Against a Clear Target
Say you need a prompt for summarizing customer feedback into themes. You describe the outcome, summaries grouped into three to five named themes, with constraints on length and neutrality, and ask the model to draft a prompt. The draft is your raw material, deliberately provisional.
Critiquing From Two Angles
You read the draft and notice it never specifies how to handle contradictory feedback. Separately, you ask the model to critique its own draft, and it flags that the theme count could balloon without a cap. Your inspection caught a content gap; the model's self-review caught a structural one. Together they produce a sharper revision target than either would alone.
Refining to a Plateau
You feed both issues back as specific instructions, test the revised prompt on several real feedback batches, and find it now holds steady. A second round changes little, so you stop and store the prompt. The loop closed cleanly because each stage did its distinct job.
Where the Framework Has Limits
No model fits every situation, and knowing the edges keeps you from misapplying it.
It Assumes a Definable Outcome
Draft-Critique-Refine needs a target to design toward. For genuinely exploratory work where you do not yet know what good looks like, the framework stalls at the drafting stage. In those cases, use generation to surface options and clarify your intent first, then return to the loop once a target exists.
It Is Overkill for Trivial Tasks
Running three stages and a stopping rule on a quick, one-time request wastes effort. The framework is built for prompts worth reusing. Match its weight to the stakes, and reach for a direct request when the task does not justify the loop.
Teaching the Framework to a Team
One of the strongest arguments for naming the loop is that it travels. Here is how to hand it off well.
Give People the Vocabulary First
Before walking through a task, make sure everyone knows what Draft, Critique, and Refine each mean and, crucially, that Critique is a distinct stage rather than part of revising. The shared vocabulary lets a team diagnose problems together: someone can say a prompt failed because critique was skipped, and everyone knows exactly what that means.
Demonstrate the Exit Condition
The stopping rule is the part people most often ignore, because stopping feels like giving up. Show a live example where two rounds produce equal quality and you stop, and the discipline becomes concrete. Watching the rule applied is far more persuasive than reading it.
Let the Structure Carry Newcomers
The whole point of a framework is that it encodes judgment newcomers have not yet developed. A person on their first day can run Draft-Critique-Refine and produce a sound prompt, because the stages enforce the inspection and the stopping that experience would otherwise have to teach. Trust the structure to do that work.
Frequently Asked Questions
Is this framework different from generic iteration?
Yes, in two ways: critique is a mandatory, distinct stage rather than something folded into revision, and the exit condition is explicit. Those two additions are what make the loop reliable rather than open-ended.
How many times does the loop usually run?
Two to four passes for most tasks. If you are well past that and still changing things, the task is probably too broad and should be split into smaller prompts.
Can I skip the critique stage if the draft looks good?
No. A draft looking good is exactly when critique pays off, because silent failures hide behind polished prose. The stage is non-negotiable precisely when you feel like skipping it.
Does the framework need special tooling?
Not at all. It runs in any chat window. Tools help you store and version prompts once your library grows, but the loop itself is purely a way of working.
Key Takeaways
- The framework is a three-stage loop: Draft, Critique, Refine, with an explicit exit.
- Draft produces a candidate; treat it as a first attempt, never a finished prompt.
- Critique is a mandatory, distinct stage combining your inspection and the model's self-review.
- Refine with specific, case-named feedback and a real test batch, not guesses.
- Exit when two rounds give equal quality, then store the prompt as a reusable asset.