The Complete Production SOP: How to Deploy and Run Self-Reflective Critic & Error Correction in Autonomous AI Agents
Step-by-step SOP to install and run the Self-Reflective Critic & Error Correction skill in Codex, Claude Code, and Cursor. Fix regressions before code merges.
Technical Overview & Architectural Context
Autonomous coding agents frequently suffer from sycophancy, premature convergence, and blind spots when executing non-trivial code modifications. When models like Claude 3.7 Sonnet or OpenAI o3 draft complex algorithms or refactor core modules, they inherently evaluate their own drafts with positive bias. Without an explicit adversarial feedback loop, silent logic inversions, unhandled edge cases, and subtle interface regressions bypass initial lint checks and enter production pull requests. The 'self-reflective-verification-loop' skill enforces a deterministic Reflexion paradigm. Instead of allowing the primary generative persona to immediately report completion, this skill binds the agent into an adversarial critic state prior to file write finalizing. By forcing the runtime to simulate execution failure paths, verify negative constraints, and remediate identified flaws directly, it eliminates standard hallucinations and logic drift across Codex, Claude Code, Cursor, and Windsurf.
Prerequisites & Environment Requirements
Verified Search Intents & Long-Tail Queries Solved
This operational tutorial is engineered to provide deterministic solutions for these developer search queries:
Step-by-Step Execution Playbook
Local Environment Setup & SKILL.md Mounting
Mount the self-reflective-verification-loop skill into the runtime's agent skill registry.
Autonomous runtimes discover capabilities through standardized directory structures. For Claude Code and global agent runtimes, skills are mounted into `.agents/skills` or `.claude/skills`. For Cursor or Windsurf, mounting in `.cursor/rules` or `.windsurfrules` enables automatic agent context ingestion. This ensures the triggers ('critique generated code', 'self-verify response', 'run reflexion error correction') are indexed in the agent's semantic router.
mkdir -p ~/.agents/skills/self-reflective-verification-loop && cat << 'EOF' > ~/.agents/skills/self-reflective-verification-loop/SKILL.md
---
name: "self-reflective-verification-loop"
description: "Evaluate drafted code and responses with a dedicated critic loop before final output."
metadata:
author: "Noah Shinn"
version: "1.0.0"
runtime_compatibility:
- "codex"
- "claude-code"
- "cursor"
- "windsurf"
triggers:
- "critique generated code"
- "self-verify response"
- "run reflexion error correction"
permissions:
fs_read: true
fs_write: "workspace"
shell_exec: false
net_access: false
---
# Self-Reflective Critic & Error Correction
Applies self-reflection patterns (Reflexion): inspecting generated code against constraints, detecting subtle logic regressions, and synthesizing corrective feedback before concluding turns.
## When to Invoke
Invoke this skill whenever you need to:
- critique generated code
- self-verify response
- run reflexion error correction
## Execution SOP & Rules
1. Review the draft from an adversary's perspective, actively looking for failure modes.
2. Verify that all original user requirements and negative constraints are strictly satisfied.
3. Revise the solution directly to resolve identified flaws rather than just listing issues.
4. Ensure final code compiles or passes static type checking without warnings.
## Verification Checklist
- Run local linting, syntax validation, and type-checks before reporting completion.
- Ensure all created or modified files adhere to workspace boundaries and avoid uncommitted secrets.
- Verify tests or build commands exit cleanly with return code 0.
EOF---
name: "self-reflective-verification-loop"
description: "Evaluate drafted code and responses with a dedicated critic loop before final output."
metadata:
author: "Noah Shinn"
version: "1.0.0"
runtime_compatibility:
- "codex"
- "claude-code"
- "cursor"
- "windsurf"
triggers:
- "critique generated code"
- "self-verify response"
- "run reflexion error correction"
permissions:
fs_read: true
fs_write: "workspace"
shell_exec: false
net_access: false
---Keep the SKILL.md under 400 tokens; autonomous agents retain higher directive adherence when reflective rules are concise constraints rather than essay-length descriptions.
Ensure directory permissions match current workspace user permissions. If running in a root container, non-root agent runtimes will fail to mount the manifest silently.
Configuring Project-Level Runtime Links & Permissions
Symlink the skill into project directories and configure execution boundary parameters.
To ensure Cursor, Windsurf, or repository-isolated Claude Code runs pick up the verification loop without global pollution, establish a symlink or direct project inclusion under `.cursor/skills/` or `.claude/skills/`. The skill definition strictly restricts permissions: `shell_exec: false` and `net_access: false`, meaning the agent must perform cognitive verification within context rather than spawning unmonitored external network calls.
mkdir -p .claude/skills .cursor/skills && ln -sf ~/.agents/skills/self-reflective-verification-loop/SKILL.md .claude/skills/self-reflective-verification-loop.md && ln -sf ~/.agents/skills/self-reflective-verification-loop/SKILL.md .cursor/skills/self-reflective-verification-loop.mdBecause this skill mandates `fs_write: workspace`, make sure your agent runtime's global sandbox flags allow in-tree workspace writes while blocking system files.
Do not elevate `shell_exec` to `true` inside this skill manifest; reflection should occur as a deterministic semantic pass prior to any external bash commands.
Intent Matching & Trigger Invocation
Initiate generation tasks using standardized natural language triggers that route to the critic loop.
Runtimes scan user prompts against the trigger patterns listed in the frontmatter (`critique generated code`, `self-verify response`, `run reflexion error correction`). Appending explicit trigger phrases ensures the agent activates its two-phase deliberation state: Draft Generation -> Adversarial Critique -> Remediation -> Final Output.
Structure user prompts as: '[Core Implementation Task]. Before concluding, critique generated code and self-verify response against negative constraints.'
Avoid ambiguous trigger phrases like 'check this'. Stick to the exact triggers defined in the SKILL.md YAML manifest to ensure high confidence matching.
Quality Gate Verification and Static Diff Audit
Execute workspace linting and evaluate the agent's self-remediation trace before committing.
Once the agent completes its reflective loop, verify that the resulting file modifications pass type-checking and that the reflection trace actually corrected flaws rather than hallucinating validation.
git diff --stat && npx tsc --noEmit || python3 -m py_compile $(git diff --name-only)Inspect the agent's thought scratchpad to confirm it evaluated at least two distinct edge cases (e.g., null states, boundary conditions) during the critic phase.
If an agent modifies files outside of the target refactor scope during self-correction, review the git diff immediately; reflection without strict constraints can cause scope creep.
Real-World Scenario: Concurrent Rate Limiter Refactoring with Zero Regressions
“Refactor src/rateLimiter.ts to use a sliding window log algorithm with Redis commands. Self-verify response and critique generated code for race conditions under concurrent async invocations.”
Runtime Troubleshooting & Failure Modes
Root Cause: The agent attempted to write self-correction logs or temp files outside the allowed workspace scope defined in permissions (fs_write: 'workspace').
Enforce project-local scratchpad configuration by adding `--sandbox=workspace-only` or updating agent settings to direct all critic scratchpads to `.tmp/agent/`.Root Cause: The runtime failed to match prompt keywords to the frontmatter triggers due to prompt ambiguity or mismatched manifest path.
Verify skill discovery with: `claude skills list` or ensure prompt includes exact trigger: `critique generated code: implement user auth service`.Frequently Asked Questions (Self-Reflective Critic & Error Correction SOP)
Q:Can I use Self-Reflective Critic & Error Correction across Codex, Claude Code, and Cursor simultaneously?
Yes. The skill conforms to the universal SKILL.md specification. By mounting the file in a shared location (`~/.agents/skills/self-reflective-verification-loop/SKILL.md`) and symlinking it into `.claude/skills/`, `.cursor/skills/`, and Windsurf rules, all runtimes will execute the critic protocol identically.
Q:How does Self-Reflective Critic & Error Correction prevent context window overflow during long agent sessions?
The skill enforces an immediate 'revise in place' rule rather than appending multi-turn dialogue debate. By mandating that the agent directly synthesizes corrections in the working artifact instead of dumping exhaustive conversational commentary, context token usage is minimized.
Q:Does this skill require escalated root or container permissions?
No. The skill is audited with a security score of 98/100. It explicitly enforces `shell_exec: false` and `net_access: false`, confining execution to internal model cognitive evaluation and local workspace filesystem writes.
Ready to equip your autonomous agent with Self-Reflective Critic & Error Correction?
Copy the complete audited SKILL.md specification or download the 1-click zip bundle directly from our verified registry.