Anthropic's AI Agents Broke Git. Seven Engineers Built a Replacement in Five Months.

In May 2026, Anthropic merged about 2,500 code changes per day. By September, the number passed 30,000. Four months, twelve times the volume.

The number matters less than the response. They replaced Git.

Anthropic's engineering blog put it plainly: the main branch history is nearly 100GB, compressed working copies exceed 25GB, and CI performs about 25 million checkouts per day. Pulled naively, that would be more than 600PB of traffic per day. They tried shallow clones, sparse checkout, promisor remotes, object-storage snapshots, and at peak ran hundreds of internal Git mirrors to offload traffic. Those measures bought time, but not an endpoint.

Then they stepped back and saw a fact they had overlooked: nearly all clients are agents and jobs, and by definition they are online. The capabilities Git prepares for offline scenarios, such as every clone a full repository and every operation independent of the server, became a burden in their scenario.

So they built Scion. Seven people, five months, a centralized version control system built from scratch, completing a full migration of a nearly 100GB monorepo.

What Scion changed

Scion's core idea in one sentence: move the heavy work to the server.

Commit, merge, rebase, blame, and file-history queries all run on the server. The client keeps only a bounded local object cache, places working files, watches the filesystem, and asks the server for data when it needs it.

This inversion produced a chain of effects.

Commit cost decouples from repository size. A Git commit is essentially a pointer to a full tree object, and the hidden cost of committing is tied to total repository size. Scion's basic unit of work is the changeset, a write-ahead log record that lists only the files changed relative to the first parent and points to content-addressed compressed blobs. The cost of creating a commit depends only on how much changed, not on how big the repository is. At 30,000 merges a day, that difference is decisive.

Global refs are sharply reduced. Branches and tags require all servers to agree, and in a horizontally scaled architecture, any state requiring global coordination is a bottleneck. Scion minimizes refs. Landing a change is essentially a compare-and-swap on a single row in Cloud Spanner. There is no global merge lock. Commit, merge, and rebase require no cross-server coordination.

CI no longer needs a materialized local repository. Scion exposes all source-control operations as RPC APIs. When a CI job needs the diff of a commit, it asks the server. Anthropic says that without this low-cost server-side access, its automated bisect and revert pipelines would not be feasible at the previous scale.

Layered caching dissolves the synchronization problem. Git mirrors are hard to maintain because each mirror must rebuild a full or near-full repository locally and then sync with the main branch. Scion's caches do not need to sync, because the data is immutable and content-addressed. Any server or cache can answer requests independently, with no need to confirm consistency with other nodes. Scion uses three layers: a node-local daemon, a regional in-memory cache, and an authoritative server backed by Spanner and cloud storage. Each layer has a cache hit rate above 99%.

The cumulative effect of these design choices is large. Scion's infrastructure CPU and memory footprint dropped to about 1/200 of the previous Git mirror setup. Code checkout for CI and research tasks went from minutes to seconds. CI alone saved about 25% of CPU capacity.

The second domino

Source control was only the first domino.

In another article about CI, Anthropic disclosed a set of numbers: within six months, CI job volume grew 25 times and total test volume grew 10 times. Anthropic engineers now ship about 8 times more code per quarter than the 2021-2025 average, with Claude writing 80% of it.

Traditional CI assumes every change runs all tests, or a reasonable subset. At tens of thousands of merges per day, that assumption collapses. Anthropic built a deterministic test-impact analysis service that decides which tests each change should run based on historical test results and package dependencies. The service itself went through repeated scaling failures. Three temporary patches lasted 70 days, 29 days, and less than a day, respectively.

The deeper change happened in the merge model. The traditional global merge lock plus serial merge queue barely works at agent scale. While tests are still running, hundreds of changes may already have landed. Anthropic's response is to move more testing after merge and before deploy, and hand concurrent conflicts to agents for automatic repair. They found agents often fix conflicts faster than humans notice them.

Code review was redesigned as well. Anthropic built a companion review tool called Antique. Traditional PR review centers on humans reading diffs line by line. Antique is designed more around agent-callable APIs and automated acceptance policies. When agents submit far more changes than humans can review, the value of a review system shifts to machine judgment. Human reading speed is no longer the limiting factor.

Piper, Sapling, and a 15-year wait

Anthropic's engineering blog credits its predecessors: Google's Piper and Meta's Sapling gave Scion hard-won lessons.

