AI + a16z Podcast
Episode: Rethinking Git for the Age of Coding Agents with GitHub Cofounder Scott Chacon
Date: April 8, 2026
Host: Matt Bornstein, a16z
Guest: Scott Chacon, Cofounder of GitHub & CEO of GitButler
Episode Overview
This episode delves into how software development — and the tooling that underpins it — is being transformed by the rise of AI coding agents. Host Matt Bornstein speaks with Scott Chacon about how Git, originally intended as a set of core Unix plumbing commands, is struggling to adapt to new users: AI coding agents. Chacon explains why modern workflows demand a total rethink of the developer experience, discusses the evolution (and stagnation) of Git and GitHub, and unpacks the technical and social challenges of collaborative, agent-driven coding. Throughout the conversation, Chacon reveals insights from his journey building GitHub, the motivations behind his new startup GitButler, and predictions for the future of code, collaboration, and communication.
Key Topics & Discussion Points
1. The Origins and Evolution of Git
- Git’s Unix Philosophy - Designed as plumbing, not for general users:
“The most widely used developer tool in the world was never designed. Git started as plumbing commands for the Linux kernel team… Unix primitives meant to be wrapped in whatever scripts each developer preferred.” (Host, 00:47)
- UI Limitations and a "Frankenstein" Design
"It's not designed right. It doesn't have sort of overall sort of an arc of taste." (Chacon, 04:37)
- No original intention for a user interface (06:31–07:46)
2. The Human vs. Machine Interface Problem
- Backward Compatibility and Stagnation
"They always wanted to be backwards compatible… there's almost nothing in [the Pro Git] book that doesn't work still." (Chacon, 09:16)
- One Interface to Serve Two Masters
"They kind of need to solve both of these problems with one interface, which is I need a computer to be able to do this and I also want a human to be able to... interpret this. And so how do we bridge that gap?" (Chacon, 10:04)
- CLI, GUI, and TUI for Different Personas
- GitButler started as a GUI, then added a CLI and TUI to optimize for humans, agents, and mixed workflows (11:20–15:13)
3. Coding Agents as New Platform Users
- Agents as the "New Persona"
"Coding agents are the fastest growing users of command line tools, an entirely new Persona..." (Host, 00:47)
- Chacon discusses user-centric design for agents vs. humans (14:13–15:42)
- Unexpected Agent Preferences
"We thought [agents] would love JSON and it doesn't like JSON that much..." (Chacon, 15:26)
- Output Schema Optimization
- Considering special CLI flags and output modes (e.g.,
--markdown) for agent workflows (14:13–16:41)
- Considering special CLI flags and output modes (e.g.,
4. Parallel Branches and Multi-Agent Collaboration
- GitButler’s Approach: Beyond Worktrees
“A lot of people are using kind of work trees now to do a lot of stuff in parallel so the agents don’t step on each other… But we built stuff on top of that where we essentially have like a hidden mega merge type thing.” (Chacon, 18:20)
- Agents can see and react to each other’s changes in real time, reducing merge conflicts (20:43–22:30)
- Agent Communication Experiments
“...we even experimented with having like a communication between agents. So we have agents running at one time, give them a little chat channel and they can talk to each other about what they’re doing...We were all devastated. It does not help.” (Chacon, 18:51)
- Agents self-optimize and coordinate implicitly, so explicit chat overhead is not beneficial (19:54–20:19)
5. The Future (or Replacement) of GitHub
- GitHub’s Advantage—and Risk
"It's a rocket, it's a behemoth, right? … [but] can they pivot fast enough to keep up?" (Chacon, 23:36)
- Next “GitHub” may arise from someone reimagining the problem, analogous to GitHub's leap beyond Sourceforge (25:19–26:40)
- Evolution of Primitives
- Chacon criticizes branch-based review (i.e., PRs), points out lack of code archeology, and suggests a need for new collaboration mechanisms possibly centered on patches and local review (26:58–30:29)
6. Changing Nature of Code Review and Collaboration
- Code Review: Humans Do Less, Agents Do More
“If you ask … when you do code review, do you really read the whole PR? … Agents are very good at that, right? … That is not a problem that agents have.” (Chacon, 00:00, 27:51)
- Proposes “patch-based” review over branch-based, empowering more automated or agent-augmented workflows (27:31–30:29)
- Communication as the “Next Superpower”
“Software developers that will 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.” (Chacon, 00:37, 32:40)
7. The Rising Importance of Specification and Metadata
- Shifting Value: From Coding to Writing and Spec
"The constraint moves not to can I produce the code, but can we agree on what we want?" (Chacon, 35:21)
- Appended Metadata & Transcripts
- Discusses efforts to attach specifications and context to code changes, creating new data challenges and focusing engineering insight at the “metadata layer” (39:31–41:23)
8. The Endgame: What Happens as Agents Approach Perfection?
- Limits and Logical Endpoints
- Chacon likens perfect agent coders to “the best engineer you’ve ever known that can stop time and work on something as long as they want and then start time again” (43:35–45:21)
- Raises the challenge of leveraging superhuman code output: “What do we want to do with that?” (45:21)
Notable Quotes & Memorable Moments
-
On Git’s Stagnation
"When I to go look for something else to do ... I started building some stuff and realized that the tooling for Git hasn't changed since I left... I was approached by a press to write a third edition of the [Pro Git] book and I was like, why? ... It hasn't. It's exactly the same."
— Scott Chacon (03:03) -
On Agentic Code Review
"If you ask almost any software developer, when you do code review, do you really read the whole PR?... Agents are very good at that, right? If something goes wrong, that's very human. It's actually a thing that has never been good in software development is inter team communication. ... That is not a problem that agents have."
— Scott Chacon (00:00) -
On “Next Gen” Developers
"Software developers that will 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... the next superpower."
— Scott Chacon (00:37, 32:40) -
On PRs and Code Archeology
"PR's made things really easy, but you get a lot of commit slop... The commit message doesn't make any... like nobody really looks at them... Now it's the PR description, which was not kept in git."
— Scott Chacon (26:58–27:51) -
On Collaboration Problems
"There's never been good in software development is inter team communication... if we could talk to each other in more real time about what we're doing, that's a lot of overhead. That is not a problem that agents have."
— Scott Chacon (37:28) -
On the Nature of the Next Big Tool
"Whatever is the next GitHub is going to be the same problem set. Right. It's not going to look like GitHub."
— Scott Chacon (25:19) -
On the Value of Writing Specs vs. Code
"I'm spending most of my time like testing it, right. And writing up the next thing. And not that much... Like there's a lot of wasted cycles, right."
— Scott Chacon (34:07) -
On Big Data and Metadata
"You would be surprised. It's all text, but you'd be surprised how quickly that balloons. Right. If you're really trying to keep every transcript or even every ... tool call..."
— Scott Chacon (39:49)
Timestamps for Major Segments
- 00:00–02:26 | Intro & Scott’s Motivation for Re-entering Version Control
- 04:10–06:03 | Relationship between Git core and GitHub; Git’s design priorities
- 06:03–09:16 | The shift from UNIX plumbing to the modern UI, "Frankenstein" problem
- 11:20–14:13 | GitButler’s GUI, CLI, TUI, and agent/human optimization
- 15:13–16:41 | Designing command output for agents (JSON, Markdown, hints, etc.)
- 17:10–20:19 | Parallel branches, agent coordination, and failed agent communication experiments
- 23:36–26:40 | The future of GitHub & what ‘the next GitHub’ could look like
- 26:58–30:29 | Reevaluating PRs, branch review vs. patch review, and code review realities
- 32:40–34:01 | The critical skill: communication and specification writing
- 35:12–37:14 | The importance and challenge of shared specs in an agent-enabled world
- 39:31–41:23 | Metadata explosions and big data in collaborative agent workflows
- 43:35–45:21 | What happens when agents become almost perfect?
- 45:21–End | Final reflections and sign-off
Summary Takeaways
- Git's Foundations Are Shaky in an Agentic Future: Git's design never contemplated the needs of humans (beyond kernel hackers), let alone AI agents. Its interface, focused on UNIX-like composability and backward compatibility, now limits innovation.
- Agent Personas Demand Tailored UX: AI agents interact with developer tools in unpredictable ways, requiring new output formats, symbols, and contextual clues. Chacon’s work at GitButler aims to serve agents, humans, and hybrids — each with unique needs.
- True Collaboration Is Moving Up the Stack: As code output becomes more accessible, the superpower shifts to effective specification, description, and writing. Alignment around "what to build" dominates the subtleties of "how to build."
- Old Primitives (PRs, Issues) Don’t Serve New Realities: Patch- and intent-driven workflows, agent mediation, and rich metadata will become the new organizing principles for software collaboration.
- The Next “GitHub” Will Be Fundamentally Different: Just as GitHub transformed SourceForge’s world, the next leap may come from outside the obvious players — and may revolve around empowering and choreographing swarms of intelligent agents rather than just people.
Recommended for:
Anyone curious about the intersection of developer tooling, AI, and the evolving culture of software collaboration — especially those building tools, managing engineering teams, or wrestling with how to keep up in the age of coding agents!