Anthropic replaced Git with Scion. Here’s why AI broke Git

Almost every piece of software you use is stored in Git. It has been the standard way to track code for nearly twenty years. Last month, Anthropic, the company behind Claude, said it had stopped using Git for its main codebase.

The reason is simple: AI now writes so much of Anthropic’s code that Git couldn’t keep up. So it built its own system, called Scion.

This article explains what Scion is, why Git struggled, and what it means for the rest of us. No coding knowledge needed.

What Anthropic built

On 13 October 2026, Anthropic’s engineering team published Redesigning source control. It describes two new internal tools:

• Scion, a source control system. It stores every version of Anthropic’s code and records who changed what, and when. That is the job Git used to do.
• Antique, a code review tool. It is where changes get checked and approved before they go in.

A team of seven people built both, plus about half a dozen related systems, and moved the whole company over in five months. Anthropic’s main codebase now runs on Scion.

Git in one minute

If you’ve never used Git, here is the idea. Imagine a shared notebook that a whole team writes in. Git does three things:

1. It saves every version. Each saved change is called a commit. You can always go back.
2. It gives everyone their own full copy. When you “clone” a project, you download the entire notebook, including all its history.
3. It combines work. When two people change things at the same time, Git “merges” their work into one version.

Point 2 is Git’s great strength. Linus Torvalds designed it in 2005 so developers could work anywhere, even on a plane, and sync later. Each copy is complete and independent.

That same strength is what broke at Anthropic.

Why AI broke Git

Git assumes a handful of people making a handful of changes. Anthropic’s situation looks very different now:

Most of those changes come from AI agents and automated jobs, not people typing. And every one of them needs a copy of the code to work on. Here’s what Anthropic says it was dealing with:

• The main codebase’s history is almost 100 GB. A compressed working copy is over 25 GB.
• Its testing systems alone check out the code about 25 million times a day. That doesn’t count developer machines, agent sandboxes or research jobs.
• If each of those checkouts downloaded everything the normal Git way, Anthropic estimates it would add up to over 600 petabytes a day. That’s a what-if figure, not traffic it actually ran, but it shows why the normal way was never an option.

To cope, Anthropic stacked up workarounds: partial copies, copies with only the latest history, pre-made snapshots of the code, and at its peak several hundred internal Git mirrors, which are servers that keep copies so the main one isn’t overwhelmed.

Each workaround caused new problems. Snapshots fell behind the latest code. Tools like “who changed this line?” got harder to keep working on partial copies. And once the codebase outgrew the mirrors’ disks and memory, the mirrors stopped scaling too.

Anthropic sums up the real mismatch in one line: it was using Git “as a centralized system with one authoritative copy, but nearly all of our clients were agents and jobs that are online by definition.” Git is built for working offline. Agents never are.

How Scion works

A library analogy helps. Git is like giving every reader a photocopy of the entire library before they can read one page. Scion is like a library card: you borrow the pages you need, and if you want to know something about the whole collection, you ask the librarian.

Anthropic’s post lists the ideas behind it. In plain terms:

1. Machines are always online. So they don’t need a full copy. They fetch files when they need them.
2. The server does the hard work. It answers questions about history, creates commits and performs merges. Each machine keeps only a small, limited cache and “can compute very little on its own”.
3. Many jobs need no copy at all. Questions like “which change broke this?” can be answered through an API, without checking out any code.
4. Everything grows by adding servers. There is no single full copy of the code anywhere, not even on one server.
5. Saving changes is cheap and never waits in line. Commits and merges happen on the server without locking anything, so thousands can happen at once. There is nothing to “push”.
6. Your local folder is optional. Machines only get the folders they ask for, and files can even appear only when opened.

Data moves through three layers, each with its own job:

• scion-daemon runs on each machine and shares one store of files between every job on it.
• scion-cache servers sit in each region, close to the machines.
• scion-server is the source of truth, backed by Google’s Spanner database and cloud storage.

