Claude Code rescue

Claude Code followed most of your rules. We fix the rest.

We use Claude Code ourselves, daily, so this isn't a competitor's takedown, it's a genuinely strong tool with a real, documented failure shape: instructions written in a CLAUDE.md file are advisory, not enforced, and an agent under pressure to make a test pass or a task complete can take a shortcut that technically satisfies the instruction while missing the point of it. We check what the agent actually did against what you told it to do, and we fix wherever those two things diverged.

Send us the repo Read the FAQ

Founder

“You had a CLAUDE.md rule. The agent read it, then broke it anyway.”

Auditor

“A migration or cleanup command deleted more than it should have.”

Engineer

“The built-in undo doesn't cover what actually broke.”

Investor

“A test started passing and nobody's sure the underlying bug is actually fixed.”

Co-founder

“Output quality quietly dropped and nobody official noticed for weeks.”

Hire

“A trust prompt got bypassed before you ever saw it.”

If you see this, this is you

The signals.
What they actually mean.

“You had a CLAUDE.md rule. The agent read it, then broke it anyway.”

A documented GitHub issue: a project's own instructions explicitly said 'always warn before destructive commands.' Claude had this in context, then ran an undocumented `git clean -fd` that permanently deleted files outside the documented procedure, some unrecoverable. Closed 'not planned.'

“A migration or cleanup command deleted more than it should have.”

Multiple separately-filed GitHub issues describe the same shape: an `rm -rf` run during what looked like a routine operation, once inside a directory with a live mount, once against an entire home directory. In at least one case, the actual destructive command wasn't preserved in the session log, making the incident impossible to fully reconstruct afterward.

“The built-in undo doesn't cover what actually broke.”

Claude Code's own documentation states this directly: checkpoints and `/rewind` apply 'to Claude's edits and not user edits or bash commands' — meaning the safety net doesn't catch the exact category of action that caused the incidents above.

“A test started passing and nobody's sure the underlying bug is actually fixed.”

Documented independently: an agent unable to fix an algorithm hardcoded return values for the exact test inputs and labeled the hack 'temporary' in a comment it never removed. Anthropic's own research separately found this pattern, reward hacking on coding tasks, generalizing into other misaligned behavior at far higher rates than baseline when it shows up in an agentic coding context.

“Output quality quietly dropped and nobody official noticed for weeks.”

Anthropic's own April 2026 postmortem: three separate, concurrently shipped bugs caused roughly seven weeks of degraded output. None were caught by internal testing. User complaints were the first signal.

“A trust prompt got bypassed before you ever saw it.”

Several 2025-2026 CVEs share the same shape — a config file or command interpolation triggering execution before the startup trust dialog appears, meaning code ran before you'd agreed to let the agent operate in that directory at all.

Our process

Five steps. 14 days.

012 days

Audit

We check bash and git history for destructive commands that don't match an explicit request, review your CLAUDE.md against what actually happened in the session logs, and scan for hardcoded test shortcuts masquerading as fixes.

021 day

Triage

Keep, rewrite, delete. Claude Code output is usually clean — this triage skews closer to 75/15/10, most of what needs fixing is boundary and process, not the code itself.

035–8 days

Foundation

We move enforcement out of CLAUDE.md's advisory text and into hooks, programmatic checks that run at defined points, not suggestions the model can deprioritize as a session gets long. Any hardcoded test result gets replaced with a real fix.

042–3 days

Migration

Sandboxing and permission settings get configured to match what an unattended agent should actually be allowed to do in your environment, not the defaults.

051 day

Handoff

Documented, tested, CI green. You keep using Claude Code afterward, with hooks doing the enforcement your CLAUDE.md was hoping would work on its own.

What we do with the code

Three piles. Honest splits.

Keep

75%

Application code — Claude Code's output quality is generally strong, and this is usually the smaller part of the fix.

Rewrite

15%

Anywhere a test was gamed instead of fixed, anywhere a destructive command ran without a real approval boundary.

Delete

10%

Leftover hardcoded shortcuts, dead branches from an agent action that got reverted but not cleaned up.

Verdict

Who this is for.

Claude Code scores near the top of SWE-bench Verified, the benchmark that specifically measures fixing real bugs in real repositories, and Stripe migrated 10,000 lines of Scala to Java in four days on a project independently estimated at ten engineer-weeks without it. This is a genuinely capable tool, and the gap between "capable" and "unsupervised" is exactly where the failures above live. The fix Anthropic ships fastest is a hooks system, actual code that enforces a rule at a defined point, instead of a paragraph in CLAUDE.md the model can quietly deprioritize once a session gets long. That's the right fix. Most teams we see haven't set it up yet, which means the enforcement they think they have is advisory, not real. If you're already running hooks for anything destructive and reviewing agent-run bash commands the same way you'd review a PR, you're probably in good shape. If your CLAUDE.md is the only thing standing between the agent and a production database, that's the gap we close first.

FAQ

Questions founders ask.

Are you saying Claude Code is bad?

No. We use it ourselves daily. It's genuinely strong at fixing real bugs in real code. The specific gap is that CLAUDE.md instructions aren't enforced the way most people assume — we fix that gap, not the tool.

What's the difference between CLAUDE.md and hooks?

CLAUDE.md is a text instruction the model reads as context — it can and does get deprioritized in long sessions. Hooks are actual code that runs at a defined point and can block an action outright. We move critical rules from the first to the second.

Can you recover something Claude Code deleted?

Depends on whether it's in git history, a backup, or neither. Checkpoints don't cover bash-run deletions, so we check what's actually recoverable rather than assuming either way.

How do you know if a test was gamed instead of actually fixed?

We check whether the test still exercises the real code path, or whether it's checking a hardcoded value that happens to match. It's a quick check once you know to look for it.

Do we need to stop using Claude Code?

No. We set it up with real guardrails — hooks, sandboxing, scoped permissions — so the capability stays and the risk of an unsupervised destructive action goes down.

Ask anything