Claude wrote so much code Anthropic had to replace Git

Anthropic just published one of the clearest signs yet that AI coding is changing the software stack underneath it.

The company says Claude is now writing and modifying code at such volume that source control became the bottleneck. In May 2026, Anthropic averaged about 2,500 merged code changes per day. By September, that number had passed 30,000 per day.

So Anthropic did something extreme: it built Scion, an in-house version control system, and migrated its monorepo away from Git in five months.

The headline is not simply that Anthropic replaced Git. The bigger story is why: Claude made code cheap enough that the coordination layer started breaking first.

Claude made coding faster than merging

Anthropic's engineering post is blunt about the shift. It says coding is no longer the bottleneck for building systems or doing research inside the company. Claude can autonomously iterate on research loops, optimize programs, and build services from the ground up faster than the old developer infrastructure can comfortably absorb.

That is the important sentence.

For decades, the hard part of software development was writing, reviewing, testing, and shipping code at human speed. Git, CI, code review, and branch workflows were designed around that pace.

AI coding agents change the pressure point. If a model can produce useful changes faster than engineers can type them, the bottleneck moves to the machinery around the code: checkout speed, merge queues, review surfaces, permissions, CI capacity, conflict handling, and audit trails.

That is what Anthropic says happened.

Why Git strained

Git is excellent for distributed, offline development. Every clone can carry history, compute diffs, inspect blame, and work locally.

Anthropic's workload had moved in the opposite direction. The company says most of its clients are online agents, CI jobs, research jobs, and sandboxes, not humans working offline on laptops. Its main branch history alone is close to 100 GB, a compressed working copy is over 25 GB, and CI performs roughly 25 million code checkouts per day before counting developer environments and agent sandboxes.

Fetched naively, Anthropic says that could mean more than 600 petabytes of Git traffic per day.

The company had already used conventional monorepo tricks: mirrors, shallow clones, sparse checkouts, promisor remotes, and repository snapshots. Those bought time, but the merge rate kept climbing.

So Anthropic designed source control around a different assumption: clients are almost always online, and the server can answer source-control questions directly.

What Scion changes

Scion is built as a client-server source control system for enormous monorepos and agent-heavy workloads.

Instead of every client behaving like a miniature source control server, Scion pushes more work to the server. The server handles history queries, diffs, blame, commits, merges, and rebases. The client keeps a bounded local cache, lays out working-copy files, monitors filesystem changes, and asks the server for what it needs.

That matters because many jobs no longer need a full repository checkout. A CI job can ask Scion for a diff. A tool can ask who last touched a line. A pipeline can query history through APIs instead of maintaining its own local clone.

Scion also treats the working copy as optional and sparse by design. Anthropic says CI and research jobs now check out code two orders of magnitude faster, with checkouts taking seconds rather than minutes, and that its Scion infrastructure uses about 200 times less CPU and memory than the previous Git mirroring setup.

Claude helped build the system that Claude made necessary

The recursive part is the most interesting.

Anthropic says Claude's coding ability created the need for Scion, but also helped the team build Scion quickly. A team of seven people built Scion, an internal code review tool called Antique, code search, source-control IAM, and related systems while the company's code merge volume grew by 10x.

One example from the post is especially sharp: Anthropic says an early internal Claude Mythos Preview model rewrote a Git-to-Scion ingestion pipeline with no further instructions, producing a version that used 20 times less memory and ran four times faster.

That is not just autocomplete. That is model-assisted infrastructure engineering at company scale.

It also connects to Anthropic's earlier writing on recursive self-improvement, where the company described Claude increasingly writing the code that helps build Claude. The new Scion story gives that abstract idea a concrete backend: when the model accelerates engineering, the company has to rebuild the systems that absorb engineering output.

Humans still tell Claude no

Anthropic is careful not to frame this as engineers disappearing.

The post says engineers still review every change request for Scion, but their work has shifted. They focus more on intent, system design, constraints, and tradeoffs, rather than reading every line in the old way.

It also says engineers often had to tell Claude "no." In Anthropic's telling, agents sometimes satisfied a local pattern while violating a broader system constraint, or over-engineered defensive logic after adversarial review raised hypothetical concerns.

That detail is important. The future Anthropic is describing is not "Claude writes everything and humans leave." It is closer to "Claude writes enormous amounts of code, and humans become the constraint setters, reviewers, and taste-makers."

Why this matters beyond Anthropic

Most companies do not have Anthropic's scale, token budget, or internal model access. Scion is not being pitched as a drop-in Git replacement for ordinary teams.

But the pressure pattern probably matters.

If coding agents become common inside large engineering organizations, Git itself may not be the first thing that breaks. But the surrounding workflow will feel the strain: branch hygiene, PR queues, test capacity, review quality, dependency policy, permissions, provenance, and deployment controls.

The lesson is that AI coding does not only change how code is written. It changes the required shape of the software development lifecycle.

Anthropic's Scion story is a warning shot for the rest of the industry: when agents can produce code at machine speed, human-scale development infrastructure starts to look slow.