Critique-Generate Cycle

The cycle enforces a strict, sequential workflow that separates analysis from synthesis.

• Phase 1: Critique: The model is instructed to act as a reviewer, analyzing its initial draft against specific criteria (e.g., factual accuracy, logical consistency, style guidelines).
• Phase 2: Generate: Using the structured critique as a directive, the model produces a revised output. This phase is explicitly conditioned on the feedback, making the improvement process transparent and auditable.

This separation prevents the model from conflating generation and evaluation, leading to more systematic corrections than a single-step revision prompt.

The core mechanism is the generation of a formal, textual critique. This serves as scaffolded chain-of-thought, externalizing the model's evaluation process.

• The critique must be substantive, listing specific issues, referencing source material, or quoting problematic sections of the draft.
• Examples include: "The third sentence contradicts the data in paragraph two...", or "The conclusion does not address the constraint about cost limitations."
• This explicit step transforms implicit self-assessment into a verifiable artifact, allowing developers to audit the model's "reasoning" about its own errors.

Effective cycles are guided by a clear, prompt-defined rubric. The model does not critique generically but against specified dimensions.

Common evaluation criteria include:

• Factual Consistency: Alignment with provided context or known facts.
• Logical Soundness: Absence of contradictions and valid argument flow.
• Instruction Adherence: Compliance with all task requirements and formatting rules.
• Completeness: Coverage of all query components.
• Style & Tone: Conformance to specified voice, formality, or brand guidelines.

Providing this rubric in the critique instruction focuses the model's analysis and reduces vagueness in the feedback.

This cycle is a primary defense against a model's tendency to generate plausible but incorrect information (hallucination) and to present it with high confidence.

• The critique phase acts as a hallucination self-check, forcing the model to cross-reference claims. An instruction like "Identify any statements not directly supported by the source document" triggers a verification routine.
• It also facilitates uncertainty acknowledgment. The model can flag parts of the draft where it is less confident, which can then be handled cautiously in the revised generation.
• By separating the initial "creative" generation from the critical review, the model often catches its own confident errors.

The cycle is exceptionally effective for ensuring outputs obey complex rules and structured formats.

• In the critique, the model performs a schema compliance check, verifying that a JSON output contains all required fields, uses correct data types, and follows nesting rules.
• It can re-apply guardrails or boundary conditions (e.g., "ensure the total cost does not exceed $1000") that may have been missed in the first draft.
• This makes the technique vital for generating reliable, machine-parsable data in API integrations and automated workflows, where format errors are breaking.

The basic two-step cycle is the building block for more complex autonomous architectures.

• Iterative Revision: The cycle can be repeated, with the output of the second phase becoming the new draft for another round of critique.
• Multi-Agent Self-Review: The pattern can be extended by using different model personas or instances for the critique and generate roles, simulating a panel review.
• Agentic Cognitive Architectures: This loop is a simplified form of the Reflection component in frameworks like ReAct (Reasoning and Acting), where an agent plans, acts, and then reflects on outcomes to inform the next action.

Thus, mastering this prompt pattern is foundational for engineers building sophisticated, self-improving AI systems.

A self-correction loop is the overarching prompting architecture that enables a language model to iteratively critique and revise its own output. It is the structural framework within which a critique-generate cycle operates. Key characteristics include:

• Iterative Nature: The model performs multiple passes of generation and review.
• Explicit Instructions: The loop is driven by clear prompts for critique and revision phases.
• Convergence Goal: The process aims for a stable, improved output that meets predefined quality criteria.

A self-critique prompt is the specific instruction that initiates the 'critique' phase of the cycle. It directs the model to act as an evaluator of its own initial draft. Effective prompts specify evaluation criteria, such as:

• Factual Accuracy: Check against provided sources.
• Logical Consistency: Ensure no internal contradictions.
• Adherence to Format: Verify compliance with JSON schema or other constraints.
• Completeness: Confirm all parts of the query are addressed.

Iterative revision is the process engine of the critique-generate cycle. It refers to the model's action of producing a new, improved output based on the critique. This is not a single edit but often involves multiple cycles where each revision can be critiqued again. This process continues until a stopping condition is met, such as:

• A maximum number of iterations.
• The critique finds no significant errors.
• The output satisfies all validation checks.

Output verification is a critical self-correction instruction that tasks the model with checking its final (or intermediate) response against external or internal standards. It is a broader category that includes the critique phase but emphasizes validation. Common verification targets are:

• Fact-Consistency: Cross-referencing claims with a knowledge base or source text.
• Hallucination Self-Check: Identifying statements not grounded in provided context.
• Schema Compliance: Ensuring structured data matches an exact format.

An internal consistency check is a specific type of critique where the model is prompted to ensure all parts of its generated response are logically coherent and free from contradictions. This check does not require external sources; it analyzes the internal logic of the text. The model looks for:

• Conflicting statements within the same answer.
• Arguments that undermine the main conclusion.
• Explanations that do not follow from stated premises.
• Temporal or causal inconsistencies in a narrative.

A confidence calibration prompt instructs the model to assess and explicitly state its level of certainty in its generated answer. This meta-cognitive step helps mitigate overconfidence in incorrect responses. In a critique-generate cycle, this can be used to flag areas of high uncertainty for more rigorous review in the next iteration. The output often includes:

• A confidence score (e.g., high/medium/low).
• Identification of the least certain factual claims.
• Explicit acknowledgment of information gaps.