Iterative Revision

Iterative revision operates through a closed-loop system where the model's output becomes the input for the next evaluation cycle. This is not a single check but a recursive process where each iteration refines the previous one. The cycle typically involves:

• Generation of a draft response.
• Critique against specific criteria (e.g., accuracy, structure).
• Revision based on the critique. This loop continues until a termination condition is met, such as a maximum number of cycles, satisfaction of all criteria, or convergence where no further improvements are identified.

The process is driven by explicit, pre-defined rubrics provided in the system prompt. These criteria act as the objective function for the model's self-assessment. Common criteria include:

• Factual Consistency: Verification against source context to prevent hallucinations.
• Logical Coherence: Ensuring arguments follow sound reasoning without internal contradictions.
• Completeness: Addressing all sub-questions or requirements from the original query.
• Format Compliance: Adherence to specified output schemas like JSON or XML. Without these concrete criteria, the revision process lacks direction and can diverge or optimize for irrelevant attributes.

A key architectural feature is the functional separation between the critique phase and the revision phase. While often performed by the same model instance, the prompt instructs the model to adopt distinct mental frameworks:

1. Analyst Persona: The model acts as a critic, tasked solely with identifying flaws, gaps, or deviations from the criteria.
2. Editor Persona: The model, using the critique as a guide, rewrites the output to address the identified issues. This separation mitigates confirmation bias, where the model might overlook errors in its own initial reasoning, by forcing an explicit intermediate analysis step.

The model must maintain a persistent context that includes the original query, the evaluation criteria, all previous draft versions, and the associated critiques. This allows each new revision to be informed by the entire history of the process, preventing it from repeating past mistakes or oscillating between solutions. Effective prompt engineering uses techniques like numbered versions or explicit references (e.g., 'Based on Critique #2 regarding factual accuracy, revise the third paragraph...') to manage this state within the context window.

Iterative revision requires deterministic stopping rules to prevent infinite loops. These conditions are specified in the initial instructions and can include:

• Cycle Limit: A hard cap on the number of revisions (e.g., max_revisions: 3).
• Criteria Satisfaction: Proceeding until the model self-assesses that all rubrics are fully met.
• Convergence Detection: Stopping when consecutive revisions yield negligible changes (e.g., semantic similarity between drafts exceeds a threshold).
• Timeout: A fallback based on token count or processing time. Defining these conditions is crucial for production reliability and cost control.

This technique is particularly powerful for multi-step reasoning tasks like mathematical problem-solving, code generation, or legal analysis. The model breaks the task into steps, generates a solution, and then iteratively revises each logical segment. For example, in code generation, the cycle might be:

1. Generate initial function.
2. Self-critique for syntax errors, edge cases, and efficiency.
3. Revise code.
4. Self-critique again by writing test cases.
5. Final revision. This transforms the model from a one-shot generator into a reasoning engine capable of debugging its own logic.

Used for drafting reports, articles, or documentation, this process involves multi-perspective review and redundancy pruning. The model is instructed to:

• Generate an initial draft.
• Critique the draft for structure, flow, and argument strength.
• Identify and remove repetitive sections.
• Check for internal consistency of facts and claims.
• Rewrite the introduction and conclusion for impact.

Example Prompt: "Draft a 500-word blog post on quantum encryption. Then, act as an editor. Critique the draft's clarity, identify any redundant paragraphs, and ensure the explanation progresses logically from basics to implications. Provide the revised post."

Critical for turning unstructured text into clean JSON or XML. The model performs a schema compliance check and completeness verification. Steps include:

• First pass: Extract entities and relationships into the target schema.
• Second pass: Validate all required fields are populated with correct data types.
• Third pass: Cross-reference extracted values with the source text for fact-consistency.
• Output the validated, schema-compliant object.

Example Prompt: "From the following product description, extract attributes into this JSON schema: {name: string, price: number, features: array}. Then, review your JSON. Confirm each value is directly supported by the text, all fields are present, and data types are correct. Output the final JSON."

