The speed of AI writing code completely overwhelmed Git; Anthropic redesigned the version control system.
In five months, seven people built a brand-new version control system, Scion, from scratch and completed the migration of the entire main codebase.
There was only one cause: human tools failed in the face of AI commits.
In May of this year, Anthropic merged about 2,500 code changes per day.
By September, that number exceeded 30,000.
The frequency of code merges skyrocketed more than tenfold.
Now, writing code inside Anthropic is no longer the bottleneck. Claude can autonomously iterate on research loops, fine-tune complex programs, and build entirely new services out of thin air.
The real bottleneck has become the infrastructure originally designed for human developers: code version control, build systems, and CI pipelines.
Consuming 600 PB of traffic per day, Git was stretched to death.
The code management model Anthropic uses is a massive monorepo.
The main branch's history is nearly 100 GB, and the compressed working copy exceeds 25 GB.
To support intensive CI automated testing, research tasks, and agent sandboxes, they need to perform about 25 million code checkouts per day.
If they used Git directly to handle it, the network traffic generated per day would exceed 600 PB.
Git's core logic is decentralized. Every local clone is a complete repository, with full capability to view history offline, compute diffs, and run blame.
This model is suitable for humans working in offline environments.
But at Anthropic, almost all clients are always-online AI agents and automated tasks.
To keep Git alive, they tried every conventional industry solution: shallow clones, sparse checkouts, object storage snapshots, and even deploying hundreds of Git mirror nodes on the internal network.
As mirrors multiplied, machine memory and disk began to buckle. Snapshot updates could not keep up with the speed of code merges, and any diff or blame that relied on history records would frequently cause errors across the entire partial clone.
Git's decentralized nature instead became the biggest obstacle to scaling.
The all-new system Scion: eliminating local repositories.
Anthropic overturned Git's basic assumptions and designed Scion around the premise that agents are always online.
The core logic of this system changed fundamentally:
Clients do not store complete copies.
Git requires clients to have full repository processing capability.
Scion pushes all computation to the server. History queries, line-change location, code merges, and rebases all run on the server. The client only maintains a limited local object cache, places files on disk, and fetches the rest on demand.
Changesets replace tree pointers.
Every Git commit saves a pointer to the entire directory tree.
Scion's smallest unit of work is the changeset. It only records the list of modified files for the current change relative to its parent, plus pointers to compressed file contents in cloud storage.
There is no tarball packaging process and no cross-server coordination lock. Creating a commit no longer depends on branch pointers; modifying a branch only requires a single-row CAS operation in the Spanner database.
On-demand loading, no global fetch.
In Scion, the working copy has become optional.
If a CI automated task only needs to see the diff of a certain commit, it can request the result directly from the server via API without downloading the complete repository on the local machine.
Even when files need to land on local disk, Scion uses virtualization and sparse checkout mechanisms: only the file that the task reads is fetched from the underlying layer.
Hierarchical caching crushes traffic.
In the specific architecture, the local client scn only communicates with the local scion-daemon.
The daemon requests data from the regional cache server scion-cache, and only then falls back to the core scion-server and database.
Each layer achieves a cache hit rate of over 99%.
After this architecture was deployed, Anthropic's code checkout speed shortened from several minutes to a few seconds.
The CPU and memory usage of the servers supporting the underlying operation was reduced to one two-hundredth of the original Git mirror cluster. In the CI stage alone, 25% of CPU compute resources were saved.
Using Claude to build a weapon to replace Git.
The development process of the entire system was itself a testing ground for AI's code-writing ability.
The team that completed the research and development of the entire system, replaced Git, and incidentally built half a dozen systems including the code review platform Antique and code search, had only seven people.
Seven people, five months.
The most typical example is the data migration pipeline. The team initially hand-wrote a prototype of the data ingestion pipeline from Git to Scion.
Then they obtained internal access to the Claude Mythos preview and directly had the model rewrite it.
Without any additional prompts, the version Claude rewrote reduced memory usage to one-twentieth of the original, improved runtime speed by 4x, and kept the original data structures and ingestion order rules intact.
Engineers involved in the project said that when it comes to writing code, Claude's current level has surpassed their own.
The core working style of engineers has completely changed:
Engineers' main task is to say no to Claude.
To satisfy local needs, AI instinctively tries to break the system's underlying constraints. For example, multiple automated tasks tried to confirm when code was merged into the main branch by hard-reading commit logs line by line; this approach would instantly drag down performance and required humans to correct it to directly call the review system.
There is also the code adversarial review mechanism. When reviewing code, AI tends to be overly defensive, stuffing in a large amount of unnecessary validation logic out of nowhere, making the system extremely complex.
The work of human engineers now is to control trade-offs in cross-system design at a higher level and review the intent of each commit, rather than picking apart every line by eye.
Traditional workflows collapse: no merge queue, AI acts as network admin in Slack.
As the scale of agents explodes, more traditional R&D habits are smashed to pieces.
The traditional merge queue has failed.
When massive amounts of code merge concurrently every minute, global locking and queuing would paralyze the entire CI system.
Anthropic removed the global merge lock and switched to merging code first, then running automated regression tests before deployment.
This means the probability of code conflicts increases significantly. But they found that Claude automatically resolves conflicts faster than humans can even understand where the conflict occurred.
The operations model has also changed. The team used Claude Tag to create a set of component monitoring channels in internal Slack.
Each channel has a dedicated Claude instance stationed in it, which the company officially calls superfans.
Some Claudes specifically watch scion-daemon, some specifically watch scion-cache, and some specifically watch the merge queue.
These AIs have full access to logs and monitoring metrics, tirelessly refreshing backend charts every day and catching tiny anomalies that traditional static alert rules simply cannot identify.
Is Git really going to be eliminated?
Anthropic has no intention of open-sourcing Scion to replace Git.
They admit that Scion's design is completely tied to extremely massive monorepos, massive concurrent programming by AI agents, and token consumption far beyond the limits of ordinary enterprises.
For the vast majority of ordinary development scenarios, Git remains an extremely excellent version control tool.
Anthropic predicts that as AI programming tools spread, over the next 6 to 12 months, other teams relying on AI to write code will also hit this wall one after another.
They made this approach public to give the open-source community, GitHub, and GitLab ideas: Git's server side can absolutely be redesigned, introducing more efficient RPC query mechanisms and more flexible negotiation protocols; there is no need to fully continue rules set decades ago for humans writing code by hand.
When the speed of AI writing code rises exponentially, all patches in software engineering originally made for human flesh must be torn down and redone.
Source:
https://www.anthropic.com/engineering/redesigning-source-control