Flashcard: what is the self-refine prompting pattern and what loop does it set up?

Flashcard·Easy·4.0 · 0·~30s·Asked atNiki Ai Sambanova Zoho·Relevant atAnthropic

Attempt it

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.

Your answer

**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.

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.

Memory aid

Easy to grasp

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.

Key concepts

Self-refine Iterative refinement Self-critique

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Self-refine is one of the cleanest examples of a 'pattern, not a prompt' in modern prompt engineering. It is not a single prompt template; it is a loop of three prompts run in sequence, where the same LLM plays three different roles and each role's output feeds the next. Once you see the pattern, you start noticing it inside every agent framework and most prompt engineering cookbooks.

The technique was formalized by Madaan et al. in 2023 (Self-Refine: Iterative Refinement with Self-Feedback) and has held up well because the intuition behind it is sound: critique is often easier than authoring, and the same model can play both roles with different prompts.

This deep dive defines self-refine precisely, walks through the three roles and why splitting them helps, names the limits the pattern hits in production, and explains how to combine self-refine with related techniques like external verification and multi-model critique.

The three roles and the loop they form

Self-refine decomposes a generation task into three sequential prompts.

The author prompt is the baseline: 'Given this input, produce X.' It is whatever you would have written as a single-shot prompt before introducing self-refine. The output is a first draft.

The critic prompt takes the draft as input: 'Here is a draft of X. Review it. List specific issues with the draft. For each issue, describe what is wrong and what would make it better.' The critic prompt benefits enormously from concrete criteria; a critic told to 'review against accuracy, clarity, format, and tone' produces sharper critiques than one told to 'review and suggest improvements.'

The reviser prompt takes the original draft and the critique: 'Here is the draft. Here is the critique. Rewrite the draft to address each point in the critique while preserving what was working.' The reviser is constrained by the critique, which keeps the revision focused on identified problems rather than wholesale rewrites.

One author + critic + reviser cycle is one 'refine' step. The loop can run multiple rounds: take the revised draft, critique it again, revise again. Madaan et al. found 1-3 rounds typical, with most gain in round 1 and diminishing returns thereafter.

Why splitting the labor helps

Where self-refine wins and where it does not

Cost, round-count, and production patterns

Writing the critic prompt: rubrics beat vague review requests

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Cursor 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.
Anthropic's prompt-engineering cookbooks show self-refine patterns for long-form writing tasks with Claude Opus 4.7, capped at 2 rounds.

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?

Generation and evaluation bias the same prior differently; the model can compare a draft to criteria and notice issues it would not have noticed while generating. This is local lift, not knowledge expansion.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases 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.

60 second bullets to scan on the way to the call.

Name the three roles in the self-refine loop and what each does
Explain why critique is often easier than authoring from scratch

Primary sources. Browse if you want the original framing.