The viral version says Git died in 2026.
The real story is funnier: seven humans spent five months building a version control system so their AI could keep merging 30,000 changes a day and it works by banning the two features Git is most famous for.
A post went around this week with the energy of a tabloid that just found out your marriage is over before you did. "Git is DEAD in 2026?" Two screaming-face emojis.
Anthropic has replaced Git with its own system called Scion, the robots write too much code, Git simply couldn't keep up, pour one out for the little distributed version control system that could.
And here's the thing that ruins a perfectly good funeral: the story is basically true. Anthropic did build an in-house source control system called Scion. They did move their internal monorepo off Git.
They are, by their own numbers, merging more than 30,000 code changes a day. I read their actual engineering write-up, because somebody has to, and it's a genuinely great piece of engineering.
It's also not a eulogy for Git. It's a note from the office saying the robots need a bigger desk. Let me show you the difference, because the difference is the whole joke.
The clickbait says "Git is dead." The footnotes say "please do not try this at home."
Here's the first thing the viral version conveniently loses. Anthropic goes out of its way to say Scion is not for everyone, is built only for one absurd situation, and is not going to be released.
This is the software equivalent of a Formula 1 team explaining that yes, the car does 370 km/h, and no, you cannot drive it to Big Bazaar.
So Git isn't dead. Git is fine. Git is running on your laptop right now, serenely, the way it has for twenty years, handling your eleven commits a week without filing a complaint.
What actually happened is narrower and far more interesting: one company hit a scale so ridiculous that a core assumption of Git stopped being free, and they had to pay to make it go away.
That assumption is the one every Git tutorial sells as the feature.
The feature that became the bill
Git is decentralized. Everyone who clones the repo gets the entire repo - every file, every branch, all of history, the whole cathedral - on their own machine. In 2005 this was revolutionary and correct.
It's why your internet going out doesn't stop you from committing. It's the thing we all fled Subversion and Perforce to get.
Now put a number on "the entire repo" at Anthropic scale. Their main branch history is pushing 100 GB. A compressed working copy is over 25 GB. And they run roughly 25 million CI checkouts a day. Do the naive multiplication and you get an estimate of more than 600 petabytes of Git traffic. Daily. To check out code.
Image: 100 GB history × 25M checkouts/day = 600 PB Press enter or click to view image in full size
Sit with the comedy of that. The beautiful, democratic idea - everybody gets a full copy! - is wonderful right up until your contributors are a swarm of always-online machines that don't need a full copy, don't go on holiday, and want to clone the cathedral every eight seconds. At that point "everybody gets everything" stops being empowerment and starts being a DDoS you're running against yourself, on purpose, with a straight face.
At peak, Anthropic was babysitting several hundred Git mirrors just to survive its own enthusiasm.
The robots didn't kill Git. The robots just took the one thing we loved about Git - you always have the whole thing - and used it ten million times a day until it showed us the bill.
Scion, or: we have reinvented Perforce and we feel great about it
So what did seven engineers build over five months? Reader, they went back to the office.
Scion is centralized. The authoritative servers are backed by Google's Spanner and cloud storage. Clients keep a small bounded cache. Most CI jobs don't even hold a local copy of the repo - they just ask the server over an API, like a civilised person ordering off a menu instead of being handed the entire kitchen.
Twenty years of the industry sprinting away from centralized version control, and the most advanced AI lab on Earth looked at its robot-generated code tsunami and sprinted straight back, yelling "it's fine, it's different when WE do it."
And - annoyingly - it is different when they do it. The wheel of history is round for a reason.
But here's my favourite detail, the one I want cross-stitched on a pillow. In Scion, branches and tags are discouraged.
Read that again. They built a version control system whose official guidance is to go easy on the two features that, for most of us, ARE version control. The reasoning is airtight - branches and tags are global state every server has to agree on, and global agreement is exactly the thing that doesn't scale when you're content-addressing immutable changesets across three tiers of cache.
But stripped of the justification, the sentence is pure deadpan poetry: welcome to our new version control system, please try not to control any versions.
The rest is seriously elegant, and I mean that with no snark left over. Commits are "changesets" that store only what changed. Everything is content-addressed and immutable, so any cache or server can answer a request without phoning a friend.
Checkouts are sparse and virtualized - a job pulls only the files it actually reads. Three tiers: a daemon on every node, regional caches, authoritative servers, each reportedly landing a cache hit rate above 99%. The payoff Anthropic reports: 200× less CPU and memory than the old mirror fleet, checkouts that went from minutes to seconds, and 25% of CI capacity handed back like finding money in a coat.
The part that should make every architect a little uneasy
Here's the detail the hot-takes skip, and it's the one I can't stop poking. Claude wrote most of Scion. The AI wrote the version control system that exists because the AI writes too much code for the old version control system.
That's not a dunk. It's an ouroboros, and it's genuinely where we are: the tooling layer is now being rebuilt, in real time, by the thing that broke the tooling layer. The system's workload created the system's solution and also authored it. Somewhere in there is a snake eating its tail while filing a pull request against itself - sorry, merging a changeset, there are no pull requests, we discourage branches.
And one more quietly radical bit: they dropped the merge queue. The old model - line up, test, then merge - stopped making sense at 30,000 a day, so Scion leans on post-merge testing and rollback instead. Merge first, find out later, roll back if it screamed. Which, if you've watched how agents write code, is also precisely how the agents write code. The tool didn't just scale to the robots. It started thinking like them.
Steal this (the you-are-not-Anthropic edition)
Architect hat on. The single most expensive mistake you can make with this story is to read "Anthropic replaced Git" and feel even a flicker of FOMO. You do not have this problem. If you build Scion for your fourteen-person team and your 400 MB repo, you have not future-proofed anything; you have cosplayed a scaling crisis and billed it to your runway.
The transferable lesson isn't centralize your VCS. It's this:
Your tool's killer feature and your tool's eventual bill are the same line item, read from different distances. "Every clone is a full repo" was the pitch and the tombstone. Audit your own stack: which beloved convenience becomes a catastrophe at 100× your current volume? That's your Git-history-is-100-GB moment, waiting.
Scale doesn't just break your performance; it breaks your assumptions. Anthropic didn't need a faster Git. They needed to delete the premise that everyone holds everything. Faster is an optimization. Deleting the premise is an architecture.
When the workload changes species, the tool has to change species. Humans and agents are not the same kind of client. Most of your tools were designed for the first and are about to be flooded by the second. That is the actual headline, and it has nothing to do with Git.
So no, Git isn't dead. Git got the highest compliment our industry gives: it was pushed until the exact shape of its one big idea became visible, and the only people it broke for were the ones running a code-generation operation the size of a small nation's power grid.
The robots didn't bury Git.
They just found the edge of the map - and politely, in a five-month sprint, drew a little more of it.
I've spent about two decades building data and AI systems, long enough to have personally fled Perforce for Git and to now watch the industry's most advanced lab speedrun the return trip with a straight face. I write about AI in production: the parts that are genuinely new, and the parts that are just the wheel of history turning one more honest rotation.
If this made you want to go check how big your repo history actually is - follow me here, and clap a few times so Medium shows it to the next person about to build Scion for their to-do app.
Sources / further reading: Anthropic Engineering, "Creating in-house source control" (the primary source for Scion's architecture, the merge-volume figures, and the self-reported performance numbers). Coverage and analysis: DevOps.com, "Anthropic Builds Its Own Source Control After AI Agents Outgrow Git"; Crypto Briefing, "Anthropic replaces Git with custom source control system Scion"; AlphaSignal, "Anthropic Ditched Git and Built Scion After Claude Caused 12x Merge Surge." A note on the numbers: the 200× and 25% figures are Anthropic's own, measured against their previous Git mirror fleet - not against Git in general - and are not independently verified. The ~600 PB figure is a hypothetical estimate for naive fetching, not measured traffic. The viral "nearly 100× faster checkouts" is a rounding-up of Anthropic's actual phrasing, "minutes to seconds." And the separate "20× less memory, 4× faster" stat floating around belongs to a different ingestion-pipeline rewrite, not Scion. The practice is real and impressive; the funeral is editorial.
