We Need a New GitHub

It’s easy to think of GitHub as a place to keep git repositories. Hosting git was never really the hard part, though, and I don’t think it’s what made GitHub matter. The thing that stuck was the review layer on top of the repository: the pull request. A proposed change, rendered as a diff against what’s there now, staged somewhere people can talk about it, and approved (or not) before it lands.

It didn’t start out that way. According to Daniel Smith’s history of the feature, GitHub added pull requests in February 2008 as a fairly thin layer over git’s own request-pull. It was August 2010 before GitHub announced that “pull requests are living discussions about the code you want merged.” Commenting directly on the diff came in February 2011, and the merge button followed that April. GitHub’s own documentation now calls the pull request “GitHub’s key collaboration feature, letting you discuss and review changes before merging them.”

Software engineers have had that primitive for so long that it’s mostly invisible to us, and almost nobody else has it. Now that we have models that can read and reason about nearly any kind of proposed change, I think we want the same thing for changes that aren’t merges into a code repository: a customer email, an edit to a contract, a pricing change, an update to a published policy. I’m going to call it an Approval Request. It’s a pull request generalized to any consequential action, staged and reviewed before it takes effect, and carrying its own way back if it turns out to be wrong.

Last week I wrote about replacing the pull request with a Review Request for code that agents write. This is the same instinct, pointed at everything else.

What Version Control Actually Gave Us#

If you take the code out of version control, what’s left is a fairly general machine for managing change. There’s a diff, which is a proposed state compared against the current one. There’s staging, where a set of edits gets assembled into one coherent change instead of a stream of individual keystrokes. There’s review and approval, a gate between “someone wants this” and “this is now true”. There’s an audit trail of who changed what, when, and (if the commit message is any good) why. And there’s rollback.

That’s my own framing rather than a standard definition, and people who do change management for a living would likely draw the lines differently. The piece I care most about here is the gate.

The gate only works if the review is real. Ten years ago I wrote a post on effective code review, and the point I was most emphatic about was the 1000 line pull request, touching multiple services, that gets a “lgtm :+1:” and an approval after five minutes with no substantial comments. That kind of review is arguably worse than none, because it gives everyone a false sense of security. Tooling can’t fix that on its own. What it can do is put everything a careful reviewer needs in one place: the exact change, the context it lands in, somewhere to ask questions, and a record of the decision.

Everyone Else Is Flying Without It#

Outside of software, the everyday version of change management tends to look like the opposite of a diff. A document goes out by email as report_FINAL_v2.docx, comes back as report_FINAL_v2_edits.docx, and somebody has to work out by hand which one is actually final. A shared spreadsheet belongs to whoever saved it last. Track changes is the closest thing most people have to a diff, and it’s a diff of the words in a document, not of what happens when somebody acts on it.1

There are fields with real, formal change control, and I don’t want to pretend otherwise.2 But where it exists, it tends to be heavy: documents, a board, sign-offs, and a timeline measured in weeks. That’s a reasonable design for change that happens at human pace, a few times a quarter. It isn’t interactive the way a pull request is, where you open a change, see exactly what differs, comment on the line that worries you, and get it approved and merged in the same afternoon.

Plenty of people outside of software review things. What almost none of them have is review granular, interactive, and cheap enough to use every day. Agents are going to strain both ends of that. The heavyweight processes can’t keep up with the rate of change agents produce, and the ad-hoc majority doesn’t have anything to review against in the first place.

Why Agents Make This Urgent#

Agents don’t only write things anymore. More and more, they act: they send the message, change the record, and kick off the workflow. Gartner has predicted that 33% of enterprise software applications will include agentic AI by 2028, up from less than 1% in 2024.3 You don’t have to believe that exact number to believe the direction.

The usual answer to the risk is a human in the loop, and I think it’s the right answer. Anthropic’s guidance on building effective agents says agents “can then pause for human feedback at checkpoints or when encountering blockers,” and warns that “the autonomous nature of agents means higher costs, and the potential for compounding errors.” The trouble is that a human in the loop, without a structured thing to review, is a person approving a stream of actions they can’t really see. That’s the “lgtm :+1:” problem again, at a much higher rate, in places that have never had a diff.

We’ve already seen what the unreviewed version looks like. In March, TechCrunch reported, relaying The Information, that an agent at Meta “ended up posting a response without asking the engineer for permission to share it.” Another employee then acted on the agent’s advice, which, according to the report, “inadvertently made massive amounts of company and user-related data available to engineers, who were not authorized to access it, for two hours.” Meta deemed the incident a “Sev 1.” Writing about it afterwards, agno put the problem about as plainly as it can be put: “The problem was that what it did could not be undone.”

