Self-Critique Prompt

A standard self-critique prompt follows a critique-generate cycle. The model is first instructed to produce an initial draft. In the second phase, it is given a specific rubric to analyze that draft for errors, inconsistencies, or missing elements. Finally, it synthesizes this critique to produce a revised, higher-quality final output. This separates the generative and evaluative cognitive modes, reducing bias and improving objectivity.

Effectiveness hinges on providing the model with a concrete, actionable evaluation rubric. Vague instructions like "check for errors" are insufficient. Effective rubrics specify criteria such as:

• Factual consistency against provided sources
• Logical coherence and absence of contradictions
• Completeness in addressing all query parts
• Adherence to format (JSON, XML)
• Clarity and conciseness, flagging redundancy This structured checklist guides the model's internal audit process.

A primary application is the hallucination self-check. The prompt explicitly tasks the model with verifying that every factual claim in its output is grounded in the provided context or its general knowledge, flagging potential fabrications. This often involves a grounding prompt that requires the model to cite source excerpts for key claims. This technique directly addresses one of the most critical reliability challenges in LLM deployment.

Beyond facts, self-critique prompts enforce internal consistency and sound reasoning. This includes:

• Logical fallacy detection (e.g., identifying straw man arguments)
• Assumption checking to surface implicit premises
• Stepwise verification of multi-step reasoning chains
• Schema compliance checks for structured data outputs
• Ambiguity resolution to rephrase vague statements These components transform the model into a preliminary quality assurance agent for its own work.

Self-critique can be directed toward alignment and safety through instructions like a bias self-scan or toxicity self-filter. The model reviews its output for potential demographic, cultural, or cognitive biases, as well as harmful or inappropriate content. A more advanced form is constitutional self-review, where the output is evaluated against a predefined set of ethical or safety principles, prompting censorship or rewriting if violations are found.

Self-critique is rarely a standalone operation. It is a core subroutine within larger agentic frameworks:

• In a ReAct loop, it acts as the reflection step.
• It enables iterative revision within a self-correction loop.
• Multi-agent self-review architectures use multiple model instances to critique a single output, simulating panel review.
• It provides the reasoning trace and confidence calibration needed for observability and trust in production systems.

This is the most common application, where a model is instructed to verify its factual claims against a provided source context or its training data. The prompt typically directs the model to:

• Flag unsupported statements that lack explicit grounding.
• Cite specific source excerpts for each claim.
• Revise or retract any identified fabrications. This is critical for Retrieval-Augmented Generation (RAG) systems, technical documentation, and any domain requiring high factual fidelity.

Here, the model acts as its own code reviewer. A self-critique prompt tasks it with analyzing generated code for:

• Syntax errors and runtime exceptions.
• Logical bugs and edge case failures.
• Security vulnerabilities like injection risks.
• Performance inefficiencies (e.g., O(n²) algorithms). The model then produces a corrected version. This is foundational for Program-Aided Language Models (PAL) and automated software development tools.

Self-critique prompts enforce constitutional AI principles and content safety policies. The model is prompted to review its output through specific lenses:

• Toxicity Detection: Identifying harmful, offensive, or inappropriate language.
• Bias Self-Scan: Checking for demographic, cultural, or cognitive biases in reasoning or recommendations.
• Ethical Compliance: Ensuring outputs align with predefined safety rules (e.g., no instructions for harm). The model must then censor, rewrite, or flag the problematic content.

When generating JSON, XML, or YAML, a self-critique prompt ensures strict schema compliance. The model is instructed to:

• Verify all required fields are present and correctly named.
• Validate data types (e.g., string, integer, array).
• Check for adherence to enumerations or value constraints.
• Ensure the structure is parseable by standard libraries. This is essential for reliable API integration and function calling workflows.

This application focuses on the logical soundness of the model's reasoning chain. The prompt guides an internal consistency check and logical audit:

