Implementing Self-Critique and Revision: Claude AI Prompts SEO for Safer Outputs

Overview

How It Works

Step-by-Step

1. Step 1: Prepare Your Constitutional Principles as Evaluation Criteria

   Before you can implement self-critique, you need a concrete set of principles the model will evaluate against. If you haven't already, work through drafting a constitution of ethical principles to create these.

   For the self-critique loop, transform each principle into an evaluable question. For example, the principle "Be honest and don't fabricate information" becomes the critique question: "Does this response contain any fabricated claims, unsupported assertions, or misleading implications?" Each principle should map to one or two specific critique questions.

   Aim for 3-8 principles per critique pass. Too few and you'll miss issues; too many and the model's attention diffuses, producing shallow critiques across all dimensions rather than deep analysis on any single one. If you have more than 8 principles, consider splitting them into separate critique passes focused on different categories (e.g., safety principles in one pass, quality principles in another).

   Tip: Rank your principles by severity. Run the most critical safety-focused principles in the first critique pass, so that even if you only run one iteration, the most important issues are addressed.

2. Step 2: Generate the Initial Response

   Have the model produce its initial response to the target prompt without any constitutional constraints. This is intentional—you want the unconstrained output so the critique phase has material to evaluate.

   In practice, this means running your prompt through the model with a system message focused on helpfulness and task completion, not safety filtering. For example: "You are a helpful assistant. Answer the user's question as completely and accurately as possible."

   Capture this initial response in full. You'll pass it verbatim into the critique prompt in the next step. If you're building a pipeline, store this as initial_response in your data structure.

   Tip: For testing and development, deliberately use prompts that are likely to produce borderline or problematic responses. This gives your critique loop meaningful work to do and helps you validate that your principles catch real issues.

3. Step 3: Construct the Critique Prompt

   The critique prompt is the most important engineering artifact in this process. It must provide the model with: (1) the initial response, (2) the constitutional principles as evaluation criteria, and (3) clear instructions for structured critique.

   A strong critique prompt follows this structure:

   Here is a response generated by an AI assistant:
   
   [INITIAL RESPONSE]
   
   Please evaluate this response against the following principles:
   1. [Principle 1 as evaluable question]
   2. [Principle 2 as evaluable question]
   ...
   
   For each principle, state whether the response complies or violates it. If it violates, quote the specific problematic text and explain why it's a violation. Be specific and thorough.
   

   The critique output should be structured—ideally as a numbered list matching the principles. This makes it parseable for automated pipelines and ensures the model addresses every principle rather than cherry-picking easy ones.

   Critically, instruct the model to identify violations with specificity. "This response could be harmful" is useless. "The phrase 'you should definitely invest all your savings in crypto' in paragraph 2 violates Principle 3 (avoiding financial advice without disclaimers) because it presents a high-risk strategy as universally advisable without mentioning risks" is actionable.

   Tip: Add the instruction "If the response fully complies with all principles, state that explicitly rather than inventing issues" to prevent the model from hallucinating violations to appear thorough.

4. Step 4: Construct the Revision Prompt

   The revision prompt takes both the original response and the critique, then asks the model to produce an improved version. The key design challenge is ensuring revisions address every critique point without over-correcting—stripping so much content that the response becomes unhelpfully vague.

   A strong revision prompt follows this structure:

   Here is an AI assistant's response:
   
   [INITIAL RESPONSE]
   
   Here is a critique of that response based on constitutional principles:
   
   [CRITIQUE OUTPUT]
   
   Please revise the response to address every issue identified in the critique. Preserve all helpful, accurate, and appropriate content. Only modify or remove content that violates the stated principles. The revised response should be at least as helpful as the original while being fully compliant with the principles.
   

   The instruction to "preserve all helpful content" is crucial. Without it, models tend toward excessive caution, producing bland refusals instead of nuanced, improved responses. The goal is surgical correction, not wholesale rewriting.

   Tip: Include the instruction "Do not add unnecessary disclaimers or caveats that weren't identified as needed in the critique" to prevent over-hedging during revision.

5. Step 5: Execute the Critique-Revision Loop Iteratively

   Run the critique on the initial response. Feed the critique and original response into the revision prompt. Then—and this is where iterative refinement happens—run the critique prompt again on the revised response.

   If the second critique identifies new issues (or issues that were partially but not fully addressed), feed that second critique and the revised response into another revision pass. Continue until the critique phase returns no violations, or until you've hit your maximum iteration count.

   In practice, 2-3 iterations are typically sufficient. The first revision addresses the most obvious issues. The second catches subtler problems that may have been introduced during revision (a common occurrence—fixing one issue can inadvertently create another). By the third pass, most responses are clean.

   For production pipelines, implement this as a loop with a maximum iteration parameter and a convergence check (if the critique identifies zero violations, break the loop early).

   Tip: Log every iteration—initial response, each critique, and each revision. This audit trail is invaluable for debugging principle gaps and understanding how your constitutional criteria perform across different prompt types.

6. Step 6: Validate Revision Quality with Spot Checks

   Automated self-critique is powerful but not infallible. The model can miss subtle issues, hallucinate that violations were fixed when they weren't, or over-correct in ways that degrade usefulness. Build a validation step into your workflow.

   Select a representative sample of critique-revision outputs (10-20% of your volume during development, lower in stable production). For each sample, verify: (1) Were all genuine violations identified? (2) Were the revisions actually addressing those violations? (3) Did the revision preserve the helpful content? (4) Were any new issues introduced?

   Track these metrics over time. If you see systematic patterns—like the model consistently missing a particular type of issue, or consistently over-correcting in a specific way—update your constitutional principles or critique prompt accordingly. This feedback loop between validation and principle refinement is what makes the system improve over time.

   Tip: Use the patterns you discover during validation to create better [red-team prompts](/skills/crafting-red-team-prompts-for-safety-testing) that specifically target the weak spots in your critique loop.

7. Step 7: Integrate into Production Pipelines or Training Data Collection

   Once your critique-revision loop is producing consistent, high-quality results, integrate it into your workflow. There are two main deployment paths:

   Runtime pipeline: Run the critique-revision loop on every model output before it reaches the end user. This adds latency (each iteration is an additional API call) but provides real-time quality assurance. Best for high-stakes applications where every output matters.

   Training data generation: Use the critique-revision loop to generate large volumes of (initial_response, revised_response) pairs. These pairs become training data for RLAIF—the model learns to prefer the revised outputs. This is the approach described in Anthropic's Constitutional AI research and connects directly to generating reinforcement learning from AI feedback.

   For many practitioners, a hybrid approach works well: use the runtime pipeline during development and early deployment, collect the data it generates, then fine-tune a model on that data so it produces better initial responses that require fewer revision passes over time.

Examples

Best Practices

• Ground every critique in specific textual evidence from the response—require the model to quote problematic passages rather than offering vague assessments, which dramatically improves revision accuracy.

• Separate safety-critical principles from quality principles into distinct critique passes to ensure the model gives full attention to each category rather than spreading its analysis thin.

• Always include an explicit instruction in the revision prompt to preserve helpful and accurate content, preventing the common failure mode of over-cautious responses that refuse to engage with the topic.

• Set a maximum iteration count (typically 3) to prevent infinite loops where the model oscillates between two competing revision strategies without converging.

• Version-control your constitutional principles and critique prompts alongside your code—these are the most impactful parameters in your system and small changes can significantly alter behavior.

• When building claude ai prompts seo workflows, test your critique loop against a diverse set of prompt categories to ensure principles generalize rather than being tuned to a narrow distribution of inputs.

Common Mistakes

Frequently Asked Questions