Ask AI To Audit Itself

Ask AI to Audit Its Own Output (AI Skill)

Overview

When an AI generates a long response in a single generation pass, it cannot "look ahead" to revise earlier sentences based on later logical deductions. As a result, drafts often contain subtle internal contradictions, forgotten constraints, or code bugs that the model would easily catch if asked to review them as a third party.

This skill implements the Reflexion / Critic-Actor Prompting Protocol - a technique that separates generation from critique to dramatically elevate accuracy and quality.

The 3-Stage Reflexion Architecture

┌─────────────────────────────────────────────────────────────┐
│                 The Critic-Actor Pipeline                   │
│                                                             │
│  Step 1: ACTOR       ──► Draft initial solution             │
│            │                                                │
│  Step 2: CRITIC      ──► Adversarial audit against strict   │
│            │             rubric (find 3 flaws/edge cases)   │
│            │                                                │
│  Step 3: SYNTHESIZER ──► Output final refined version with  │
│                          all audited flaws resolved         │
└─────────────────────────────────────────────────────────────┘

Master Audit Prompts

Pattern 1: The "Adversarial Code & Logic Audit"

Use this prompt immediately after an AI provides a code snippet or architectural plan:

Now, switch personas. Act as a Principal Security and Performance Reviewer.

Critically audit your code/solution above against these 4 criteria:
1. **Edge Cases**: Where will this fail (null values, concurrency race conditions, unexpected formats)?
2. **Performance & Scalability**: Is there any O(N^2) bottleneck, memory leak, or redundant compute?
3. **Security Vulnerabilities**: Are there injection risks, unsafe inputs, or missing validations?
4. **Constraint Adherence**: Did the draft violate any original prompt requirements?

List any flaws found. If flaws exist, provide the corrected, production-ready version.

Pattern 2: The "Editorial & Consistency Audit"

Use this for articles, contracts, reports, and documentation:

Read through the text you just drafted. Audit it strictly for:
1. Internal factual or mathematical contradictions between sections.
2. Passive, repetitive, or vague statements.
3. Unanswered questions or vague hand-waving (e.g., "implement appropriate logic here").

Output a bulleted "Changelog of Fixes" followed by the finalized, corrected text.

Real-World Examples

Example 1: Auditing an Ingestion Script

Initial Generation (Actor Pass)

def process_user_records(records):
    results = []
    for r in records:
        data = r['profile']
        results.append(data['email'].lower())
    return results

The Audit Prompt & Self-Correction

User: "Audit the function above for runtime exceptions in production."

AI Self-Audit: Flaws Identified:

1. KeyError: Will crash if r lacks 'profile' or 'profile' lacks 'email'.
2. AttributeError: Will crash if email is None.
3. TypeError: Will fail if records is None or not iterable.

Corrected Production Version:

from typing import List, Dict, Any

def process_user_records(records: List[Dict[str, Any]] | None) -> List[str]:
    if not records:
        return []
    
    valid_emails = []
    for r in records:
        if not isinstance(r, dict):
            continue
        profile = r.get('profile')
        if isinstance(profile, dict):
            email = profile.get('email')
            if isinstance(email, str) and email.strip():
                valid_emails.append(email.strip().lower())
                
    return valid_emails

Example 2: One-Turn Multi-Pass Audit (Self-Correction Prompt)

You don't always need two separate chat turns. You can instruct the model to perform the audit internally:

Solve the following logic problem: [INSERT PROBLEM]

Follow this multi-pass structure in your response:
### Pass 1: Initial Solution & Reasoning
[Work through the problem step-by-step]

### Pass 2: Adversarial Self-Audit
[Test the solution with extreme boundary inputs and double-check all arithmetic]

### Pass 3: Final Verified Answer
[State the confirmed solution]

Critical Rules & Anti-Patterns