388 pull requests. 180 of them merged. Every line written by an AI. Claude co-creator Boris Cherny posted these numbers from an experiment that has been running inside Anthropic for weeks: a Slack channel called proj-claude-maintains-apps, where Claude shows up every day, finds problems, fixes them, opens PRs — and waits for a human to press merge. The engineers' remaining job is a single button.
This is not a demo. It is a structural signal: the bottleneck in software engineering has moved from writing code to reviewing it. The data behind that shift is worth unpacking before anyone calls it hype.
What Claude actually did: eleven chores, zero new features
Cherny assigned Claude a maintenance routine across six surfaces — iOS, Android, desktop, web, CLI and Agent SDK. Eleven task types, and none of them is "build something new":
- Crash patrol. Open the real app in a simulator, poke it until it breaks, locate the cause, open a fix PR with repro steps and a truth table. Cherny's original instructions explicitly forbid faking it with a stand-in app.
- Duplicate abstraction merging. Scan the codebase for lookalike implementations and collapse them into one.
- Dead code cleanup. Delete what static analysis proves unreachable immediately; for "suspected" dead code, add logging, observe for a day, delete the next day if nobody walked through it.
- Abstraction leak fixes, always-passing test removal, flaky test triage, feature-flag removal, usage-based sunsetting of forgotten internal features.
That "log for a day, then delete" discipline is the instinct of a senior engineer. Claude is being paid in tokens to do the work nobody wants to do and nobody gets promoted for.
The bottleneck has flipped: generation is cheap, review is expensive
Anthropic's own March announcement on Code Review gave the first number: per-capita code output grew 200% year over year, and code review became the bottleneck.
The independent evidence is stronger. Faros AI's 2026 report The Acceleration Whiplash, built on two years of telemetry from 22,000 developers and 4,000+ teams, found that at high AI adoption:
- Epic completion per person: +66.2%. Task throughput: +33.7%. PR merge rate: +16.2%.
- But weekly deployments: −11.7%. Bugs per developer: +54%. Incidents per PR: +242.7%.
- Code merged and later deleted: +861%. Average PR size: +51.3%.
- Median time waiting for a reviewer: +441.5% — and 31% more PRs merged without ever being reviewed.
More merged, less shipped. The queue is stuck in review. The human day now looks like: five minutes generating a thousand lines, then an entire afternoon reading them. AI took the writing; humans kept the reading.
Anthropic's Code Review numbers explain why: before launch, only 16% of PRs got substantive review; after, 54%. PRs over 1,000 lines get 84% of their problems caught (7.5 on average); PRs under 50 lines get 0.5. One review costs roughly 20 minutes and $15–25 in tokens. The system never approves anything — approval stays human. The boundary is explicit: AI can find, fix and propose without permission; merging and shipping require a person.
How the system is built: fix the routine, not the result
Four layers: Claude Tag sits in Slack as the entry point (upgraded August 13 to read the whole channel's context before acting). Routines are the execution layer — launched April 14, they bundle prompts, repos and connectors, triggered by schedule, API calls or GitHub events, running on Claude Code's cloud infrastructure. Claude Code Review is the review layer. Humans are the approval layer.
The most transferable lesson is Cherny's tuning method: when a class of PR keeps failing, he does not fix the PRs one by one — he edits the Routine that generated them and watches the next few days of output. Prompts stop being one-shot inputs and become long-lived assets that need operating: write, ship, observe, iterate, exactly like a production service. Each fix compounds into the rule set, so tomorrow's batch of PRs contains fewer mistakes by construction.
What it means for the industry
- A review economy is forming. If generation is effectively free, the scarce skill is fast, accurate code reading. Anthropic is already pricing review as a paid product; expect review tooling, review-as-a-service and "merge concierge" roles to multiply.
- Policy is catching up. The Rust project adopted an LLM policy in early August: AI-generated contributions must be disclosed, kept off critical paths, and well tested — and maintainers are explicitly not obligated to review AI PRs. "We can close it" is the new governance floor.
- Engineer value is being redefined. The salary signal is shifting from how fast you write to how fast and reliably you judge. The people who thrive are the ones who can triage 388 PRs without burning out.
This connects to two threads we covered recently: why agent instruction files grow out of control and how multiple agents collide on one codebase. Agent output is no longer the constraint — governance is.
What you can do today
- Hand over the verifiable chores first. Tasks with clear pass/fail checks — crash reproduction, duplicate detection, dead code — are where agents are already reliable. Deferred to taste-based judgment ("is this abstraction over-engineered?"), agents still fail.
- Invest in tests before you invest in agents. A review bottleneck is a test-coverage problem in disguise. The safer your suite, the cheaper it is to trust AI PRs.
- Treat prompts as production assets. Write them like services: version, observe, iterate. Fix the rule, not the result.
- Reconsider your own review workflow. If your team's PR queue is growing faster than deploy cadence, the fix is not more generation — it is faster, cheaper review.
