Error Recovery

Error Recovery

Overview

AI agents get stuck. They try the same approach repeatedly, add complexity to fix complexity, and rationalize "one more attempt" long past the point of diminishing returns. This skill detects stuck patterns proactively and forces recovery before wasted effort compounds.

Core principle: Track every failed attempt. Escalate at defined thresholds. Never allow unbounded retries.

The Prime Directive

NO CONTINUED ATTEMPTS WITHOUT ACKNOWLEDGING FAILURE COUNT

Before EVERY fix attempt, state: "This is attempt N of the current issue." If N >= 3, you are not authorized to continue without user direction.

When to Use

This skill activates automatically when any of these patterns appear:

• Same error message after 2+ attempted fixes
• A fix for problem A introduces problem B
• File edited 3+ times for the same issue without resolution
• Increasing line count or complexity with each attempt
• "Let me try one more thing" after 2+ failures
• Test suite results getting worse, not better
• Reverting a fix and trying a variation of the same approach

This skill overrides optimism. When triggered, it takes priority over whatever strategy is currently failing.

Failure Counter

You MUST maintain an internal failure counter for each distinct issue:

FAILURE LOG
Issue: [description]
Attempt 1: [what you tried] -> [result]
Attempt 2: [what you tried] -> [result]
Attempt 3: [what you tried] -> [result]   count
  count -> check
  check -> yellow [label="2"]
  check -> orange [label="3"]
  check -> red [label="4+"]
  yellow -> start [label="Next attempt fails"]
  yellow -> resolved [label="Fix works"]
  orange -> start [label="New hypothesis\nattempt fails"]
  orange -> resolved [label="Fix works"]
  red -> user [label="User responds"]
  user -> start [label="New attempt"]
}

Recovery Strategies

When a fix fails, apply these in order:

1. Re-read the actual error message. Not your interpretation of it -- the literal text. Errors frequently contain the answer.

1. Try a fundamentally different approach. Not a variation. If you were editing config, try code. If you were patching, try replacing. If you were adding, try removing.

1. Simplify ruthlessly. Strip the problem to its smallest reproducible case. Remove everything non-essential. Test the simplest possible version.

1. Verify your assumptions. Print values. Check types. Confirm the file you think you are editing is the one actually being executed. Confirm the function you think is being called is actually being called.

1. Escalate with honesty. Tell the user: "I have tried N approaches. None worked. Here is what I know and what I recommend."

1. Rollback to last known-good state. If you have made things worse, undo all changes and return to where things last worked. Start fresh from there.

Anti-Patterns to Block

These patterns indicate the agent is stuck and MUST trigger this skill:

| Anti-Pattern | What to Do Instead | |---|---| | "Let me try one more thing" (after 3+ failures) | STOP. You said that last time. Escalate. | | Adding complexity to fix complexity | Simplify. Remove code. Reduce moving parts. | | Ignoring the error message, trying random changes | Read the error. It is telling you something specific. | | Blaming the environment ("must be a cache issue") | Verify the claim. Run a clean build. Check actually. | | Widening scope instead of narrowing it | Focus on the smallest failing case, not the whole system. | | Editing the same file repeatedly | Step back. The problem may not be in that file. | | "It should work" without verifying | Run it. Check output. Trust evidence, not expectations. | | Fixing the test instead of the code | The test is probably right. Fix what it is testing. |

Cognitive Traps

| Rationalization | Reality | |---|---| | "This is a different issue" | If it appeared while fixing the original, it is the same issue. Count it. | | "I almost had it last time" | Almost does not count. Two near-misses is a pattern, not progress. | | "The approach is right, just needs tweaking" | Three tweaks of the same approach is not three different attempts. | | "I need to understand the whole system first" | You need to understand the failing part. Scope down, not up. | | "Let me refactor first, then fix" | Refactoring while debugging creates two problems. Fix first. | | "This is an edge case" | If it blocks completion, it is a primary case. | | "One more log statement will reveal it" | If three log statements did not help, you are looking in the wrong place. |

Guardrails

STOP and activate this skill if you observe:

• You have edited the same file 3+ times for one issue
• Your fix introduced a new failure
• You are writing more code to handle an error than the original feature
• The test suite has more failures now than when you started
• You are suppressing errors or warnings instead of fixing them
• You are about to say "let me try" for the 3rd+ time
• Your solution is more complex than the original problem
• You have been working on the same error for more than 10 minutes of active attempts

Connections

• godmode:fault-diagnosis -- Error recovery activates when fault diagnosis is not converging. If Phase 4 has failed 3+ times, this skill takes over.
• godmode:completion-gate -- After recovery, use completion-gate to verify the fix actually holds. Prevents false "done" claims after a recovery sequence.
• godmode:test-first -- Recovery should include writing a test that reproduces the exact failure. A fix without a regression test is not complete.
• godmode:task-planning -- If recovery reveals the task was scoped wrong, return to task planning to re-scope before continuing.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: NoobyGains
• Source: NoobyGains/godmode
• License: MIT

Install and usage instructions live in the source repository linked above.