Applied to mathematical, legal, or strategic problems, this uses stepwise verification and assumption checking. The model:

• Generates an initial solution with step-by-step reasoning.
• Re-examines each logical step for validity, flagging potential logical fallacies.
• Explicitly states and validates all implicit assumptions.
• Considers counterfactual testing (e.g., "What if this variable were zero?").
• Produces a final, audited solution with a reasoning trace.

Example Prompt: "Solve this logic puzzle. Show your reasoning. Then, review your solution. Verify each deductive step is sound and list any assumptions you made. Are there alternative interpretations? Provide the final, verified answer."

Enhances narratives, poetry, or marketing copy through ambiguity resolution and constraint re-application. The cycle involves:

• Generating a creative piece (e.g., a story opening).
• Critiquing for narrative coherence, character motivation, and emotional impact.
• Resolving vague or confusing passages.
• Ensuring the final output strictly adheres to initial constraints (e.g., genre, tone, word limit).
• Applying a final polish for language and rhythm.

Example Prompt: "Write a 100-word sci-fi story hook about a lost AI. Then, critique your hook. Is the setting clear? Is the AI's 'lost' state compelling? Remove any ambiguous phrases. Finally, rewrite the hook to be more vivid and within the word limit."

A self-correction loop is the fundamental control structure for iterative revision. It is a prompting technique where a language model is instructed to iteratively critique and revise its own output to improve accuracy, coherence, or adherence to constraints. The loop typically consists of:

• Generation: Producing an initial draft.
• Critique: Analyzing the draft for errors or areas of improvement.
• Revision: Generating a new, improved version. This cycle repeats until a termination condition is met, such as a maximum number of iterations or satisfaction of predefined quality criteria.

The critique-generate cycle is the core two-phase operational unit within an iterative revision process. In this pattern, the model first produces a detailed critique of a draft response, identifying flaws, inconsistencies, or missing elements. It then uses that critique as a directive to generate a refined version. This explicit separation of evaluation and synthesis phases often yields more substantial improvements than a single, monolithic revision instruction. It is a key component of frameworks like ReAct (Reasoning and Acting) where the 'reasoning' step acts as the critique.

Stepwise verification is a self-correction methodology applied to complex, multi-step reasoning. Instead of verifying the final answer only, the model is instructed to validate each individual logical or computational step before proceeding to the next. This prevents error propagation and is crucial for tasks like mathematical problem-solving, code generation, and long-form logical deduction. For example, in a chain-of-thought response, the model would be prompted to check the correctness of each equation or inference as it is generated, creating a built-in validation layer.

A schema compliance check is a self-correction step focused on structured output generation. The model is instructed to verify that its output—often in JSON, XML, or YAML format—adheres exactly to a specified schema. This includes:

• Validating all required fields are present.
• Ensuring data types (string, integer, array) are correct.
• Checking that values fall within defined enumerations or ranges. This check is essential for reliable API integration, where malformed outputs can break downstream systems. It transforms a generative task into a deterministic validation task.

Constitutional self-review is a self-correction process where a language model evaluates its output against a predefined set of principles or rules, known as a 'constitution'. This constitution defines criteria for safety, ethics, legality, or style. The model is prompted to assess its own text for violations and to rewrite it to comply. This technique, inspired by Anthropic's Constitutional AI, provides a scalable method for alignment by embedding high-level normative principles directly into the model's self-correction routine, rather than relying solely on pre-training or fine-tuning.

Multi-agent self-review is an advanced self-correction architecture that simulates a panel of experts. Instead of a single model critiquing itself, multiple instances or distinct personas of a language model (e.g., a 'fact-checker', a 'logic reviewer', a 'security auditor') are prompted to critique a single output. Their feedback is then synthesized to produce a final, consensus-driven revision. This approach reduces the blind spots of a single perspective and is a prompt-based simulation of ensemble methods, increasing the robustness and reliability of the corrected output.