For decades, software engineering has operated around one fundamental constraint: humans write code, and writing code takes time.
AI is rapidly eliminating that constraint. And the consequences are becoming impossible to ignore.
In a fascinating engineering post, Anthropic revealed that it had replaced Git, one of the foundational tools of modern software development, with a custom-built system called Scion.
The reason? Its AI-powered development workflow had simply outgrown Git’s architecture.
But the most important story isn’t about version control. It’s about what happens when software development moves from human speed to machine speed.
In May 2026, Anthropic was merging approximately 2,500 code changes per day. By September, that number had exceeded 30,000.
At this scale, the infrastructure designed to support human developers starts breaking down. Anthropic was performing approximately 25 million repository checkouts daily, creating enormous computational overhead.
Its solution was Scion, a centralized source control system optimized for AI agents rather than individual developers.
The reported results are striking: 100 times faster checkouts and a 200 times reduction in source-control infrastructure CPU and memory requirements.
Scion was built by a team of just seven engineers, working extensively with Claude, developed the system and supporting infrastructure in approximately five months.
When implementation becomes dramatically cheaper, a small group of experienced engineers can potentially accomplish work that previously required much larger teams.
The scarce skill shifts from writing code to designing systems, defining constraints, making architectural decisions, and evaluating what AI produces.
The best engineers may increasingly resemble technical architects supervising fleets of autonomous developers.
This could fundamentally change how startups are built and how established technology companies organize their engineering teams.
The Next Bottleneck Is Trust
Producing twelve times more code does not necessarily mean producing twelve times more value.
More code means more complexity, more dependencies, and more opportunities for failures.
Anthropic’s approach increasingly relies on automated testing and rapid correction rather than preventing every conflict before integration.
That may work exceptionally well for its environment but what happens when thousands of AI agents independently make changes that are technically valid yet collectively introduce subtle architectural problems?
Who verifies that the system remains understandable, maintainable, and secure? Who determines whether an agent’s change is actually necessary?
Generating code is becoming cheap. Verifying that code deserves to exist may become the expensive part.
The AI coding market is increasingly crowded. If thousands of agents are producing software simultaneously, the valuable infrastructure may be the systems that coordinate and govern their work.
Think automated architectural validation, semantic conflict detection, agent permissions, intelligent testing, and autonomous deployment safeguards.
It’s still an emerging market, and Anthropic’s unusual scale doesn’t automatically translate into demand from typical enterprises.
For years, we measured engineering productivity through output: commits, pull requests, features delivered.
In an AI-native world, those metrics become increasingly inadequate. A company producing 50,000 changes per day isn’t necessarily more innovative than one producing 5,000.
The winners will be organizations that translate abundant machine-generated implementation into reliable products, simpler architectures, and actual customer value. The next revolution is code governance.