I’ve also argued before that any control an agent can reach is not a control. An approval gate is a control, so it has to live outside the agent, as something the agent submits into rather than something it gets to configure.

The Labs Are Already Rebuilding It#

Even inside software, where we do have the pull request, the shape is starting to give. Companies producing agent-written code at scale are already rebuilding source control and review around it, and new open-source backends are appearing alongside them.

Last month Anthropic published how it redesigned source control. The headline number is the volume: “In May 2026, Anthropic averaged around 2,500 code changes merged per day; as of September, we merged over 30,000 per day.” Their conclusion was that “the bottleneck, now, is all of the developer infrastructure built for human scale: source control, builds, and CI.” So they built Scion, an in-house version control system, and “fully migrated our monorepo from git in five months.” The part I find more interesting is that they also “built and shipped a code review surface (called Antique).” A new storage layer wasn’t enough on its own. It needed its own review.4

The review side is where it lines up with this post. Anthropic says their tooling “can express complex semantic constraints on approvals,” distinguishing “comment-only changes from sensitive logical changes,” so “that human reviewers can focus on the most consequential changes.” Describing how the team that built Scion reviews changes to it, they write that “our team members still review every change request for the system, but they now examine the intent of the change as opposed to reading every line of code.” That’s very close to what I’d want from an Approval Request. The reviewer looks at what a change is for and what it will do, and the system decides how much human attention a given change deserves.

Back in March, when Anthropic launched its Code Review product, the announcement named the same problem: “Code review has become a bottleneck, and we hear the same from customers every week.” Faros AI’s telemetry points the same way. Developers on teams with high AI adoption “complete 21% more tasks and merge 98% more pull requests,” while “PR review time increases 91%.”5

OpenAI has been moving in the same direction. Its post on scaling Git at OpenAI describes Pando, an internal, Git-compatible backend for its monorepo. According to AI Weekly’s write-up, the post says “it was clear that we needed to revamp our source control system to scale to the level of concurrent work that Codex makes possible.” Separately, Reuters reported in March, citing The Information, that “OpenAI is developing a new code-hosting platform to rival Microsoft’s GitHub,” in a project that was in its early stages; Reuters said it could not independently verify the report. And this month OpenAI announced it would acquire Pierre, whose Code.Storage InfoWorld describes as an “infrastructure layer for Git” that OpenAI plans to fold into Codex.6

The open-source side is moving too. Enroute bills itself as “fast, programmable git infrastructure on object storage,” and its repository calls it an “open source alternative to Pierre (code.storage).” Its site invites you to “build review strategies beyond the pull request,” and its thesis says that “well established primitives, like pull requests, are breaking down.” The project has also turned pull requests off for its own repository, and takes patches by email instead: “Pull requests are disabled. Coding agents make it too easy to send a large, low-context change that costs maintainers more time than it saves.” Aspen, from Reason Machines, is “a self-hostable Git server for agent-scale traffic,” and describes itself as “an independent implementation” of the design in OpenAI’s Pando post. Both are early, and Aspen is explicit that it’s pre-alpha.

Across all of these, storage is getting rebuilt first, because it’s the part that’s falling over. Aspen’s README is direct about it: “no code review or issues (keep those on GitHub or GitLab with mirror mode).” Enroute lists code review as part of a broader vision rather than something it does today. The review layer is harder, and it’s the piece Anthropic had to build alongside Scion.

So yes, I think we need a new GitHub even for git. But all of this is still about code, where we at least have a pull request to outgrow. Last year, in a post about giving parallel agents their own worktrees, I wrote that code review will become a larger part of the responsibilities of engineers. I’d make the same prediction for most people whose work agents touch, and they’re starting with a lot less.

The Tools Already Exist#

The capability that makes agents risky is the same one that makes an Approval Request buildable. An agent that can draft a change to a supplier contract can also read the current contract, render the change as a redline against it, and summarize what it does to each side’s obligations. An agent proposing a price change can show the old and new prices, which customers it touches, and when it takes effect. A customer email can be staged next to the account history that prompted it. A marketing campaign can show its audience, its copy, and its send schedule before anything goes out.

None of these domains had a diff before, mostly because a diff needs someone to work out what the current state is and what’s actually changing. That used to be a person’s job, and it was expensive enough that nobody did it for routine changes. It’s now cheap.

