Self-refine and self-consistency are two different ways to spend extra compute on a single task. They target different shapes of task and they are not interchangeable.
Self-refine is sequential. The model writes a draft, then the model critiques the draft, then the model revises based on the critique. It is one thread, three passes. The pattern works when the output is an evaluable artifact the model can inspect: a chunk of code, a piece of prose, a summary, a plan. The critique pass spots issues that the original draft missed; the revision pass fixes them.
Self-consistency is parallel. The model produces N independent reasoning paths at temperature greater than zero, then a vote picks the most common final answer. It works when the task has a discrete answer to vote on: a number, a classification label, a decision. The diversity across paths is the signal; the vote concentrates on the consensus.
The rule for picking between them is the shape of the output. Evaluable artifact, use self-refine. Discrete answer, use self-consistency. Picking the wrong one wastes compute and rarely lifts accuracy.
**Self-refine** and **self-consistency** are two amplification techniques for LLM output, and they target different task shapes. The choice between them is structural, not preferential.
Self-refine is sequential single-thread. The model drafts, then critiques the draft against a quality rubric, then revises based on the critique. The pattern shines when the output is an evaluable artifact the model can inspect and improve incrementally. Examples include code with bugs to spot, prose with rough sentences to smooth, summaries missing key claims, plans with weak steps. The critique pass identifies concrete improvement opportunities; the revision pass implements them. The gain compounds when the rubric is sharp.
Self-consistency is parallel multi-sample voting. The model produces N independent CoT samples at temperature greater than zero and a vote picks the majority final answer. The pattern shines when the task has a discrete answer (number, label, decision) where consensus across diverse reasoning paths concentrates signal that single-pass CoT loses. Math word problems, multi-hop QA, classification with reasoning all fit cleanly.
The artifact vs answer distinction is what drives the decision. Self-refine cannot vote because there is nothing discrete to count. Self-consistency cannot iteratively improve because the parallel samples never see each other. Picking the wrong technique either burns compute with no lift (self-refine on math) or misses the gain available (self-consistency on a code-review task). Modern production code routes by task shape, often with a cheap classifier deciding which technique to invoke per request.
Quick reference
TL;DR
Self-refine fits evaluable artifacts (code, prose, summaries) the model can critique and rewrite; self-consistency fits discrete answers (numbers, labels) where voting across paths concentrates signal.
Think about how you improve different kinds of work. If you wrote an essay, you read it, find the rough patches, and rewrite them. That is self-refine. If you are solving a hard puzzle and you are not sure of the answer, you might solve it five times in slightly different ways and trust the answer that comes up most often. That is self-consistency. Self-refine works when there is something concrete to look at and fix. Self-consistency works when there is one right answer hiding somewhere and you want to vote on it. Math homework is closer to the puzzle. A code review is closer to the essay. Picking the wrong technique is like editing your puzzle answer or voting on essay sentences.
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.
Self-refine on arithmetic-heavy reasoning The same blind spot that produced the wrong arithmetic survives the critique pass; the critique tends to launder errors rather than catch them.
Self-consistency on free-form generative tasks Voting needs a countable answer; on open-ended generation there is no clean target for the vote and the parallel samples cannot be aggregated.
Latency-bounded interactive routes Both techniques multiply latency (self-refine sequentially, self-consistency in parallel); on tight p95 budgets the cost rarely justifies the lift.
Quick scan · 2–4 min
Everything important, quickly.
3 min: artifact-shape selection rule, where each technique fails, and how the two layer in hybrid production routes.
Real-world examples
Real products, models, and research that use this idea.
1Code-generation routes in 2025 production agents pipe linter or test output back into a self-refine critique pass before committing the final code.
2Math tutoring routes use self-consistency at N=5 to N=10 to catch arithmetic slips that single-pass CoT misses.
3Multi-step planning agents combine self-consistency over the plan-selection step with self-refine over the execution-step output, applying each technique at its native granularity.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhy does self-refine often fail to catch arithmetic errors in a critique pass?
Sign in or go Pro to see the approach for this follow-up.
QHow would you combine both techniques in a single production pipeline?
Sign in or go Pro to see the approach for this follow-up.
QWhat does a sharp rubric look like for self-refine on a summarization task?
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
Treating self-refine and self-consistency as interchangeable accuracy boosters instead of matching them to artifact-shape (evaluable vs discrete answer).