Claude's merge rate outgrew git, so Anthropic built Scion

Anthropic's CI runs on the order of 25 million code checkouts a day, and fetched naively that would come to more than 600 PB of git traffic every day. That figure sits at the centre of a post on Anthropic's engineering blog describing how the company built its own version control system, Scion, and moved its monorepo off git in five months.

At a glance

• Merges into Anthropic's monorepo rose from around 2,500 a day in May 2026 to more than 30,000 a day in September, and Anthropic expects that growth to keep going.
• Scion assumes clients are always online, so the server computes history, blame, commits, merges and rebases, while clients keep a bounded cache and fetch only the trees and blobs they need.
• The catch is scope: Anthropic says Scion is not suited as a general-purpose git replacement and is hard to offer to others, while commentators point to the cost of leaving git's ecosystem.

If you have not been following, Anthropic's framing is blunt: writing code is no longer its bottleneck. Claude iterates on research loops, micro-optimizes complex programs and builds services from the ground up, so the pressure has moved to infrastructure built for human scale: source control, builds and CI. Anthropic says it uses Claude to write software far more than almost any other company, so it tends to see those tools strain first.

Daily merges went from about 2,500 in May to more than 30,000 in September

In May 2026 Anthropic averaged around 2,500 merged code changes per day. By September the figure was over 30,000. Anthropic writes that latent demand for merging code is practically infinite and that every bottleneck it removes immediately produces more code, so it does not expect the growth rate to slow soon.

Scion was one piece of the five-month push. In the same period Anthropic shipped a code review surface called Antique, code search, a source control IAM system and new ways of landing large amounts of reviewed code. According to AI時短ラボ, a team of seven built Scion, Antique and about half a dozen related systems.

Anthropic presents the project as a case study in which Claude's coding ability both created the problem and helped solve it. AI時短ラボ reports that the first git-to-Scion ingestion pipeline was a mostly hand-written prototype, and that an early Claude Mythos Preview snapshot rewrote it with 20x less memory and 4x the speed while preserving implicit invariants.

At its peak, Anthropic ran several hundred internal git mirrors

Git is decentralized: every clone is a complete repository that can compute diffs, read history and blame, and check out any revision offline. For most repositories that is the right design. Anthropic's monorepo has outgrown it. The history of the main branch alone is almost 100 GB, and a compressed working copy is over 25 GB.

The 25 million daily CI checkouts come before developer environments, agent sandboxes and research jobs are counted. Anthropic tried the standard tools: shallow clones, sparse checkouts, promisor remotes, internal mirrors and repository snapshots called seeds kept in blob storage. They bought time, but seeds fell further behind the tip of main between refreshes, and diff and blame took more and more care on partial clones.

The turning point was noticing that Anthropic, like most companies, used git as a centralized system with one authoritative copy, while nearly all its clients were agents and jobs that are online by definition. The properties that make git good at offline work were, in Anthropic's words, undermining its ability to scale.

In Scion, every commit is a changeset created on the server

Scion splits the work unevenly. The server answers history and blame queries, creates commits, and performs merges and rebases, so there is nothing to push. The client keeps a bounded object cache, lays out working-copy files and watches the filesystem. Every query it uses is also an API, which is what makes Anthropic's automated bisect and revert pipelines practical at scale.

The unit of work is a changeset, an entry in a write-ahead log. Where a git commit points to a tree, a changeset lists the files changed relative to its first parent, with content-addressed pointers to compressed contents in blob storage. No packfiles, locks or ref updates are involved; moving a ref is a compare-and-swap on a single Spanner row.

Blame, path history and commit-graph skip lists are derived data, each computed recursively from a changeset's parents. Think of a bank ledger: each transaction is written once, and balances are worked out from the entries, either in advance or when asked. Anthropic has added new types, such as copy-detection indices, without changing the client.

Every fetch request names an object that never changes

Scion's negotiation never tells the server what the client already has. Starting from a root tree, the scn client checks its local store for missing trees and requests them recursively, then does the same for blobs. Because every object is immutable, any cache can answer, transfers resume cleanly without a multi-gigabyte packfile, and sparse or virtualized checkouts need no special support.

On each node, the client talks over a socket to scion-daemon, which stores objects for the whole machine. According to AI時短ラボ, the daemon queries regional scion-cache servers, which fall back to scion-server reading from Spanner and cloud storage, with hit rates above 99% per layer. The same outlet reports infrastructure about 200 times smaller in CPU and memory than the git mirrors, and CI alone freeing 25% of CPU capacity.

AI時短ラボ also reports that checkouts for CI and research jobs became two orders of magnitude faster, going from minutes to seconds. Those figures come from Anthropic itself, and none of them arrives with measurement details.

The performance claims have no third-party verification, and Anthropic itself says Scion is not suited as a general-purpose git replacement. In our view, the most demanding design choice for engineers is discouraging refs other than main and release branches: it removes global state every server must agree on, but it likely means unlearning the branch-heavy habits git built up over the years.

When other AI-heavy teams hit the wall

Anthropic does not expect many organizations to face these problems in the very near term, but suspects it will not be long before others using AI coding tools hit the same pressure points. It names builds and CI alongside source control as infrastructure built for human scale. No timeline has been given for that work, or for offering Scion outside Anthropic.