⏱️ Reading time: 9 min
Anthropic averaged 2,500 code merges per day in May 2026. By September, that figure had passed 30,000 daily merges: a jump that turned Git into the company’s main bottleneck and pushed it to build Anthropic Scion, its own version control system, in just five months.
📑 En este artículo
The decision wasn’t to optimize Git, but to leave it behind. Almost all users of the monorepo are no longer people: they’re Claude agents and automated jobs that stay connected around the clock, something Git’s original design never accounted for.
TL;DR
- Anthropic migrated its entire monorepo from Git to Scion, its own system, over five months during 2026.
- Daily merges went from 2,500 in May to over 30,000 in September 2026.
- Scion assumes all clients are always online, the opposite of Git’s decentralized design.
- The main branch’s history weighs nearly 100 GB, and the compressed copy exceeds 25 GB.
- In CI alone, the company runs about 25 million code checkouts per day.
What Anthropic Scion Is
Anthropic Scion is the version control system the company built in 2026 to replace Git in its monorepo. Unlike Git, which is decentralized, Scion assumes the server is always available and that clients request only the data they need.
The name reflects a concrete idea: take lessons from other giant monorepos, such as Google’s Piper and Meta’s Sapling, but adapt them to a scenario where clients aren’t developer laptops but fleets of agents and ephemeral machines that connect, request specific data, and disconnect. That’s the core difference from Git: Git was designed so any clone could work without a network; Anthropic’s system assumes the network as part of the design from day one.
What Happened
On October 13, 2026, Anthropic published the full story of the migration on its engineering blog. In May of that year, the company merged an average of 2,500 code changes per day in its monorepo; by September, that number exceeded 30,000 daily merges, about twelve times the volume from four months earlier.
That growth didn’t come from hiring more engineers, but from Claude writing, testing, and merging code autonomously: iterating on research cycles, making micro-optimizations, and building new services without constant supervision at every step. The bottleneck stopped being writing code and became the entire infrastructure built for human scale: version control, builds, and CI.
Anthropic’s response was to build, in five months, its own version control system (Anthropic Scion) and migrate the entire monorepo away from Git. In parallel, the team delivered a code review surface called Antique, an internal code search tool, a permissions system for the repository, and new ways to integrate large volumes of already-reviewed changes.
Context and History
Git is a decentralized system: every clone is a complete, self-sufficient repository, capable of computing diffs, reading history, and running blame without an internet connection. For the vast majority of projects, that remains the right design choice, and it’s a big part of why Git became the standard. Anthropic’s problem is that its monorepo stopped fitting that mold a while ago: the main branch’s history weighs nearly 100 GB, and a compressed copy of the working tree exceeds 25 GB.
The company was already using the usual patches for giant monorepos: shallow clones, sparse checkouts, promisor remotes, and above all, hundreds of internal Git mirrors plus snapshots (seeds) stored in object storage. At its peak, Anthropic ran several hundred Git mirrors at once to spread the load. Those patches bought time, but became harder to operate as the merge rate climbed: the seeds drifted further from the tip of the main branch between each update, and keeping history-dependent operations like diff and blame working required increasingly manual care.
The final diagnosis was that Anthropic, like almost any company, was using Git as a centralized system with a single authoritative copy, when nearly all of its clients (agents and automated jobs) were already online by definition. The properties that make Git excellent for distributed, offline work were, in this case, the very same ones preventing it from scaling.
Technical Details: How the Git Replacement Works
The core principle of the new system is client-server asymmetry. In Git, any client can act as a full server: it has the entire history and can answer any query without a network. In the system that replaced Git at Anthropic, the server is the one that answers questions about file history and blame, creates commits, and runs merges and rebases. The client, by contrast, only keeps a local object cache of bounded size, writes the working copy’s files to disk, watches for file system changes, and gives the user, human or agent, an ergonomic way to talk to the server.
flowchart TD
A["Agent or CI job"] --> B["VCS client"]
B --> C["Central server"]
C --> D[("History and objects")]
C --> E["Blame, diff, merge, rebase"]
subgraph Server
C
D
E
endThat asymmetry is what cuts network and disk consumption: the client computes little on its own, but in exchange needs far less information stored locally. Anthropic calculates that if its 25 million daily CI checkouts were served with Git naively, cloning the full repository each time, traffic would exceed 600 petabytes of data per day. With the lightweight client, each checkout only requests the files and objects the specific task needs.
The other structural change is that all version control queries are exposed as an API, not just as client commands. With Git, a CI job that needs to know who last modified a line, or how two commits relate, has to keep a local copy of the repository or depend on a specific external provider’s API. With the new system, those same queries are available via API, so in many cases a job needs no local repository at all. That property enabled new internal tools, such as automated bisect and change reversion, built directly on top of the server’s API.
Impact and Analysis
Anthropic’s case is, for now, an anomaly: few companies merge 30,000 code changes a day. But the company argues the pattern isn’t exclusive to them. Any organization that lets Claude or equivalent models write and merge code autonomously, without a human reviewing every line before every commit, will sooner or later hit the same design limits of Git: a system built for every developer to work offline, in a world where the typical client is now a permanently connected agent.
Anthropic’s version control system doesn’t solve the problem by switching tools alone. Building it required, in parallel and within the same five months, rebuilding code review, internal search, and the repository’s permissions system: a complete redesign of the chain that runs from Claude writing a change to that change being merged and auditable in the monorepo.
💭 Key takeaway: Anthropic’s own text sums it up: Claude was both the cause of the problem, through the volume of code it generates, and the tool that made it possible to solve quickly, by helping build a new version control system in five months.
The obvious limitation is that this centralized approach has a cost. If Anthropic’s internal VCS server goes down, no client can operate offline, unlike a locally cloned Git repository. For a monorepo with hundreds of agents and CI pipelines depending on that server at all times, the server’s availability literally becomes the availability of being able to code at all.
What’s Next
Anthropic didn’t announce a date to open-source the system that replaced Git, and nothing in the announcement suggests it will do so soon: it’s custom-built for its own monorepo and its own scale of agent use. What the company did confirm is that it will keep investing in this infrastructure, because internal demand to merge code is, in its words, practically infinite. Every bottleneck they remove immediately triggers an increase in the amount of code they produce.
This case serves as a reference for any team evaluating how much code a model like Claude can start merging without direct human intervention. If the rate of daily changes multiplies twelvefold in four months, as happened at Anthropic between May and September 2026, the question stops being which model to use and becomes how fast the development infrastructure behind it collapses.
Try it yourself: read Anthropic’s full technical announcement and check how many of the 25 million daily checkouts they describe resemble those in your own CI pipeline.
Frequently Asked Questions
What is Anthropic’s internal VCS and what is it for?
It’s the version control system Anthropic built to replace Git in its main monorepo. It allows Claude agents, CI pipelines, and human developers to read, modify, and merge code without every client needing a full copy of the history.
Why didn’t Anthropic stick with Git?
Because Git’s decentralized design, built for clients working offline, stopped fitting once nearly all of the repository’s clients became always-connected agents and jobs. Maintaining Git mirrors and seeds became harder to operate as daily merges grew from 2,500 to over 30,000.
How long did it take Anthropic to migrate from Git to the new system?
Five months. In that same period, the team also built Antique, its code review surface, an internal code search tool, and a permissions system for the repository.
What inspired Anthropic Scion?
Earlier monorepo-scale version control projects, such as Google’s Piper and Meta’s Sapling, which had already solved some of the same scaling problems for their own giant repositories.
What happens if Anthropic’s version control server fails?
Unlike a cloned Git repository, where every local copy keeps working offline, clients of this system depend on the server being available for almost any operation, from making a commit to checking a file’s history.
References
- Anthropic Engineering: the original announcement about the migration from Git to Anthropic Scion, published October 13, 2026.
- Wikipedia: entry on Piper, Google’s internal version control system that inspired part of the design.
- Sapling: official site of Meta’s version control system, the other reference cited by Anthropic.
- Git: official documentation for the version control system Anthropic replaced in its monorepo.
📱 Like this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day. @programacion
Featured image: Foto de Árpád Czapp en Unsplash
Did it work for you? Got a different error? Say so below: questions get answered and help the next reader.
Leave a comment
0 Comments