TL;DR: Git doesn’t break at 30,000 merges a day; outdated techniques do. GHS (Git-at-High-Speed) answers AI-driven load with AI itself, using adaptive techniques to keep repositories performing at their best. Aided by GHS, standard Git sustained 240,000 commits in 18 hours on a live production repository: eight times Anthropic’s daily figure, in three-quarters of the time. And Git itself keeps pushing the envelope, with pluggable storage backends pioneered in JGit and now coming to CGit.
First, credit where it’s due: Anthropic’s claim that they built Scion, their custom server-side version control engine, together with Antique, their code review tool – and, I imagine, a nod to Critique, Google’s code review tool – and migrated their entire monorepo onto them in five months—with a team of seven is a remarkable engineering achievement, and a sign of the exciting times we are living in.
However, the headlining justification for the move caught the attention of systems engineers everywhere: Git simply couldn’t handle 30,000 merges per day. For a team like ours, who has been in the trenches scaling the biggest Git installations in the world for over a decade, something didn’t sound right, we know for a fact that our customers go well beyond such numbers, so we had to take a closer look.
At first glance, 30,000 merges in a 24-hour window sounds staggering. It translates to roughly 0.35 merges per second, non-stop, day and night. To anyone outside the source-control world, that feels like an insurmountable wall. Yet large enterprises have been operating at these volumes for quite some time: busy repositories with thousands of engineers and fleets of CI bots have been pushing Git servers this hard for years.
What has changed is who gets there. In the era of AI-driven software development—where tools like Claude Code and autonomous agents generate, test, and commit hundreds of granular changes per minute—30,000 write operations a day is no longer reserved for the largest engineering organisations. Even much smaller companies can now hit these numbers, and they are quickly becoming the new baseline for machine-driven codebases.
The real question isn’t whether 30,000 merges a day is a massive workload. The question is: Is this an architectural failure of the Git data model, or is it an infrastructure and scheduling bottleneck?
History—and modern high-speed Git server architecture—suggests it’s the latter.
A History of Scaling Version Control
Before concluding that Git requires a ground-up replacement at high write frequencies, it helps to look at how tech giants have handled massive version control throughput over the last decade:
Microsoft & Windows Mono-Repo: Microsoft scaled Git to hold the world’s largest single code repository (the Windows codebase: 3.5M files, 300GB+ object database). Through VFS for Git (now Scalar), they proved that Git’s client-side bottlenecks—like tracking working directory status across millions of files—could be virtualized without altering the underlying Git Directed Acyclic Graph (DAG).
Google & Meta: Google built Piper, paired with its Critique code review tool—much like Anthropic paired Scion with Antique—while Meta developed Sapling/Mononoke. Both chose custom backends to tackle monorepo scale (billions of files, thousands of engineers checking out subsets of the tree), the same problem Scion sets out to solve.
High-Frequency Bot Pipelines: Large enterprises have long run CI/CD systems that execute tens of thousands of automated merges, rebases, and bot-driven integration events every day. We have proven that installations built on Gerrit Code Review and Zuul can far exceed these numbers, easily reaching in the hundreds of thousands operations per day.
30,000 merges a day is not uncharted territory. So why did Git break for Anthropic?
To understand why standard Git server installations fail under heavy agent-driven workloads, you have to look at what happens under the hood when thousands of concurrent merges hit a central repository.
As mentioned in our GHS performance analysis, every push or fetch makes Git walk the commit graph to count the objects it needs (Counting) and scan existing packfiles for objects it can reuse (Search-For-Reuse, or SFR). As continuous merges pile up packfiles and loose objects, both phases slow down. When uncoordinated git gc runs finally kick in to clean up, they compete with incoming traffic for CPU, I/O, and locks, until the server’s thread pool is exhausted.
The Saw-Tooth Latency Trap
In default Git server configurations, every push lands as a new packfile or a batch of loose objects, so high-frequency writes quickly generate thousands of them. To keep read operations fast, Git relies on periodic Garbage Collection (git gc) to combine packfiles, generate commit-graph indexes, and recompute reachability bitmaps. The catch is that the cost of gc grows with the size of the repository, not with the size of the latest change: the bigger and busier the repository, the more expensive each run becomes, and the less time is left between runs to serve users.
Under continuous load
Packfile Fragmentation: As thousands of small merges land, object lookup degrades because Git must scan across hundreds of un-indexed packfiles.
Search-For-Reuse (SFR) Inflation: During fetch/pack creation, Git spends exponential CPU cycles searching for existing deltas across fragmented storage.
The GC Spike: When git gc finally triggers, it consumes massive I/O and CPU, locking refs and causing severe latency spikes for incoming writes.
This creates a saw-tooth performance curve: write latency is low initially, spikes catastrophically during maintenance, and eventually leads to thread pool exhaustion and timeout cascades.
Progress has certainly been made over the years: incremental and geometric repacking, multi-pack indexes, multi-pack bitmaps, all reduce how much work each maintenance cycle has to do. But the problem is far from solved, as the recent GitHub outages highlight.
GHS: Optimizing Git Instead of Replacing It
Rather than throwing away twenty years of developer ecosystem compatibility, we can fix how Git repositories are maintained at scale.
This is precisely what we set out to prove with GHS (Git-at-High-Speed). In our
performance analysis on GitEnterprise, we showed how a new, adaptive approach to repository maintenance can help Git sustain the load generated by write-heavy, agent-driven workloads. And this is not just a lab result: on a huge production repository, on a live system, the very same Git SCM, aided by GHS sustained 240,000 commits in 18 hours while also serving a proportional amount of clones and fetches.
How GHS Eliminates the Bottleneck
Adaptive Maintenance: Instead of waiting for loose objects to accumulate and running a heavy global git gc, GHS uses adaptive AI techniques to ensure the repository always performs at its best.
Stable Latency Under Pressure: In 12-hour stress tests with 210 concurrent clients mixing developer pushes, CI clones, and CI fetches, Counting and SFR times under GHS stayed mostly below 500 ms, hovering in the 5–50 ms range for long stretches. Under the same workload, a repository with no maintenance, or with git gc scheduled every 15 minutes, climbed to hundreds and even thousands of seconds.
When you eliminate maintenance spikes, Git is fully capable of ingesting high-frequency commits without degrading performance or locking branches.
The Hidden Cost of Abandoning Git
Building a custom proprietary filesystem like Scion solves an immediate internal pain point, but it introduces major long-term engineering trade-offs:
Ecosystem Isolation: Discarding Git means losing native integration with thousands of mature developer tools—IDE integrations, diff/merge algorithms, static analysis engines, security scanners, and CI/CD runners.
Developer Friction: Engineers working with custom filesystems must learn non-standard workflows and CLI primitives, increasing onboarding friction and cognitive load.
Infrastructure Lock-In: A custom version control system becomes a massive maintenance burden for internal platform teams, who must now maintain custom backends, replication protocols, and backup systems indefinitely.
Conclusion: Pragmatism in the Age of AI Coders
As AI agents continue to generate code at machine speed, software infrastructure
will undoubtedly face unprecedented stress. But rushing to replace a foundational
tool like Git often treats a solvable performance problem as if Git itself were the wrong design.
That doesn’t mean Git is finished evolving. JGit started down the path of
pluggable storage backends about ten years ago, with an implementation on top of
Cassandra that was definitely ahead of its time, and that Luca Milanesio will
revisit at the upcoming Gerrit User Summit, so stay tuned. CGit is moving in this direction too: Patrick Steinhardt walked through the upstream effort to make Git’s storage layer pluggable in his Git Merge talk, Rebuilding Git. These backends evolve Git from within, keeping its protocol, tooling, and ecosystem intact.
With intelligent scheduling, modern storage layouts, and proactive maintenance
engines like GHS, Git can easily scale to handle the demands of automated agent
workflows—all while preserving the open, interoperable ecosystem that software
development relies on.
















