Anthropic Just Ditched Git (Claude Broke It)

Author: Hyperautomation Labs · Watch on YouTube

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: Anthropic Just Ditched Git (Claude Broke It) · Channel: Hyperautomation Labs · 08:46 · Watch on YouTube

Topics: AI agents, Task and workflow automation, Claude Code, Software engineering with AI

Summary

Anthropic’s rapid increase in AI-generated code overwhelmed Git workflows built around complete local copies, prompting seven engineers to create Scion, a server-centered source-control system. The video explains Scion’s design, its caching layers, and the reported improvements in speed and computing efficiency. It draws five lessons for teams using AI: optimize the whole development loop, review for intent and system rules, invest in tests, use focused AI agents to monitor systems, and reconsider processes designed for human-speed work. Anthropic says Scion is not intended as a general Git replacement; the broader message is that as code becomes cheaper to produce, engineering judgment becomes more important.

Key points

Anthropic’s daily code changes rose from about 2,500 in May to 30,401 on September 9, with AI coding agents contributing to the increase.
Its large monorepo and frequent checkouts made Git’s full-copy model costly for online agents and test jobs.
Scion moves source-control operations to a server, while client machines keep a small cache and fetch files or diffs as needed.
Three cache layers reportedly answer more than 99% of requests at each layer, reducing load on the top-level server.
The video reports that code-status checks fell from almost four seconds to 19 milliseconds, and agent workspace setup from seven minutes to five seconds.
Seven engineers built Scion, the code review tool Antique, and other systems, then moved the company over in five months as code volume grew tenfold.
Anthropic’s team uses Claude for code but still reviews changes, focusing on intent, system rules, and whether proposed fixes address real problems.
The team emphasizes testing, including simulations and fuzzing, and uses specialized Claude agents called “super fans” to monitor system areas.
Anthropic says Scion is not a Git replacement for normal teams and is not being released; it hopes GitHub, GitLab, and Git may adopt useful ideas.

Chapters

Start	Chapter	Summary
00:00	Why Git became a bottleneck	Anthropic’s surge in AI-generated code exposed the limits of Git’s full-copy model for its large repository and constant agent checkouts.
02:34	How Scion works	Scion shifts source-control work to servers, fetches only needed data, and uses layered caches to improve performance.
04:06	Building Scion and learning from Claude	Seven engineers built and deployed Scion and related tools, while Claude helped rewrite a history-migration pipeline more efficiently.
05:09	Five lessons for AI-assisted engineering	The video recommends optimizing the whole work loop, reviewing AI output carefully, expanding tests, assigning focused AI monitors, and questioning human-speed processes.
07:45	What Scion means for other teams	Anthropic says Scion is not for general release, while the video argues that engineering judgment matters more as code becomes cheaper to produce.

Quotes

In Git, your machine does the work. In Scion, the server does. — 02:34

Claude writes code better than they do. — 05:41

Does this break a rule of my system? And is this fixing a problem I actually have? — 06:12

Code is getting cheap. Judgment isn’t. — 08:15

Concepts and entities

Anthropic, Claude, Claude Mythos, Git, Scion, Antique, GitHub, GitLab, Subversion, mono repo

Full transcript (original language)

00:00 In May, Anthropic merged about 2,500 code changes a day. On September 9th, they merged 30,401 in one day. And what pushed it that high? Claude writing code. And the thing that broke wasn’t the AI, it was Git, the tool almost every developer on Earth uses. So, seven engineers did something almost nobody does. They replaced it in 5 months. I’ll show you exactly how and the five lessons from it that change how

00:31 you should work with AI starting this week. Here’s why this matters even if you’ll never work there. Anthropic uses Claude to write code more than almost any company on Earth. So, they hit the walls first. And in this post, they say the same problem will reach a lot more companies in the next 6 to 12 months. So, think of this as a look at your own future. Before we go on, five words you’ll hear. A commit is one saved change to the code. A merge is when that change joins the main version everyone uses. A repo, short for repository, is the folder that

01:02 holds all the code and its whole history. A mono repo is one giant repo for the entire company. And a checkout is when a machine downloads that code so it can work on it. That’s it. You’re ready. Here’s what they were up against. One giant repository holding almost all their code. The history of the main branch alone is almost 100 GB. Even a compressed copy of the code is over 25 GB. And their test machines check that code out around 25 million times a day.

01:33 If every one of those downloaded it the normal way, that’s over 600 PB of traffic every single day. To see why Git broke, you need one idea. Git was built so every copy is complete. Your laptop holds the whole history so you can keep working on a plane with no internet. For people, that’s brilliant. But Anthropic’s coders aren’t on planes. They’re agents and test jobs running in data centers. They are online by definition. So, every one of them was hauling around a full copy it didn’t

02:04 need. They tried every standard fix. Shallow clones, partial checkouts, snapshots of the repo kept in cloud storage. At the peak, they were running several hundred extra Git servers called mirrors just to keep up. It bought them time, but the snapshots kept falling behind and the mirrors outgrew their own disks and memory. So, they stepped back and asked one question. If you designed source control from scratch, knowing your users are always online, what would it look like?

