Anthropic has moved its main monorepo off Git onto an in-house version control system called Scion, after daily merges grew twelvefold in four months.

The company reported that it averaged roughly 2,500 code changes merged per day in May 2026 and more than 30,000 per day by September, with a single-day peak of 30,401 on September 9.[1][4] The cause is the thing Anthropic sells. Claude writes code faster than the tools around it, built for human hands, can absorb it. "The bottleneck, now, is all of the developer infrastructure built for human scale: source control, builds, and CI," the engineering team wrote in a post published on October 13.[1]

Anthropic is open that this is an unusual problem. It says its engineers use Claude to write software more than almost any other company, and that the pattern will spread: "we suspect it won't be too long before others who use AI coding tools experience these same pressure points."[1]

How fast the merge rate climbed

The chart in Anthropic's post starts around 1,000 merges a day in January 2026, holds through the spring, and steepens sharply from July. Volume dipped during a quiet week in early August, then recovered to the September 9 peak. Around June and July, the mix also shifted from GitHub-style pull requests to change requests inside Anthropic's own review tool, Antique.[4]

The monorepo itself is the other half of the story. The history of the main branch alone is almost 100 GB, and a compressed working copy is over 25 GB. Anthropic runs roughly 25 million code checkouts a day for CI, before counting developer machines, agent sandboxes and research jobs. Fetched naively, that would be more than 600 petabytes of Git traffic a day.[1]

Why Git stopped fitting the workload

Git already offers ways to work with part of a repository: shallow clones, sparse checkouts and promisor remotes. Anthropic used all of them, and at its peak ran several hundred internal Git mirrors to spread the load. The mirrors bought time, but they became harder to operate as the merge rate climbed. Snapshots drifted away from the tip of main between refreshes, and history-dependent operations such as diff and blame took more and more care to keep working on partial clones.[1]

The deeper problem was a mismatch. Git is decentralized, so every clone is complete and can compute diffs or read blame while offline. Anthropic was using it as a centralized system with one authoritative copy, while nearly all of its clients were agents and CI jobs that are online by definition.[1][2] "The properties that make git excellent for distributed, offline work were actively undermining our ability to scale as the repo grew," the team wrote.[1]

The bet behind Scion: assume the client is always online

That mismatch shaped the new system. Clients hold a small, bounded object cache and fetch data on demand instead of keeping a full repository. The server answers history and blame queries, creates commits, and performs merges and rebases, so clients compute very little on their own and need far less local data.[1]

Every query the client makes is also exposed as an API. That matters for automation: a CI job that needs the diff between a commit and its merge base can ask the server for it, and many write workloads can skip a checkout entirely. Anthropic says its internal automated bisect and revert pipelines would not be practical at that scale without this cheap, programmatic access.[1] Simon Willison described the result as a reinvention of centralized source control along the lines of Subversion.[3]

How Scion is put together

The unit of work is a "changeset," an entry in a write-ahead log. Where a Git commit points at a tree, a changeset lists the files that changed relative to its first parent, plus content-addressed pointers to compressed file contents in blob storage. Creating commits touches no packfiles and needs no locking or cross-server coordination, which is what lets the system accept changes at a high rate.[1]

Anything that is not part of the changeset is computed as "derived data" from one generic mechanism: file blame, path history and skip lists for the commit graph. Because a changeset records only what changed, those structures are built to answer the questions a plain log cannot, such as who last edited a line.[1][5] Requests pass through tiers: a node-level daemon that stores objects for every job on a machine, regional caches that stream objects from memory, and authoritative servers that read from Google Spanner or cloud storage.[1][4]

Anthropic reports three results from the switch:

• A footprint about 200 times smaller than the old Git mirror fleet in CPU and memory.[1]
• Checkouts two orders of magnitude faster, in seconds instead of minutes.[1]
• A 25% CPU capacity win for CI alone.[1]

Each tier sustains a cache hit rate above 99% and keeps no long-lived state, which Anthropic says makes it easy to scale up when needed.[1]

Claude built part of the tool that manages Claude's output

Engineers handwrote the first version of the pipeline that ingests changes from Git into Scion. Later, they handed an early internal snapshot of Claude Mythos Preview the job of rewriting it, with no further instructions. According to the post, the model produced a version that used 20 times less memory and ran four times faster, while preserving implicit rules around ingestion ordering and data structures.[1][2]

Seven people built Scion, the Antique review surface, code search and a source control identity system, and finished the migration in five months while merge volume grew tenfold.[1][4] The post frames the team's value as judgment rather than typing. It says the engineers would now rate Claude as better than themselves at writing code, and that much of their job is telling the model "no" when it tries to bypass a core constraint, such as reading the commit log linearly instead of asking the review tool when a change merged.[4]

What Anthropic is not giving you

Scion will not be released. "Scion is by no means a suitable replacement for git for general use," the post says, adding that offering it broadly would be difficult because it leans on bespoke review, search and CI components, and because it depends on infrastructure such as Spanner.[1] Anthropic is not the first to look past Git's distributed model. Google runs Piper, Meta runs Sapling, and Microsoft built the Virtual File System for Git to handle very large repositories.[2]

The post does not hide the trade-offs. Anthropic could not replicate a global repository lock, so concurrent changes can still conflict, and the team leans on post-merge and pre-deploy testing instead. Development in Scion also discourages branches and tags beyond main and release branches, and changesets record only first-parent changes, which fits trunk-based work.[5]

The advice to other teams is to measure the bottleneck before rewriting anything, and to climb Git's own tooling ladder first. Scion, by Anthropic's own account, only makes sense for truly enormous monorepos with tens of thousands of engineers or swarms of agents. The company says it will work with GitHub, GitLab and the open-source community on server-side improvements rather than ship a competing product.[1][4]

Every figure here comes from Anthropic's post and has not been independently audited.[4]

Sources

1. Redesigning source control at Anthropic, Anthropic Engineering, October 13, 2026.
2. Anthropic reinvents source control as Claude floods the world with code, The Register, October 13, 2026.
3. Redesigning source control at Anthropic, Simon Willison, October 13, 2026.
4. Anthropic Scion: Why It Replaced Git at 30,000 Merges/Day, explainx.ai, October 13, 2026.
5. Anthropic Scion: why it moved its monorepo off git, The Terminal, October 13, 2026.