• Identifying logical fallacies (e.g., straw man, false dilemma).
• Checking for contradictions between different parts of the response.
• Validating assumptions made during reasoning.
• Ensuring stepwise verification in a Chain-of-Thought process. This is vital for complex analysis, legal reasoning, and strategic planning tasks.

A self-critique prompt can direct the model to perform a final review against the original user query or system instructions. This completeness verification includes:

• Confirming all sub-tasks in a complex instruction have been addressed.
• Checking that all explicit constraints (e.g., word count, format, perspective) are satisfied.
• Pruning redundant information to improve conciseness.
• Resolving ambiguities for greater precision. This closes the loop in prompt chaining and complex task decomposition.

A self-correction loop is a prompting architecture that embeds the self-critique process into an iterative cycle. The model generates an output, critiques it based on provided criteria, and then revises the output. This loop can be repeated multiple times until a satisfactory result is achieved or a termination condition is met.

• Key Mechanism: Explicitly structures the prompt to include generation, critique, and revision as distinct, repeatable phases.
• Primary Use: Complex reasoning tasks, code generation, and long-form content creation where a single pass is insufficient.
• Distinction from Basic Self-Critique: A self-critique prompt may be a one-off instruction, while a loop formalizes the process into a recursive control flow.

The critique-generate cycle is the fundamental two-step unit of a self-correction loop. First, the model (or a separate 'critic' instance) produces a detailed critique of a draft, identifying errors, inconsistencies, or areas for improvement. Second, a 'generator' model (often the same instance) uses that critique to produce a revised output.

• Common Pattern: Often implemented as a single prompt with clear role instructions: 'First, critique this draft. Second, write an improved version based on your critique.'
• Architectural Variant: Can be implemented using two separate model calls or specialized personas to separate the critique and generation functions for higher objectivity.

A hallucination self-check is a specialized self-critique instruction that directs the model to verify the factual grounding of its output. The model is tasked with distinguishing statements supported by its source context or reliable knowledge from unsupported fabrications.

• Core Instruction: 'Review your answer. For each factual claim, cite the exact sentence from the provided document that supports it. If no support exists, flag the claim as "unsupported."'
• Critical for RAG: A foundational technique in Retrieval-Augmented Generation (RAG) systems to ensure generated answers are faithful to retrieved documents.
• Output: Often results in an annotated response or a separate verification report.

An internal consistency check is a self-critique task focused on logical coherence. The model is prompted to scan its generated text for contradictions, conflicting statements, or narrative/argumentative discontinuities that undermine the validity of the response.

• Scope: Applied within a single output. For example, ensuring a character's age doesn't change in a story, or that an argument's premises align with its conclusion.
• Method: Instructions often ask the model to list all key assertions and then check them against each other.
• Distinction from Fact-Consistency: Focuses on logical integrity within the generated text itself, not necessarily alignment with external sources.

A confidence calibration prompt guides the model to assess and explicitly state its level of certainty in its generated answer. This is a meta-cognitive self-critique aimed at mitigating overconfidence in incorrect responses and providing a useful signal for downstream processing.

• Typical Format: 'Provide your answer, then assign a confidence score from 0-100% and justify that score based on the clarity of the question and the strength of the evidence in your reasoning.'
• Application: Used in decision-support systems where knowing the model's uncertainty is as important as the answer itself. Low-confidence outputs can be flagged for human review.
• Related to: Uncertainty Acknowledgment, which focuses on identifying specific knowledge gaps.

Constitutional self-review is a self-critique process where the model evaluates its output against a predefined set of principles or rules—a 'constitution.' This constitution defines desired behavioral traits such as helpfulness, harmlessness, honesty, or compliance with specific ethical and legal guidelines.

• Process: The prompt instructs the model: 'Review your response against the following principles: [Principle 1, Principle 2...]. If any principle is violated, rewrite the response to comply.'
• Origin: Inspired by Anthropic's Constitutional AI training methodology, adapted here as a prompt-time self-governance mechanism.
• Use Case: Enforcing safety and alignment guardrails in applications without relying solely on pre-trained model safeguards.