Coding Stopped Being the Bottleneck. Storing Code Became One
On October 13, 2026, Anthropic published an engineering blog post titled "Redesigning source control at Anthropic," and quietly announced something version control history has rarely seen: the company moved its main code repository off Git and onto Scion, a version control system it built itself. The reason is refreshingly unglamorous. Claude was writing code faster than infrastructure designed for human-scale teams could absorb it.
The numbers, all from Anthropic's own account and not independently verified, go like this: in May 2026, the company averaged around 2,500 code changes merged per day. By September, it was merging over 30,000 per day. That is a twelvefold increase in four months. One line from the post deserves to be quoted in full: "the latent demand for merging code is practically infinite, and every bottleneck we remove immediately leads to a further increase in the amount of code we produce."
In other words, writing code is no longer the bottleneck. The bottleneck has moved to everything built around human-scale development: source control, builds, and continuous integration. That is what makes this post worth careful reading even if you never run a monorepo. It is not a product announcement. It is a first-person incident report and rebuild plan from the team whose infrastructure got pierced by its own AI output.
How Git Broke
Start with scale. The history of Anthropic's main branch alone is almost 100 GB, and a compressed working copy is over 25 GB. Every day, CI performs on the order of 25 million code checkouts — before counting developer environments, agent sandboxes, and research jobs.
Fetched naively over Git's wire protocol, that would be more than 600 PB of git traffic per day. Chinese media covering the story reached for a vivid comparison: the equivalent of moving 120 million 4K movies across the internal network daily. No amount of incremental tuning closes a gap of that shape.
Anthropic tried the standard workarounds first. Sparse checkouts, shallow clones, and at peak several hundred internal Git mirrors. The mirrors still could not keep up with the rate at which Claude produced changes. Copying repositories is a linear operation; agent-generated changes are not.
The root cause is a design assumption. Git was built for offline humans: every copy is complete, every copy works alone. That is exactly why it has ruled version control for two decades, and exactly why it fails here. Most of Anthropic's "clients" are not people. They are always-online agents and automated jobs, many of which never need a local copy at all. Paying the full cost of a complete replica for a use case that no longer exists is a losing trade.
Scion's Three Inversions
Scion has recognizable ancestors. Google's Piper and Meta's Sapling both solved version control at enormous monorepo scale, and Anthropic explicitly credits their "hard-won lessons." But Scion rests on a different premise: clients are always online. That premise produces three fundamental inversions of Git's design.
The first inversion: from full replicas to a small cache. A Git client needs the whole repository to work. A Scion client keeps only a bounded local object cache, and pushes history questions, blame, commits, and merges to server-side APIs. Many automated jobs simply ask the server for answers and never download code at all. Checkout becomes optional. The authority of the repository moves entirely to the server, and the client becomes light enough to discard at any moment.
The second inversion: changesets instead of commits. Scion's unit of change is the changeset, which stores the list of changed files relative to the first-parent commit, plus content-addressed pointers into blob storage. Changesets are created server-side, written to a write-ahead log, and instantly available everywhere after creation. There is no locking and no cross-server coordination. The cost of a commit scales with the size of the change, not the size of the repository — a life-or-death difference when 30,000 merges land per day.
The third inversion: virtualized checkouts. Fetch by directory, stream lines as they are read. Nowhere in the system — not even on the server side — does a fully materialized copy of the repository exist. Data is horizontally distributed, scaling means adding machines, and there are no packfiles or repository maintenance to schedule.
All three inversions express the same worldview: when the client is an agent rather than a person, version control should be built as a distributed service, not a distributed filesystem.
The Measured Numbers: One Two-Hundredth of the Footprint
After the migration, Anthropic reports the following, again by its own account: Scion's CPU and memory footprint is 200 times smaller than the Git mirroring infrastructure it replaced. Every tier of its three-level caching architecture maintains a hit rate above 99 percent. CI and research jobs now check out code in seconds rather than minutes — a two-order-of-magnitude improvement. CI alone realized a 25 percent CPU capacity win.
The architecture has three layers: node-level scion-daemons, region-level scion-caches, and authoritative scion-servers, all answering the same RPC interface. Most requests are absorbed by the first two tiers; the authoritative layer handles real writes and cache misses.
Some of the most interesting changes never show up in a performance chart. The merge queue is one. When hundreds or even thousands of changes can merge while tests are running, a global merge-queue lock designed for humans stops making sense. Anthropic moved to post-merge and pre-deploy automated testing instead. Concurrent changes can conflict — but the company says Claude typically fixes those conflicts faster than humans can even identify them. The security model was rebuilt too. Scion supports rich access control down to individual directories, protecting the most sensitive code without losing monorepo benefits, and the accompanying review tool can express semantic constraints on approvals, separating comment-only changes from sensitive logical ones so human reviewers focus on what matters.
Seven People, Five Months, and an AI Often Told "No"
A team of seven people built all of this in five months. Not just the version control system: the same team delivered Antique, a code review platform, plus code search, source control IAM, and a set of related systems, and completed the full migration of the monorepo from Git. During those five months, the daily merge volume grew another tenfold.
Anthropic acknowledges that in the past, developing and deploying a system like this would have taken years of iterative migration and many more engineers.
Claude's role in the story is peculiar: it created the problem and then helped solve it. The most cited example: the team had largely handwritten the first version of the git-to-Scion data ingestion pipeline as a prototype and thought it was good. Then they handed it to an early internal snapshot of Claude Mythos Preview and asked it to rewrite the whole thing. With no further instructions, the model produced a version that consumed 20 times less memory and ran 4 times faster, while preserving every implicit invariant around ingestion ordering and data structures. Similar windfalls kept coming: Claude casually found an algorithmic optimization to ancestry queries that the team's own indexes had missed — the kind of thing an expert would need days or weeks of analysis to find. "And then did it all again the next day."
The engineers' value did not go to zero; it moved. Every engineer on the team would now rate Claude as better at writing code than they are. But system-level judgment stayed human. In their own words: "Very often, we found that the role of the engineers was to tell Claude 'no.'" Agents sometimes violate core system constraints to satisfy a pattern — several systems tried to brute-force lookup of merge times by linearly reading the commit log instead of asking the review tool. Sometimes they over-engineer in response to hypothetical concerns, adding excessive validation around internal services. Humans caught all of this. The team still reviews every change request, but they now examine the intent of a change rather than reading every line of code.
One operational detail says a lot about the culture. Anthropic assigned a dedicated monitoring Claude to each component, nicknamed "superfans" — one for the scion-daemon, one for the scion-cache, one for the Antique merge queue, and so on. These Claudes watch telemetry and logs, "act like an experienced engineer who has nothing better to do than to refresh charts and look for anything strange," and catch subtle issues that traditional alerts treat as one-dimensional.
The Boundary: Not a Git Replacement for General Use
If you are already planning to migrate your company's repository, stop here. Anthropic is explicit: "Scion is by no means a suitable replacement for git for general use." The design only makes sense for truly enormous monorepos, with either tens of thousands of engineers or swarms of agents prolifically writing code. Teams at ordinary scale get the lessons, not the system.
Scion is not open source, and there is no plan for a general release. The reasoning is practical. It diverges significantly from Git, so adopting it would mean migrating the entire development lifecycle — code review, code search, CI — and any attempt to build a public version that tries to please everyone would satisfy no one. Anthropic's internal versions of those components are highly bespoke and difficult for other organizations to adopt. The company also admits something candid: its ability to spend tokens for internal use far exceeds what any other business would realistically want to spend. The whole approach rests on resources others cannot easily replicate.
What Anthropic chose to do instead is share the design thinking with GitHub, GitLab, and the open-source community. A git server does not have to work the way a git client does; comprehensive server-side RPCs could exist, perhaps standardized across forges. The negotiation protocol does not have to look like it does today, and git's sparse and shallow features could be made to compose well. The post closes with an acknowledgment that the Git community has spent nearly two decades scaling the platform for millions of developers, and that Anthropic's contribution is narrower: an early view into how agentic software development interacts with these systems. The company predicts this class of problems will become commonplace over the next six to twelve months.
AI Coding Is Pushing Human-Scale Infrastructure Past Its Limits
Zoom out, and the real signal is not Scion itself but the trend it confirms.
Large-scale version control migrations have historical precedents. Google's Piper and Meta's Sapling each took teams of dozens to hundreds of engineers, working for years. Anthropic did the equivalent with seven people in five months — while its daily merge volume grew another tenfold mid-flight. That is not because Anthropic's engineers suddenly got smarter. It is because the economics of writing code changed: when the cost of producing code approaches zero, every pipeline designed around expensive code overloads.
AI coding made the cheapest stage of software development even cheaper, so pressure flooded into the expensive stages: storage, review, testing, and merging. This case is worth reading word by word because it is the first detailed public specimen of what happens when agent output exceeds the design capacity of human-scale infrastructure. The most fascinating part is Claude's triple role: it created the pressure, helped engineer the relief, and in the process rewrote what the daily job of an engineer looks like — from someone who reads every line, to someone who tells the AI "no."
For most teams, the conclusion is not that Git is dying. Git remains the world's default, and Scion's boundaries are clearly drawn. The real conclusion is that once agents start writing your code, the bottleneck moves from writing to managing. Review queue depth, CI capacity, merge throughput, permission granularity — every system designed around human speed is a candidate for the next breach. Anthropic simply hit the wall first, then dismantled it for everyone to inspect. As for when other organizations hit theirs, the company's forecast is six to twelve months. The clock on that prediction has already started.