Self-Critique Prompting

The fundamental mechanism of Self-Critique Prompting is a structured, multi-turn loop. The model first generates an initial response. It is then prompted to act as a critic, analyzing this output for errors, inconsistencies, or areas for improvement based on specific criteria (e.g., factual accuracy, logical coherence, completeness). Finally, it is instructed to produce a revised response incorporating the critique. This creates a closed-loop system for quality enhancement without human intervention.

Example Prompt Structure:

1. Initial Generation: 'Solve this math problem: {problem}'
2. Critique Phase: 'Review your solution. Check for calculation errors, missing steps, or incorrect assumptions.'
3. Revision Phase: 'Now, produce a corrected and final answer.'

Effective self-critique requires the prompt to define clear, actionable evaluation dimensions. Vague instructions like 'make this better' are insufficient. The prompt must specify what aspects of the output to scrutinize.

Common criteria include:

• Factual Grounding: Verify claims against provided context or known facts.
• Logical Consistency: Ensure the argument's steps follow coherently.
• Completeness: Check if all parts of the query are addressed.
• Format Compliance: Validate adherence to requested structures like JSON or XML.
• Safety & Alignment: Flag harmful, biased, or unethical content.

Providing a rubric or checklist within the prompt guides the model's internal evaluation process, making the critique more systematic and reliable.

A key design pattern is to explicitly assign distinct roles or personas to the model for different stages of the process. This mitigates the model's tendency to be anchored to its initial, potentially flawed, reasoning.

Standard Personas:

• The Generator: Responsible for the initial draft or answer.
• The Critic/Evaluator: Tasked with impartial analysis, fault-finding, and suggesting improvements.
• The Editor/Refiner: Synthesizes the original output and the critique into a polished final version.

This separation is often enforced via system prompts (e.g., 'You are a harsh scientific reviewer') or explicit stage instructions (e.g., 'Now, switch roles. You are an editor reviewing the following text...'). It helps overcome cognitive fixedness in the model's single forward pass.

A core challenge Self-Critique aims to address is a model's confirmation bias—its propensity to overconfidently assert its first answer without scrutiny. The technique forces a decoupling between generation and verification.

How it works:

• By instructing the model to 'find flaws,' it activates a different, more skeptical reasoning mode.
• This can surface reasoning shortcuts, hallucinations, or logical leaps that were initially overlooked.
• The process is analogous to a human writer proofreading their own work after a break, gaining a fresh perspective.

Limitation: The critique's quality is bounded by the model's own knowledge and reasoning capabilities. It cannot identify errors outside its latent knowledge space without access to external tools (e.g., a calculator, search API).

Advanced implementations of Self-Critique extend beyond internal verification by incorporating tool use. The model's critique phase can include plans to verify its claims using external resources, blending self-critique with frameworks like ReAct (Reasoning + Acting).

Example Flow:

1. Model generates an answer stating a historical date.
2. In the critique phase, it reasons: 'I should verify this date using a reliable database.'
3. It calls a tool/function (e.g., a search API or knowledge graph query) to retrieve the correct date.
4. It revises its answer based on the tool's output.

This creates a hybrid closed-open loop, where the self-critique triggers factual grounding actions, dramatically improving accuracy for knowledge-intensive tasks.

Self-Critique Prompting is often conflated with other Chain-of-Thought methods. Key differentiators:

• vs. Chain-of-Thought (CoT): CoT generates a step-by-step reasoning trace leading to an answer. Self-Critique generates an answer and then a meta-evaluation of that answer/reasoning.
• vs. Self-Consistency: Self-Consistency samples multiple independent reasoning paths and votes on the final answer. Self-Critique iteratively refines a single reasoning path.
• vs. Chain-of-Verification (CoVe): CoVe is a specific, structured instance of self-critique focused on factual claims. It involves generating independent verification questions and answers. Self-Critique is the broader paradigm encompassing CoVe.
• vs. Process Supervision: Process Supervision is a training method using step-by-step rewards. Self-Critique is an inference-time prompting technique that mimics this process.

The foundational technique that enables Self-Critique. Chain-of-Thought Prompting instructs a language model to generate an explicit, step-by-step reasoning trace before delivering a final answer. This decomposition of the problem is a prerequisite for effective self-evaluation, as the critique must operate on a visible reasoning process, not just a black-box output.

• Core Mechanism: Adds the instruction 'Let's think step by step' or provides few-shot examples with intermediate reasoning.
• Relation to Self-Critique: Self-Critique typically evaluates and refines the reasoning chain produced by a CoT prompt, making CoT the 'generate' step in a 'generate-then-critique' loop.

A decoding strategy that leverages multiple reasoning paths to arrive at a more robust answer. Self-Consistency works by sampling several diverse Chain-of-Thought reasoning paths from a model for a single question and then selecting the most frequent final answer via majority vote.

• Core Mechanism: Generates multiple outputs, then uses statistical aggregation (voting) on the final answers.
• Contrast with Self-Critique: While Self-Consistency uses multiple independent samples, Self-Critique uses iterative refinement of a single sample. They can be combined: a model could critique each of several chains before the final vote.

A framework that interleaves reasoning with external actions. In ReAct, a model generates a verbal reasoning trace (Thought), decides on an action (Act) like a tool or API call, observes the result (Observation), and repeats. Self-Critique can be integrated into the Thought step to improve action planning.

• Core Mechanism: Cyclic pattern of: Thought → Act → Observation → Thought...
• Relation to Self-Critique: The Thought phase can include a self-critique of the previous action's result or the next planned action, making the agent more deliberative and less prone to error cascades. For example, 'Based on the observed error, my previous plan was flawed because...'

A framework that models reasoning as a heuristic search over a tree of possible solution paths. Tree of Thoughts extends Chain-of-Thought by allowing a model to explore multiple reasoning directions, evaluate intermediate states, and backtrack—mimicking a deliberate problem-solving process.

• Core Mechanism: At each step, the model generates multiple potential 'thoughts,' evaluates them, and selects the most promising to explore further.
• Relation to Self-Critique: The evaluation function in ToT is a form of self-critique applied to partial solutions. The model critiques its own intermediate thoughts to decide which branch of the reasoning tree to prune or pursue, making critique central to the search algorithm.

A structured method for fact-checking a model's own claims. Chain-of-Verification involves four stages: 1) Generate a baseline answer, 2) Plan verification questions to check the answer's facts, 3) Answer those questions independently (avoiding bias from the original answer), 4) Produce a final, revised answer.

• Core Mechanism: Isolates the verification step to prevent the model from confirming its own hallucinations.
• Contrast with Self-Critique: CoVe is a more rigorous, audit-focused variant. While general Self-Critique might ask 'Is this answer good?', CoVe specifically generates and executes a plan to fact-check discrete claims, making it highly suitable for reducing hallucinations in knowledge-intensive tasks.

A training paradigm that provides feedback on each step of reasoning. Process Supervision involves training a model (often via reinforcement learning) to produce correct reasoning chains by rewarding each individual valid step, not just the final answer. This creates an internalized 'critic'.

• Core Mechanism: Uses a reward model or training signal that evaluates intermediate reasoning steps.
• Relation to Self-Critique: Process Supervision is a training-time method to instill robust reasoning and self-critique capabilities. In contrast, Self-Critique Prompting is an inference-time technique applied to a pre-trained model. A model trained with Process Supervision is inherently better at executing Self-Critique prompts.