Self-refine is a prompting pattern where the same LLM plays three roles in a loop: author (produces a draft), critic (reviews the draft and lists specific issues), reviser (rewrites the draft to address the critique). Each round of author + critic + reviser is one 'refine' step; the loop typically runs 1-3 rounds before terminating. The technique improves quality on tasks where a critique then revise pattern is a natural fit (writing, code, structured arguments) and adds little on tasks the first draft already nails. Cost is roughly 3x a one-shot prompt per round.
**Self-refine** is a three-step loop where the same language model plays three different roles in sequence: author, critic, and reviser.
The author step is a normal prompt: produce a draft of whatever you are asking for, like a summary, a piece of code, an email, an argument. The critic step takes that draft and asks the same model, 'review this draft. What is wrong with it? What could be sharper, clearer, more correct?' The reviser step takes the original draft and the critique and asks, 'rewrite the draft to address each point in the critique.'
One round of author plus critic plus reviser is one 'refine' step. You can loop the critic plus reviser pair for 1 to 3 rounds before deciding the output is good enough. After each loop, the output is usually a bit better than the previous one.
The core insight is that critiquing one's own work is often easier than producing perfect work in one pass. Splitting the labor into separate prompts gives the model a chance to find and fix issues it would have missed in a single attempt.
**Self-refine** is a prompting pattern that decomposes a generation task into three sequential roles, all played by the same LLM with no fine-tuning: author (produce a draft), critic (review the draft and list specific issues), reviser (rewrite to address each issue). One round equals one author + critic + reviser cycle; in practice the loop runs 1-3 rounds before terminating.
The motivation is that finding flaws in a piece of work is often easier than producing flawless work directly. When the model is asked to critique an existing draft, it can compare against criteria, notice missing pieces, and flag inconsistencies it would have missed during generation. The reviser then has a structured set of issues to address rather than starting from a blank page.
The technique was formalized in Madaan et al. 2023 (Self-Refine: Iterative Refinement with Self-Feedback) and has become a standard component in agent loops. Production examples: AutoGPT-style agents critiquing their own plans, code-generation tools like Cursor doing draft, critique, fix loops, content tools running tone or style checks across rounds.
Where it works best: writing and editing, code with stylistic or correctness issues, structured arguments, math solutions with verifiable steps. Where it underdelivers: factual recall (the critic shares the author's blind spots), tasks where the first draft is already correct, time-sensitive tasks where the 3x token and latency cost are unacceptable.
Quick reference
TL;DR
Self-refine has the same model produce a draft, critique its own draft, and revise based on the critique, looping the author, critic, reviser cycle 1-3 times to improve quality.
Imagine you write an essay, then put on a teacher hat and mark up your own essay with red pen, then put on a student hat again and rewrite it taking the red pen seriously. Then you do it once more. Each pass usually makes the essay a bit better than the last. Self-refine is the language-model version of that habit. The model writes a draft, then a critic prompt asks the same model to find problems with the draft, then a reviser prompt asks the same model to fix those problems. The model is doing all three jobs in turn, with no fine-tuning between them; the critique is the bridge that makes the revision better than just asking the model to try again.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
The failure mode is factual error rather than stylistic or structural issues The critic is the same model as the author and shares its knowledge gaps; retrieval, tool use, or an external verifier catches facts more reliably.
Interactive UX with tight latency budgets Each refine round is roughly three sequential LLM calls; a 2-round loop adds seconds of latency that interactive products cannot afford.
Simple tasks where the first draft is reliably correct Self-refine adds 3x cost per round; on tasks the model nails one-shot, the extra calls are pure overhead with no quality lift.
Quick scan · 2–4 min
Everything important, quickly.
3 min: define self-refine as author + critic + reviser loop, name the same-model property, contrast where it helps versus where it shares blind spots, and call out the call-count cost.
Real-world examples
Real products, models, and research that use this idea.
1Cursor and Copilot Chat use draft, critique, fix loops on code edits, asking the model to review its own diff against the user's intent before committing.
2Anthropic's prompt-engineering cookbooks show self-refine patterns for long-form writing tasks with Claude Opus 4.7, capped at 2 rounds.
3AutoGPT-style agents run self-refine on their plans: generate a plan, critique it against constraints, regenerate before executing.
4Open-source frameworks like DSPy and LangChain ship self-refine primitives so teams can wire author + critic + reviser prompts without rewriting the loop.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhy does self-refine help even when the critic and author are the same model?
Sign in or go Pro to see the approach for this follow-up.
QWhen would you use a different model for the critic step?
Sign in or go Pro to see the approach for this follow-up.
QHow do you decide whether self-refine is worth the 3x cost for your use case?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Believing self-refine is a generic quality boost on every task. The pattern helps on outputs that benefit from critique (writing, code, arguments) and adds cost without quality on tasks where the first draft is already correct.