Claude Code built the apparatus that consumed my project — 220k files, 136 worktrees, git rules in 4 places, 3 drive-fillings, and this morning it auto-deployed 288 uncommitted lines to my live trading engine while reporting certified:true

I have filed a lot of narrow bugs this week. Each names a mechanism and proposes a fix, which is what a tracker rewards. That framing understates the claim, so here it is flat.

Claude Code did not just have bugs in my project. It built the system.

I did not design this architecture. Claude did — over two years, one reasonable-sounding artifact at a time. Every element of the apparatus that failed was authored by the tool, because the platform ships none of it natively and an agent will always invent a substitute rather than refuse:

• Git configuration now spread across four locations — .gitignore, .git/info/exclude, local config, per-worktree config. No single file shows the whole picture, so no review ever saw it.
• A 1,967-line .gitignore whose blanket rules blinded every subsequent code review, including the tool's own search (#84161).
• A coordination protocol mandating a new UTC-stamped file per message — the single largest file generator in my repo, and it is a rule, not a program. One sentence took me from 142 files a day to 385.
• Hooks, gates and watchdogs, including exemptions other agents then routed around, and one armed at 300s against a process that died at 303s.
• Five separate backup systems, ~112 invocations a day, none reconciled, none watching where the work actually was.
• A dashboard built to stop decisions vanishing, which never rendered its own decision queue.
• A twelve-step process that is twelve steps only because a six-step pipeline was reported complete when two of its stages had never been written. Half of it exists to check whether the other half is real.

Then it could not operate what it built, clean it, or find its own defects in it

Three independent review passes — different models — were asked what was generating the file volume. All three returned nothing. They were structurally blind because of a config file the tool wrote (#84161). The cause was found only when I asked someone to look manually.

★ And this morning it put unreviewed code into production

This is the one that should end the argument, and it happened while I was drafting this.

My live engines auto-booted at 06:00 from 288 uncommitted lines across six runtime files — after an overnight review had explicitly said hold the boot; commit, revert, or ratify first. Nobody did any of the three. The scheduler read the working tree and shipped whatever happened to be dirty.

The checkout had 1,293 dirty entries at boot (368 staged, 925 unstaged, 767 untracked). And the verification gate reported certified:true — because it hashes selected symbols inside one module, and does not require a clean worktree, hash the complete runtime files, or pin a deployed ref.

certified:true did not mean "the running engine matches committed code." Nothing conveyed that to anyone reading the word "certified."

The backups worked perfectly — the exact bytes are recoverable from an autosave commit. That is the tell. Backup was never the missing piece. Deployment control was.

The root cause is a missing platform concept

There is no notion of a deployment checkout anywhere in this product. Nothing distinguishes code being edited from code that is running. There is no clean-tree requirement, no pinned deploy ref, no immutable live checkout, no "this branch is live, edits go elsewhere."

So a scheduled job imports the working tree, and whatever any agent left dirty becomes production.

Everything I listed at the top exists because of gaps like this one. An agent handed an unmet structural need does not stop — it invents a substitute, in markdown, in hooks, in filename conventions. Then the substitutes accumulate, contradict each other, and consume the work. The sprawl is not agents misbehaving. It is agents compensating, forever, for primitives that do not exist.

The numbers

• 220,213 markdown files. 94% duplicate copies inside worktrees the harness creates and never reaps (#84027).
• 136 worktrees, ~130 GB, with no safe first-party way to remove them — the obvious command destroys NTFS junction targets (#84162).
• A 2 TB drive and a dedicated external backup drive, each filled at least three times.
• Git rules in four places. No review inspected any of them.
• ~30% of one week's usage on cleanup that reclaimed zero bytes.
• 1,293 dirty entries in the checkout that booted production this morning.

And the deliverable

I do not have step 1 of 12 finished. Not behind schedule — step one, of twelve, unfinished, after two years.

Nothing is actually done. The system built to do the work consumed the capacity that would have done it.

---

What Anthropic needs to ship natively

Every item below is something I now maintain by hand because it does not exist:

1. A deployment checkout — an immutable, pinned ref that scheduled and background jobs run from, so editing can never be deploying.
2. A clean-tree / provenance guarantee for anything a scheduler or agent executes, and verification whose scope is stated where the result is read.
3. Worktree lifecycle — creation is automatic, so reaping must be too, and removal must be safe on Windows (#84027, #84162).
4. Agent-to-agent messaging with wake-on-delivery — so coordination stops being filename conventions in a shared directory (#84058).
5. A task/decision object with real state — open, discharged, superseded — so nothing has to be tracked in append-only markdown.
6. Search that reports when it was blinded (#84161).

---

The narrow reports, each with a mechanism and a proposed fix:

• #84027 — the harness dirties every isolated worktree via .claude/settings.local.json, permanently disqualifying it from auto-cleanup. A read-only agent still leaks a full checkout.
• #84162 — worktree cleanup is unsafe on Windows: git worktree remove --force destroys NTFS junction targets, so there is no safe way to reclaim what accumulates.
• #84161 — Grep honors .gitignore silently; an agent auditing its own repo gets "No files found" for code that exists, and cannot distinguish blindness from absence.
• #84028 — CLI and mobile app report different models for the same live session, across pricing tiers; session cost is unverifiable.
• #84029 — a crash leaves the terminal in mouse-tracking mode; the restore handler is registered on graceful exit, so it can never fire on the path that needs it.
• #84058 — no messaging primitive with wake-on-delivery, so every multi-agent setup hand-rolls a message bus on the filesystem. **The sprawl is the queue.**
• #84002 — the full write-up, with measurements, screenshots, and a controlled experiment: a mechanically-gated artifact type collapsed ~99% while a prose-governed one did not move at all.

Fix any of them and something real improves. But fixing all of them still does not address what happened here: the product generated an unbounded apparatus to compensate for missing primitives, that apparatus consumed the work it was built to perform, and no part of the product noticed, prevented, or could clean it up.