When is self-refine (LLM critiques its own draft and revises) a better choice than self-consistency (vote across N parallel samples)?

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.