What Anthropic's Scion means for Git and AI coding

Anthropic has published a piece explaining why it replaced Git with a source control system it built itself, called Scion, along with a new code review system called Antique. According to Simon Willison’s write-up, “Redesigning source control at Anthropic”, the reason was a sharp rise in merged code changes. They went from around 2,500 per day in May 2026 to over 30,000 per day in September. This explainer works from Willison’s summary and the passages he quotes. Treat anything beyond those as unconfirmed.

The background you need

Source control is the system that records every change to a codebase. It lets many people work on the same code without overwriting each other, and it keeps a full history you can go back to. A commit is one saved change. A merge joins a change into a shared line of work. The main branch is the shared line everyone builds on.

Git is the tool almost every developer uses for this. Git is distributed. When you clone a repository, you normally get the entire history on your own machine, not just the current files. That is why you can commit offline and why Git is fast for everyday work.

The older model is centralized source control. Subversion is the best-known example. One server holds the history. You “check out” a working copy, meaning just the files at a given version, and you send changes back to the server.

Here is an analogy. Git is like handing every reader a full photocopy of the library, including every past edition. Centralized control is like a lending desk: you borrow the books you need, and the archive stays in the building. The analogy breaks in two places. First, Git has features such as shallow clones, partial clones, and sparse checkout that fetch only part of the history or only some files. Second, centralized systems usually need a network connection for operations that Git does locally.

Two more terms matter here. Continuous integration (CI) means that every proposed change triggers automated builds and tests, usually on a fresh machine. Each of those jobs typically starts by checking out the code. So the number of checkouts grows with the number of changes multiplied by the number of jobs per change. Agent sandboxes are isolated environments where AI coding agents run. Each one also needs its own copy of the code.

Finally, code review is the step where someone examines a change before it merges. Adversarial review is a variant where one AI model tries to find flaws in work, often work produced by another model.

At very large scale, standard source control tools strain. Some of the largest tech companies have run in-house systems for years for exactly this reason. So a company building its own system is not new. What stands out here is how quickly Anthropic’s need arrived.

What actually changed

According to Willison, these are the new facts from Anthropic’s piece:

• Volume. Merged changes rose from around 2,500 per day in May 2026 to over 30,000 per day in September. That is roughly a twelvefold increase.
• Size. The quoted passage says the main branch history alone is almost 100 GB, and a compressed working copy is over 25 GB.
• Checkouts. Anthropic says it performs on the order of 25 million code checkouts per day for CI. That count is “before counting developer environments, agent sandboxes, and research jobs.”
• A hypothetical traffic figure. Anthropic estimates that fetching those checkouts naively would mean over 600 PB of Git traffic per day. This is a what-if number, not a measured one. It appears to roughly match the checkout count multiplied by the working copy size. “Naively” means a full fetch every time, with no caching or partial fetching.
• The build. A team of seven built the new system, and the migration from Git took five months, according to Willison.

Two things in the story are interpretation, not reported fact. Willison says Scion “sounds to me like a reinvention of centralized source control along the lines of Subversion.” That is his reading. Willison also added markers to Anthropic’s chart for each 2026 public model release. He guesses that the arrival of Fable/Mythos class models is a key factor in the faster pace of coding. He also notes that his markers show public release dates, not when Anthropic began using the models internally.

One process detail also comes from the piece. Anthropic uses adversarial review heavily. According to the quoted passage, it can be myopic, and skilled engineers had to steer Claude away from over-engineering parts of the system in response to hypothetical concerns.

What it means for developers who use AI tools

You almost certainly don’t need to replace Git. Anthropic’s numbers are extreme. The pattern behind them is still worth understanding, because it can show up at smaller scale.

The bottleneck moves. When agents write code faster, the slow parts become everything around the code: checkouts, CI runs, and review. If you run several agents in parallel, each sandbox needs a copy of your repository. Clone time and CI minutes can grow faster than your team does.

Git already has tools for this. Shallow clones, partial clones, and sparse checkout reduce what each machine fetches. If your CI does a full clone for every job, fix that first.

Review becomes the hard part. No group of humans reads 30,000 changes a day line by line. Anthropic built a separate review system. Your team needs a rule for which changes get careful human review and which rely on automated checks.

Adversarial review needs a referee. If you pit models against each other to find bugs, expect some of the flagged problems to be hypothetical. Anthropic’s note says people still had to push back on over-engineering.

What to watch next: whether Anthropic releases Scion or Antique publicly, whether Git hosting providers respond with features aimed at agent-heavy workloads, and whether other AI-heavy teams report similar jumps in merge volume.

What we don’t know yet

• Availability. Nothing in the summary says whether Scion or Antique will be open-sourced or offered as products.
• Cause of the jump. Willison’s link between new models and higher velocity is his guess. The summary gives no split between agent-written changes, headcount growth, and process changes.
• What counts as a change. We don’t know the typical size of a merged change, so 30,000 a day is hard to compare with other companies.
• Alternatives considered. The summary doesn’t say whether Anthropic tried Git’s partial-fetch features at scale before building its own system.
• Design details. Willison’s comparison to Subversion is his read. How Scion actually stores history and serves checkouts isn’t covered in the passages he quotes.
• Quality. There is no data on whether defect rates changed as merge volume rose.