Interesting information from Anthropic about why the company moved off Git and built its own custom source control system. From their engineering blog:

“At Anthropic, coding is no longer the bottleneck to building systems or doing research. Claude is able to autonomously iterate on research loops, micro-optimize complex programs, and build new services from the ground up at a speed and scale we haven’t seen before. The bottleneck, now, is all of the developer infrastructure built for human scale: source control, builds, and CI. In May 2026, Anthropic averaged around 2,500 code changes merged per day; as of September, we merged over 30,000 per day. We don’t expect this rate of growth to slow down anytime soon; the latent demand for merging code is practically infinite, and every bottleneck we remove immediately leads to a further increase in the amount of code we produce.”

That’s a 12x increase in PRs in a four-month period! Interestingly, just a year ago, I shared how I had gathered Google was preparing for a similar tenfold increase across its broader infrastructure. From the deepdive published in July 2025:

“Google is preparing for 10x more code to be shipped. A former Google Site Reliability Engineer (SRE) told me: ‘What I’m hearing from SRE friends is that they are preparing for 10x the lines of code making their way into production.’ If any company has data on the likely impact of AI tools, it’s Google. 10x as much code generated will likely also mean 10x more code reviews, deployments, feature flags and source control footprint.”

Back to Anthropic, a few things about the company are different from many other tech businesses:

• Use of a monorepo. Like most large tech companies, Anthropic has a massive monorepo, where the working copy itself is 25GB in size.
• 25 million git checkouts per day, just for CI! All ~3,000 staff extensively use parallel Claude agents – typically 10-15 per engineer – so a lot of pull requests are created; somewhere in the region of 30,000 per day. All these PRs trigger a massive number of checkouts, mostly from the CI system.
• Nearly all clients are always online. Git was built on the assumption that clients go offline at various times, and that when they come back up, they need to catch up with branches and merge their changes into the repo. However, when clients are always connected to the corporate internet – like at Anthropic – this assumption no longer holds. Design decisions to accommodate offline clients mean inefficient checkouts and more data transferred than necessary.
• Hard to horizontally scale git. Scaling git is done by running git mirrors: replicating git repositories across several mirror nodes. A primary git server accepts the writes, pushes out to all mirrors, and clients fetch from various mirrors. Anthropic ran hundreds of git mirrors, but found that once their repo outgrew the mirrors’ disk capacity, they could no longer scale the repo.

So, Anthropic created a new source control system, which is called ‘Scion’ internally. It’s closed source, and Anthropic has shared the high-level design principles and data structures used, but no code details. The problem with having your own source control system (and moving off Git and GitHub) is that GitHub’s code review system is lost! So, Anthropic also had to build a new code review and code management system, which they call ‘Antique.’

I reached out to the team building Scion and Antique to learn more about how Scion works. Here’s what they told me:

Technical details

The design of Scion is pretty simple: stand up “server” nodes (that contain the whole repository), store changesets inside of Google Spanner (Google’s distributed, highly available database) and blobs (large files) in the highly durable Google Cloud Storage.

I asked Nick G – one of the authors of the original blog posts – about additional details and here’s what he told me:

• Rust: the language that Scion’s server and client are written in.
• Go + React: Antique, Anthropic’s new code review and code management platform has its backend in Go and frontend written in React. It works nicely with Scion.
• More resilient replication strategy: by default, Google Spanner offers multi-zone replication with three replicas. Anthropic has increased the number of replicas and switched to multi-region replication.
• Backups: on top of replication, Anthropic keeps full backups of the database and soft deletes on the blob storage where file contents live. Spanner’s point-in-time recovery also lets Anthropic restore from a bad write.

Scaling is an interesting topic. I asked Nick if the system autoscales or scales manually. He told me:

“Every component can autoscale, but so far it hasn’t needed to, even as our merge volume grew more than 10x this year. The data is content-addressed and never changes once it’s stored, so the caching tiers do most of the work.”

A team of seven engineers builds and maintains all of this:

• Four worked on the core Scion server and client
• Three were split between building code search, merge queues, etc.

100% of Anthropic’s monorepo has moved off Git. This was no small feat to pull off! Nick gave me more details about the migration:

“The migration was not simple, but Claude was instrumental in getting it done. It’s also ‘self-healing’ in a way: if we get all the important use cases migrated and have something like 99% coverage, we can just force the cutover and Claude can help us fix anything that actually mattered. 100% of our monorepo is off of git. A few smaller repos that were never in the monorepo are migrating now, and they’re much simpler.”

Big Tech moved off Git long ago

My take is that Anthropic has “Big Tech problems” much earlier than most of Big Tech had to tackle them. Anthropic employs around 3,500 staff, but their coding output – thanks to each person using around 10 agents all the time – is closer to that of a tech company with 35,000-70,000 staff! That’s a Meta or Google-sized company by the number of engineers.

Google and Meta have long since moved off Git because it did not scale for them.

Google built its own version control that took inspiration from Perforce. Git itself was created by Linus Torvalds in 2005, seven years after Google was founded. So git was not an option for Google to use in the early years: the company chose Perforce instead. It was around 2011-2012 that Google had ran into scaling issues with Perforce and built its own source control system called ‘Piper.’ It’s also a centralized version control model and still works well enough for the search giant.

Meta found that git and other systems could not scale as needed, and so built ‘Sapling.’ Meta initially moved over to Mercurial, and then custom-built and open sourced Sapling for itself.

Did Anthropic secretly rip off Sapling’s and Mononoke server

I asked Anthropic why it doesn’t open source Scion. Nick G’s reply:

“Mostly bandwidth! Even a no-support code drop takes a lot of work to do well. We have a small team building and running Scion. While the principles we used to build it are durable, the underlying code changes very frequently. For example, we’re still removing git-compatibility layers we only needed for the migration. We’d rather put that time into sharing what we learned, and as the post says, into working with GitHub, GitLab and the OSS community on scaling git.”

The creator of Mononoke wrote a post accusing of the Anthropic team of ripping off Monoke — and the Bonsai data model — writing:

“This [Scion] was a ripoff. My post yesterday was trying to be as charitable as possible given what I knew, and in particular that the similarity to Mononoke was mostly unintentional and the lack of credit was the result of not doing due diligence. However, after publishing the post I privately received confirmation that Scion intentionally and blatantly ripped off Monoke, and in particular that there was overlap in personnel. There is no chance that this was an unintentional homage.”

Anthropic did not give credit to Monoke in their original post, and only added a small attribution after the complaint.

Will central VCs stay a niche, or expland beyond Big Tech?

Big Tech has preferred centralized version control systems (VCS), and I wonder how niche of a trend central VCSs will remain. As we’ve seen since well before AI, some of the largest tech companies dropped git because they did not like the performance degradation from offline support they no longer need.

My question is that even with agents, how many companies will see git “break” similarly to how it has at Anthropic? When this happens, how many will find git’s mirroring functionality inadequate for their own needs?

My hunch is that very few companies will go through the trouble of building yet another source control system. In this way, Anthropic reminds me a bit of Google, which has been known to build custom internal systems which are not publicly available, to address the company’s internal needs.