That gives the Approval Request a fairly clear shape. It names the action the agent wants to take, and the intent behind it, in terms a reviewer can check. It shows the diff against current state, not just the new version. It’s a place to review: to comment, ask the agent a question, or send it back. It records an explicit approval, pinned to exactly what was reviewed, so that a change made after the approval needs a new one. And like Anthropic’s approval rules, it can decide how much review a change needs, so the cosmetic ones don’t bury the consequential ones.

Rollback Is the Hard Part#

A quietly enormous reason code review works is that almost everything in software can be undone. A bad merge is a git revert. A bad deploy is a rollback.7 That safety net is a large part of why we’re comfortable approving changes quickly: a problem the reviewer missed usually costs someone an afternoon, not something permanent.

The rest of the world mostly doesn’t have that net. A sent email stays sent. A payment that has gone out doesn’t come back because you asked nicely. A public statement can be corrected, but not unsaid. I made a version of this argument about agentic commerce a couple of months ago: what worries me isn’t agents buying things, it’s the unsupervised, large, hard-to-reverse purchase, where the agent decides and the person pays for the decision.

So an Approval Request can’t only review the forward change. It has to carry the reversion path alongside it, and be honest about what’s reversible, what isn’t, and what undoing it would cost.8 This is where agents help again. The same agent that proposes the change can propose how to undo it, at the same time, so the rollback is written once, reviewed and approved alongside the action, and then held as the known way back if it’s needed. In git, reversibility is assumed, and nobody approves it. Here, it becomes part of what you’re actually approving.

That also tells you where to spend human attention. A change with a cheap, tested way back can move quickly, with light review. A change with no way back is the one that deserves a person reading it carefully, before it happens, which is the step that was skipped at Meta when the agent posted without asking.

Someone Should Build This#

We built the review layer for code almost by accident, and it became the substrate of how software ships. Agents are about to make change cheap and fast in places that have never had anything like it. What’s missing there is a general place to stage, review, and when necessary reverse what agents propose.

Someone should build the Approval Request. It’s a record of a consequential action that an agent wants to take, and it can’t take effect until it has been approved. At a minimum it has to include the diff against current state, a place to review it, an explicit approval tied to exactly what was reviewed, and the reversion path, reviewed and approved along with the change itself. It has to sit outside the agent, and it has to work for contracts, prices, emails, and policies, not just repositories.

That’s the new GitHub, and it isn’t really for git.

GitHub’s real product was never the repository. It was the place a change waits to be approved. Most of what agents are about to touch is going to need one, and a way back.


Hopefully this works out for you, or was at least helpful. If you have any questions, don’t hesitate to shoot me an email, or follow me on twitter @nrmitchi.


  1. Track changes and suggestion modes are genuinely good at what they do. The gap is that they stop at the document, and the consequential part is usually what somebody does with it afterwards. ↩︎

  2. Pharmaceutical manufacturing has a formal change management system under ICH Q10, changes to an aircraft’s type design go through 14 CFR Part 21 Subpart D, and IT organizations that run ITIL-style change management have their own version. I’m not arguing those processes don’t work. They were built for a different rate of change. ↩︎

  3. The release that carries this figure is headlined “Gartner Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027”, and it warns about “agent washing”. I’d read the 33% as a forecast of adoption, not of success. ↩︎

  4. Anthropic is clear that “Scion is by no means a suitable replacement for git for general use,” and that it “requires its own code review, code search, and CI.” It isn’t offered outside of Anthropic, and the post doesn’t say where Anthropic hosted its repositories before. ↩︎

  5. Faros AI sells engineering analytics, so this is vendor telemetry (“over 10,000 developers across 1,255 teams”) rather than an independent study. ↩︎

  6. Pando, the code-hosting report, and the Pierre acquisition tend to get written about together. OpenAI hasn’t said they’re the same effort, and coverage of the Pando post says it doesn’t name the Git host Pando replaced, so I’m not going to connect them. ↩︎

  7. Not everything in software reverts cleanly. A destructive migration, a leaked secret, or an email sent by a background job don’t come back with git revert. Those are the exceptions engineers plan around, and they tend to be the changes that already get the most careful review. ↩︎

  8. Many of these have a compensating action rather than a true undo: a refund, a correction, a follow-up email. That still belongs in the Approval Request, along with an honest note that it doesn’t put things back the way they were. ↩︎

Read more