Every file is stored under a fingerprint of its contents, so a stored file never changes. That means any cache can safely answer without checking with anyone else.

Two smaller design choices matter too. Git ships data in large bundled files called packfiles, which need regular clean-up. Scion has no packfiles, so “no repository maintenance is needed”. And Scion discourages branches other than the main line and release branches, because every extra branch is shared state that all servers must agree on.

None of these ideas are brand new. Google’s Piper and Meta’s Sapling solved similar problems for huge human teams, and Anthropic says Scion’s server borrows from Sapling’s server, Mononoke. What’s new is the reason: not tens of thousands of engineers, but swarms of agents.

Git vs Scion, side by side

So Scion is not “Git but faster”. It gives up things Git is good at, like working offline and lightweight branches, in exchange for handling a flood of changes from machines that are always connected.

What it changed

• Scion needs 200× less CPU and memory than the Git mirror fleet it replaced.
• Each of the three layers answers over 99% of requests from its cache.
• Testing and research jobs check out code “two orders of magnitude faster”: seconds instead of minutes.
• Faster checkouts alone freed about 25% of the computing power used for automated testing.

One honest trade-off: with so many changes landing at once, Anthropic dropped the strict one-at-a-time queue for merging. Changes can now clash with each other. Anthropic relies on more testing after merging, and says Claude “can typically fix these conflicts faster than humans can even identify them.”

Claude helped build it

There’s a neat loop here. AI created the problem, and AI helped solve it. Anthropic started Scion around the time Claude Mythos Preview became available internally, and says that both increased the need for Scion and sped up building it.

• Claude wrote simulations of every non-trivial interaction with the system, so changes could be tested safely.
• A Claude rewrite of one data pipeline used 20× less memory and ran 4× faster.
• Each major component had its own “superfan”: a Claude instance with access to that component’s logs and telemetry, watching it.

The engineers’ job changed too. They now review the intent of a change rather than reading every line, and very often their role “was to tell Claude ‘no’” when it broke a design rule or added needless complexity. The team says it would now rate Claude as better at writing code than they are, and spends its own time on design and trade-offs.

Can you use Scion?

No, and Anthropic is clear about it. Its post says: “Scion is by no means a suitable replacement for git for general use.” The reasons:

• It only makes sense for “truly enormous monorepos, with either tens of thousands of engineers or swarms of agents”.
• It depends on Anthropic’s own code review, code search and testing systems.
• Building a public version “that tries to please everyone” wouldn’t be very useful, Anthropic says, so Scion is not being open sourced.

Instead, Anthropic is publishing the ideas and says it hopes to work with GitHub, GitLab and the open-source community to bring the most useful parts to Git itself, such as doing more work on the server.

What this means for everyone else

If you run a normal team, keep using Git. It isn’t going anywhere. But Scion is an early warning sign worth paying attention to.

Anthropic predicts that this kind of problem “will become more commonplace over the next six to 12 months”. As more companies hand coding to AI agents, the number of changes grows far faster than headcount. Tools designed around human speed start to strain, and version control is one of the first.

What I’d expect to see, based on Anthropic’s own suggestions:

1. Git hosts doing more on the server. GitHub and GitLab answering history questions and doing merges for you, rather than every agent downloading everything.
2. Smarter partial downloads. Fetching just the files a task needs, in small resumable pieces.
3. New review habits. When machines write 30,000 changes a day, people can’t read every line. Review shifts to checking intent and setting rules.

Git solved the problem of people collaborating. The next problem is people supervising machines that collaborate. Scion is one of the first serious answers to it.

Frequently asked questions

Sources

1. Anthropic Engineering (2026). Redesigning source control. Published 13 October 2026, updated 15 October 2026.
2. Hosbach, W. (2026). Scion: Anthropic’s lean Git alternative for agentic workflows. heise online, 15 October 2026.
3. GIGAZINE (2026). Anthropic has developed and internally migrated to Scion, a Git alternative version control system. 14 October 2026.
4. Meta. Sapling: a scalable, user-friendly source control system.