Anthropic Scion is INSANE

Don't pave the cow paths: Anthropic's new source control and post-labor economics00:01

In May 2026, the AI company Anthropic was merging around 2500 code changes into its monorepo every single day. By September, that number was more than 30,000 per day. That's more than 12 times as many merges in 4 months. Earlier this year, a fire hose of code was predicted, and this is what that fire hose looks like. The reason is Claude, Anthropic's own AI. Anthropic uses Claude to write software far more than almost any other company does. So, Anthropic is often the first company to hit the limits of the tools that everyone else uses.

In 2026, its biggest development bottleneck became source control. Every large piece of software is built from thousands of files, and many people change those files at the same time. Source control is the system that keeps track of all of those changes. It records who made each change and when it happened, and then it merges everyone's work into the main branch. Today, the standard tool for that job is a program called Git. Git was designed for human programmers. Every programmer keeps a full clone of the repository on their own computer, which means all of the files along with their entire history. That way, they can keep working offline. And for almost every repository in the world, that is still the right design.

But Anthropic keeps its code in a monorepo which is one giant repository that holds many projects at once. Even a compressed working copy of that monorepo is over 25 gigabytes. On top of that, Anthropic's continuous integration or CI checks out that code around 25 million times per day. If each of those checkouts were a full Git clone, that would mean moving more than 600 petabytes of data every single day. The engineers tried every workaround that Git offers, such as shallow clones and sparse checkouts. At their peak, they were running several hundred internal Git mirrors to handle the load, and even that wasn't enough.

Then they noticed something. Git assumes that every client is a person at a computer who might go offline at any moment. But at Anthropic, almost none of those clients were people anymore. They were AI agents and CI jobs, and those are always online. So the offline-first design that made Git so good for humans was now holding Anthropic back. Instead of patching Git, the engineers built their own version control system called Scion. In Scion, the heavy work happens on the server instead of on each client. The server answers every question about the repository's history and it creates the commits and performs the merges. An agent fetches only the files that it needs at the moment that it needs them. And the cost of a commit now scales with the change itself, not with the whole monorepo.

The results were huge. Scion runs on 200 times less infrastructure than the old Git mirrors did. And a checkout for CI now takes seconds instead of minutes. Now, here's the part that matters most. A team of just seven people built Scion along with the new code review tool and half a dozen other systems. They migrated the entire monorepo from Git to Scion in 5 months. And they did it while all of that growth was happening at the same time. And Claude helped them build Scion. Every engineer on that team says that Claude is better at coding than they are. Their job became understanding how all the systems fit together, making the design decisions, and very often just telling Claude no.

They changed code review, too. Instead of reading every line, reviewers now check the intent of each change, and the engineers dropped the global lock on the merge queue, so changes no longer wait their turn. Changes now merge concurrently, and more of the testing happens afterwards before anything is deployed. Sometimes two changes collide, but Claude can usually fix the merge conflict faster than a human could even spot it. Anthropic's engineers put it this way. At their company, writing code is no longer the bottleneck. Now, the bottleneck is the developer infrastructure such as source control, builds, and CI. And all of it was built for human scale originally.

There is an old saying in business, don't pave the cow paths. When a town grows up along the paths that cows wore into a field, the easy thing is to pave those paths. But the right thing is to ask where the roads should actually go. Git is one of those cow paths. It is a brilliant tool, but it was built for humans. Anthropic didn't stop at making Git faster. Instead, Anthropic's engineers asked what source control would look like if it were built for machines first. That kind of thinking is still rare. Today, even when a company redesigns its org chart from a blank sheet of paper, it still assumes that every box holds a person.

Anthropic's choice matters because of a puzzle called Solow's paradox. In 1987, the economist Robert Solow wrote, "You can see the computer age everywhere, but in the productivity statistics," companies had bought the computers, but they hadn't changed the way that they worked. The same thing happened with electricity. When factories first got electric power, most of them swapped the steam engine for one big electric motor and kept the same shafts and belts. For decades, those factories saw almost no gain in productivity. Agentic coding is at the same point today. A company can give every engineer an AI agent and turn on the fire hose. But if all the code from those agents still has to squeeze through tools and habits that were built for humans, then most of the gain is lost. If your engineers spend all day reviewing that code line by line, then you haven't removed the bottleneck. You've just moved it from typing to reading.

Companies won't see the full benefits of agentic coding until they do away with human-centric design patterns such as Git. Economists call that delay the productivity J curve. When a company adopts a new technology, it first has to spend time and money reorganizing itself around that new technology and productivity can dip. Then once the new systems are in place, productivity shoots up on a chart that looks like the letter J. Anthropic is leading the charge here. It hit these limits first and it rebuilt its source control in 5 months. Anthropic expects other companies to hit the same limits within the next 6 to 12 months.

Now, think about what this means for labor. Anthropic rebuilt its developer infrastructure to handle more than 12 times as many merges per day. And the team that did that work was just seven people. That's what this kind of innovation makes possible. A company can become 10 or even 100 times more productive at writing code with the same headcount. And that is how post-labor arrives inside a company. It doesn't arrive as mass layoffs, at least not at first. It arrives as compaction where the output keeps growing and the number of people stays flat or even shrinks. Anthropic's engineers say that they're no less valuable, but that their work is changing.

So, what do people still bring to a company like that? Four things. The first is accountability. The second is setting long-term goals. The third is relationships and trust. And the fourth is the knowhow that no one has written down yet. Although AI is already busy overcoming that particular limitation. And imagine that this pattern keeps going. Where else are humans the chief bottleneck for the speed of business and progress? Think about approvals that sit in someone's inbox for a week and meetings that are held just to pass along information. Think about contracts that pile up on a lawyer's desk and scientific papers that wait months for peer review. Every one of those processes was built around the limits of a human being, such as how fast we read and how many hours we can work. And most of that work is coordination, which means people passing information to each other and then just waiting for an answer.

That's why one of the most important rules is this. Automate the coordination before you fire the coordinators. Anthropic's move off Git is a prime example of automating coordination. And the team behind Scion says that building it made them take a very hard look at other workflows that were designed for human scale. Every company is going to have to do the same thing. That is why post-labor economics is defined as a paradigm in which human labor inputs no longer serve as a binding constraint on economic activity or throughput. In plain words, human effort stops being the bottleneck. That doesn't mean that no one works. It means that the amount of work that gets done is no longer limited by how many people you have or by how fast those people can read and type. That is exactly what Anthropic did for code at that company. Human labor is no longer the binding constraint on how much software gets built.

So don't pave the cow path. Find every process that was built around the speed of a human being and ask what it would look like if it were built for a machine instead. That is where the next 10-fold gain is going to come from.