How to Make Claude Code Fix Its Own Mistakes Automatically (Exact Setup You Can Copy)

Claude writes code, tests fail, you explain what went wrong. Then it fixes it, but breaks something else. Every session, same loop.

There's a setup that makes Claude catch, fix, and learn from its own mistakes automatically.

Here's the full config you can just copy 👇

Before we dive in, I share daily notes on AI & vibe coding in my Telegram channel: https://t.me/zodchixquant🧠

Why Claude keeps making the same mistakes

Claude has no memory of what went wrong last session. Every new session starts from zero.

The same bug that took you 20 minutes to fix yesterday will happen again tomorrow.

CLAUDE.md fixes this. Anthropic's own power user guide says it directly:

"Anytime Claude does something incorrectly, 
add it to CLAUDE.md so it knows not to repeat the mistake."

"After every correction, end with: 
'Update your CLAUDE.md so you don't make that mistake again.'"

Claude is good at writing rules for itself. The problem is most people never ask it to.

Step 1: The self-correcting CLAUDE.md

Your CLAUDE.md should grow every time Claude makes a mistake. Not with personality instructions, but with specific, actionable rules.

## Rules

- NEVER refactor, rename, or clean unrelated code
- All database queries through services/, never in components
- Run `npx tsc --noEmit` after every code change
- Run tests after every change, fix failures before moving on
- Prefix commits: feat:, fix:, docs:, refactor:, test:, chore:
- NEVER use enums, always prefer literal unions
- NEVER force push. Rewrites shared history.
- Run migrations before tests, not after

## Learned from mistakes

- Don't install packages in packages/ui that belong in apps/web
- Don't average two existing patterns, pick one and follow it
- When unsure about folder structure, check existing files first
- Stop-loss function must return a number, not a boolean (broke prod on 2026-05-12)

The "Learned from mistakes" section is key. Every time you correct Claude, end with:

"Update CLAUDE.md so you don't make that mistake again."

After a month, your CLAUDE.md has captured every mistake Claude has made in your project. Error rate drops because Claude literally reads the list of things not to do before starting work.

Research shows the sweet spot is ~12 rules under 200 lines. Past that, compliance drops sharply.

Step 2: PostToolUse hooks (catch mistakes in real-time)

Hooks fire automatically at specific points. PostToolUse runs after Claude writes or edits a file.

This is where you catch problems before they compound.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write(*.ts)",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $file"
          }
        ]
      },
      {
        "matcher": "Write(*.ts)",
        "hooks": [
          {
            "type": "command",
            "command": "npx tsc --noEmit 2>&1 | head -20"
          }
        ]
      },
      {
        "matcher": "Write(*.tsx)",
        "hooks": [
          {
            "type": "command",
            "command": "npx eslint --fix $file"
          }
        ]
      }
    ]
  }
}

Every .ts file: auto-format with Prettier, then type-check. Every .tsx file: auto-lint with ESLint.

Claude sees the type errors immediately in the same turn and fixes them before moving on.

Without hooks: Claude writes 5 files, you run type check, 12 errors across 3 files, you explain each one.

With hooks: Each file is checked the moment Claude writes it. Errors fixed in real-time.

Step 3: Stop hooks (the quality gate)

This is the most powerful hook. Stop hooks run every time Claude says "I'm done." They check if the work actually meets your standards before Claude finishes.

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "npm test 2>&1 | tail -5; echo \"Exit code: $?\""
          }
        ]
      }
    ]
  }
}

If tests fail, Claude sees the failure output and automatically continues working to fix it. No manual intervention.

For more complex validation, use a prompt hook that asks Claude to evaluate its own work:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Check if all requested tasks are complete. Review the code changes for bugs, missing edge cases, and test coverage. If anything is incomplete or broken, continue working. If everything looks good, confirm done."
          }
        ]
      }
    ]
  }
}

Critical rule: always check stop_hook_active in Stop hooks.

When it's true, Claude is already continuing because of a previous Stop hook. Exit 0 immediately.

