The Future of Version Control in the Age of AI Agents
Scott Shacone, co-founder of GitHub and CEO of GitButler, discusses how AI agents are transforming software development workflows. He explores the need for a new generation of version control tools optimized for both humans and machines, and the shift toward a communication-centric approach to engineering.
The Evolution of Version Control for the AI Era
For two decades, the core tools of version control—specifically Git—have remained remarkably static. While the underlying data storage and transfer protocols are robust, the user interface (the "porcelain") has not evolved to meet the needs of modern developers, let alone the new persona entering the codebase: AI Agents.
The Machine Persona
Software development is entering a "Cambrian explosion" of workflows. AI agents are now the fastest-growing users of command line tools, but they struggle with legacy Git interfaces. They run status after every command and struggle with interactive rebasing. To unlock the full potential of agentic coding, tools must provide flexible, machine-readable outputs (like JSON or Markdown) and specialized interfaces that remove the friction of traditional Git.
Redefining the Developer's "Superpower"
As implementation details become cheaper due to AI, the value proposition of a software engineer is shifting. The technical ability to write a line of code is becoming less critical than the ability to communicate, describe, and specify exactly what needs to be built. The next "superpower" for developers will be the ability to write high-quality specifications and manage the "why" rather than the "how."
Toward a New Collaboration Model
Traditional branch-based reviews and Pull Requests (PRs) are often superficial and full of "commit slop." There is a significant opportunity to move toward patch-based, local reviews where agents can augment the process by running code and validating changes before a human ever sees them. Furthermore, by utilizing parallel branches and shared working directories, multiple agents can collaborate in real-time without the overhead of traditional merge conflicts.
Conclusion: The shift from human-centric to agent-centric tooling is not just about efficiency—it is a fundamental rethink of how software is conceptualized and delivered. The winners in this space will be those who can bridge the gap between human intent and machine execution.
Key insights
-
AI agents are now a distinct user persona with different ergonomic needs than humans. They require machine-optimized outputs and specialized flags to avoid repetitive, inefficient command loops.
Impact: Development tools will shift from purely human-centric UIs to hybrid interfaces that optimize for both humans and LLM-driven agents.
-
The core value of software engineering is shifting from 'how' to implement a feature to 'what' and 'why' to build. Communication and technical writing are becoming the primary competitive advantages for developers.
Impact: Education and hiring for engineering roles will likely pivot toward systems design, specification writing, and communication skills.
-
Traditional Git primitives, such as branches and PRs, are suboptimal for agentic workflows. Parallel branches and metadata-rich commit histories are more effective for multi-agent collaboration.
Impact: A new generation of version control systems or wrappers (like GitButler) may replace the traditional GitHub-style PR workflow.
-
Inter-team communication remains the biggest bottleneck in software development. Agents can potentially solve this by coordinating in real-time, acting as a communication layer between developers.
Impact: Reduction in development overhead and faster time-to-market by automating the coordination of overlapping code changes.
-
Code review is currently often a superficial 'cursory glance.' AI agents can transform this into a deeper, functional review by running and testing code locally before human approval.
Impact: Higher code quality and lower production bug rates as the burden of initial verification shifts to AI.
Action items
-
Invest in technical writing and specification skills. Shift focus from purely mastering language syntax to mastering the art of describing complex systems and intended outcomes.
Impact: Increases a developer's value in an AI-augmented workforce where implementation is commoditized.
-
Explore version control tools that support parallel branching or 'stacking' of changes. Move away from rigid branch-based workflows to allow for more fluid, multi-agent experimentation.
Impact: Increases development velocity and reduces the time spent resolving merge conflicts.
-
Implement 'agent-native' output formats (JSON/Markdown) in internal CLI tools to make them more scriptable and usable for LLMs.
Impact: Reduces agent 'hallucinations' and inefficiencies when agents attempt to interact with legacy command-line interfaces.
Quotes
“Software developers that would be the best producers of product in the near future are the ones who can communicate, the ones who can write, the ones who can describe. That is, I think, the next superpower.”
“The assumptions baked into Git's interface no longer hold for humans or machines.”
“The why rather than the how is it becomes I think more and more valuable as the how becomes cheaper.”