02:34 Their answer is called Scion. Here’s the whole idea in plain English. In Git, your machine does the work. In Scion, the server does. Who changed this line? Ask the server. What’s different between these two versions? Ask the server. Even a commit happens on the server, so there’s nothing to push. Your machine keeps a small cache and it only downloads the files it actually opens. And because it’s all one big service, a lot of jobs never download the code at all. A test that needs one diff just

03:05 asks for that diff. Their automatic tools that find which change broke something and undo it only work at this scale because asking the server is that cheap. Under the hood, every change is a small record. Who made it? When? And only the files that changed with pointers to where their contents live. Now, look at the author on Anthropic’s own example, Claude. The heavy stuff, like the full history of a file, gets worked out by the server later and only if someone asks for it.

03:36 Then they stacked three layers of caches, one on every machine, one in every region, and the real server at the top. Each layer answers more than 99% of requests on its own, so the server at the top barely gets bothered. And the results are honestly ridiculous. Checking the status of your code went from almost 4 seconds to 19 milliseconds, 207 times faster. Setting up a fresh workspace for an agent went from 7 minutes to 5 seconds. Add it all

04:06 up and each agent change spends under 4 minutes on source control instead of 34. That’s about 11,000 agent hours saved every day. And the whole system runs on 200 times less computing power than the old Git mirrors. Now, here’s the part that surprised me most. How many people built this? Seven. Seven engineers built Scion, a new code review tool called Antique, and half a dozen other systems. Then, they moved the whole company over in 5 months while the amount of code coming in grew 10 times. Not long ago, a project like this

04:37 took a big company years and a lot more engineers. And this is the moment that tells you where things are going. Early in the year, the team wrote the first version of one key piece by hand, the pipeline that copies Git history into Scion. They thought it was good. Then, they got an early internal version of Claude Mythos. They asked it to rewrite the whole thing with no other instructions. It came back using 20 times less memory and running four times faster. And it kept every hidden rule the old code depended on.

05:09 So, what do you actually take from this? Five lessons. And every one of them works on a small project, too. Lesson one, writing the code is no longer the slow part. Anthropic says it straight. The bottleneck is now everything built for human speed, source control, builds, testing. So, if Claude writes your feature in 2 minutes and then you wait 20 minutes for tests and a day for review, that’s where your next big win is. Time the whole loop, not just the typing. Lesson two, this is the big one. Every engineer on this team now says, “Claude

05:41 writes code better than they do.” Read that again. So, what’s their job? In Anthropic’s words, very often, it was to tell Claude no. Two kinds of no. One, Claude would sometimes break a basic rule of the system just to make something work, like reading through the entire commit log to find when a change landed instead of asking the review tool. Two, when Claude reviews Claude, it can get paranoid about problems that don’t exist and pile on extra checks nobody needs. So, they still review every change, but they read it for the

06:12 intent, not line by line. Before you accept anything from Claude, ask two questions. Does this break a rule of my system? And is this fixing a problem I actually have? Quick one. Most of you watching haven’t subscribed yet. It’s free and it’s how this channel keeps making videos like this. Okay, lesson three. Lesson three, spend the time you save on tests. Because Claude writes code so fast, Anthropic says Sci-on is one of the best tested code bases they’ve ever worked on. Built on a tight deadline,

06:43 full simulations, fuzzing, rate limiting. And that’s what makes the Midas trick safe. Once you have tests that lock in how your code behaves today, you can ask the best model to rewrite the whole thing and the test tell you if it kept the rules. Lesson four, my favorite. Anthropic gave every part of the system its own Claude in its own Slack channel whose only job is to obsess over that one part. They call them super fans. There’s a cache super fan, a merge queue super fan, and

07:13 more. They read the charts and logs like an experienced engineer with nothing better to do and they catch weird problems that normal alerts miss. You can copy this today. One Claude, one thing to watch, your logs, and a daily note of anything strange with Claude in Slack or a scheduled Claude task. Lesson five, question every rule that only exists because humans are slow. A normal merge queue lets changes in one at a time so nothing clashes. At 30,000 changes a day, that just jams. So, Anthropic doesn’t use a global lock.

07:45 Changes merge and the testing happens after the merge and before anything ships. Yes, changes sometimes clash, but Claude usually fixes the clash faster than a person could even notice it. So, look at your own process. Which steps are there only because people used to be the slow part? Now, not everyone loved this. On Hacker News, it pulled over 600 comments. One person asked, “Did they just reinvent Subversion?” Another asked what you might be thinking. Honest question, “What do people at Anthropic even do

08:15 now?” Fair questions. And to be clear, Anthropic agrees Scion isn’t for you. They say it’s not a Git replacement for normal teams and they’re not releasing it. What they want is for GitHub, GitLab, and Git itself to borrow the best ideas. And that second question is the whole story. What did those seven people do? They didn’t type most of the code. They decided what to build, how big it had to scale, and when Claude was wrong. That’s the job now. Code is getting cheap. Judgment isn’t. I put all five lessons into one free

08:46 PDF, the Agent Scale Playbook. The two question review card, a copy and paste super fan prompt you can set up today, and four Git settings that make big repos faster right now. Comment Scion and I’ll send it to you. And if you’re new to Claude code, my beginner guides are linked below. See you in the next one.