Without this check, your hook blocks Claude forever.

Step 4: PreToolUse hooks (prevent mistakes before they happen)

PreToolUse runs before Claude executes a tool. Use it to filter inputs and prevent expensive mistakes.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash(cat *log*)",
        "hooks": [
          {
            "type": "command",
            "command": "grep -n 'ERROR\\|WARN' $file | head -50"
          }
        ]
      },
      {
        "matcher": "Write(**/.env*)",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'BLOCKED: Cannot write to .env files' && exit 1"
          }
        ]
      }
    ]
  }
}

Claude tries to read a 10,000-line log? Hook filters it to 50 lines of errors first. Claude tries to write to .env? Blocked before it happens.

Step 5: The auto-retry pattern

For tasks that need multiple attempts, set up a retry loop with a token budget:

Prompt pattern:

"Fix the failing tests. You have 3 attempts maximum.

After each attempt:
1. Run the tests
2. If they pass, you're done
3. If they fail, read the error, try a different approach
4. If all 3 attempts fail, explain what you tried and what's still broken

Do NOT try the same fix twice."

Combined with the Stop hook from Step 3, this creates a self-correcting loop: Claude writes code → tests run → if fail → Claude reads errors → tries different approach → tests run again → repeat until pass or budget exhausted.

The token budget prevents infinite loops. Without it, Claude can spiral into retry loops that burn hundreds of dollars.

Step 6: Memory for cross-session learning

Hooks catch mistakes within a session. Memory prevents them across sessions.

# Check what Claude has learned
/memory

# Add rules manually
/memory add "this project uses pnpm, not npm"
/memory add "auth module was refactored on May 15, new pattern is in src/lib/auth/v2/"

With Dreaming enabled, Claude processes past sessions in the background and builds persistent knowledge automatically. No manual /memory add needed.

The combination: CLAUDE.md catches project-level patterns, /memory catches session-level learnings, Dreaming consolidates everything overnight.

The full self-correcting settings.json (copy-paste ready)

{
  "permissions": {
    "allow": [
      "Read", "Glob", "Grep", "LS", "Edit", "MultiEdit",
      "Write(src/**)", "Write(tests/**)",
      "Bash(npm test *)", "Bash(npx tsc *)", "Bash(npx prettier *)",
      "Bash(npx eslint *)", "Bash(git add *)", "Bash(git commit *)"
    ],
    "deny": [
      "Read(**/.env*)", "Write(**/.env*)",
      "Bash(rm -rf *)", "Bash(git push *)"
    ],
    "defaultMode": "acceptEdits"
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write(*.ts)",
        "hooks": [
          { "type": "command", "command": "npx prettier --write $file" },
          { "type": "command", "command": "npx tsc --noEmit 2>&1 | head -20" }
        ]
      },
      {
        "matcher": "Write(*.tsx)",
        "hooks": [
          { "type": "command", "command": "npx prettier --write $file" },
          { "type": "command", "command": "npx eslint --fix $file" }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash(cat *log*)",
        "hooks": [
          { "type": "command", "command": "grep -n 'ERROR\\|WARN' $file | head -50" }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "npm test 2>&1 | tail -10; echo \"Exit: $?\"" }
        ]
      }
    ]
  }
}

The before and after

BEFORE:

- Claude writes code, you run tests, 4 failures
- You explain each failure manually
- Claude fixes 3, introduces 1 new bug
- You explain again
- 45 minutes of back-and-forth per feature
- Same mistake happens again tomorrow

AFTER:

- Claude writes code, hooks auto-format and type-check every file
- Tests run automatically when Claude says "done"
- If tests fail, Claude reads errors and keeps fixing
- CLAUDE.md prevents yesterday's mistakes from repeating
- Memory prevents last week's mistakes from repeating
- 10 minutes per feature, most of it unattended

Thanks for reading!

I share daily notes on AI, finance, and vibe coding in my Telegram channel: https://t.me/zodchixquant