Google's Piper carries the largest single code repository on Earth: 86TB of data, 2 billion lines of source code, 9 million source files, more than 25,000 engineers, and about 40,000 commits every workday, roughly 24,000 of them from bots. Piper was centralized from the start. The single source of truth is server-side; developers have only a workspace locally, not a full clone. Google engineers' daily CitC cloud workspace caches on average fewer than 10 files locally and pulls the rest on demand.

Meta's Sapling took another path: starting from Mercurial, deeply modified, then contributed back to open source, optimizing stacked-diffs workflows and large monorepo scenarios.

These systems have existed for more than a decade. But Piper and Sapling still assume the dominant client is a human developer: clone, work for hours, push. Scion's difference is that from day one it wrote "the client is an agent fleet" into its design principles. By early 2015, Google's monorepo handled about 40,000 commits per day, 24,000 from automated systems. But those automated systems ran on Google's own infrastructure and behaved predictably. Anthropic faces Claude-driven agents that initiate checkouts, commits, and merges at higher frequency, in less predictable patterns, simultaneously.

Scion is the first version control system designed with agent scale as a first-class constraint. That difference determines its architectural choices: Piper and Sapling optimize the working experience for human engineers; Scion optimizes throughput for machine clients.

Three waves

Anthropic says plainly in its blog that Scion is not a general-purpose replacement for Git. It fits enormous monorepos, either tens of thousands of engineers or a swarm of agents writing code frantically. The amount of tokens they burn internally is not something an ordinary company can afford to copy.

But the impact will arrive in three waves.

The first wave is already happening. Git hosting providers are strengthening server-side capabilities: better server RPC, more reliable shallow and sparse checkout, more efficient caching. The goal is to let "server does more, client carries less" hold the line inside existing Git tooling.

The second wave, six to twelve months out. Companies that already have large monorepos and have begun using agents at scale will internalize the design ideas of Piper, Sapling, and Scion. They may not build a whole system from scratch. They will introduce server-centric capabilities at key points. For example, letting CI avoid full clones, or letting agent sandboxes fetch only needed files via API instead of pulling the whole repository.

The third wave, a few extreme cases. Tens of thousands of merges per day, tens of millions of CI checkouts. That is the scale at which building a source-control system from scratch is worth it. For most teams, the more realistic near-term pain is runaway CI queues, increasingly fragile shallow clones, and PR review backlogs. These problems do not require Scion to solve, but they point in the same direction: assumptions designed for humans are failing one by one.

The open-source community has already responded. A project called Mega appeared on GitHub, described as an open-source implementation of Google's Piper, a Git-compatible monorepo engine built for the AI agent era, written in Rust, aiming to provide infrastructure for AI coding agents on petabyte-scale codebases. Whether that path works remains to be seen, but it shows the industry has realized this is not Anthropic's special problem alone.

Seven people, five months, and one word: no

Scion and Antique were built by a team of seven in five months. Claude did much of the work. The first version of the migration pipeline was mostly written by hand, but after Claude rewrote it, memory use dropped to 1/20 and speed increased 4 times.

There is an easily missed detail here. Anthropic notes in its blog that Claude's adversarial review works well in many ways, but it can also become short-sighted. Human engineers need to actively stop the model from over-engineering in response to hypothetical concerns. During the migration, much of the work was saying no to Claude, stopping it from breaking global constraints for the sake of local elegance.

This points to a larger trend. When agents can write, review, and repair code far faster than humans, the engineer's anchor of value shifts from writing code to defining boundaries. Concretely, that means a new set of core abilities: defining architectural constraints and non-negotiable boundaries so agents know what they may do and what they must never touch; reviewing agent intent rather than line-by-line code, judging whether a change moves the system in the right direction; recognizing and stopping agent over-design, intervening when the model introduces unnecessary complexity for a possible need.

Scion itself is an example: the reason seven people could design and migrate a version control system in five months is that Claude carried much of the implementation. But the architectural decisions, including server-centric design, the changeset model, layered caching, and API-first, required humans. Code can be written by agents, but the judgment of what is worth writing and what should not be written is still human.

Conclusion

Anthropic's engineering blog opens with this sentence: At Anthropic, writing code is no longer the bottleneck to building systems or doing research.

That sentence says something narrower than "AI can write code." It says that writing code itself is no longer the core constraint on software production. The bottleneck has moved to source control, builds, CI, and review, problems considered solved for the past twenty years.

Git will not disappear tomorrow. For most teams, it remains the best choice. But the message Anthropic sent with seven people and five months is clear: when agent throughput becomes the new baseline, tools designed for human pace will go from adequate to inadequate, and then from inadequate to obstruction.

You either change on your own, or wait for it to block you in the CI queue.