The Pull Request Was Built for Humans. Your Agents Broke It.
For as long as most teams can remember, the pull request has been the control point of software delivery. A person writes code, a person reviews the diff, and a person presses merge. Every business process built on software silently inherits that assumption: at the end of the pipeline there is a human reading every line.
That assumption is now breaking, not because agents write bad code, but because they write more of it than any team can read. This week, the industry's answer landed: a former GitHub CEO launched a platform that replaces the pull request with machine-scored review loops, keeping humans as the ones who set the gates rather than read every diff.
The generation curve nobody can review
The numbers behind this shift come from teams operating at the frontier. In Anthropic's engineering write-up on redesigning source control, the team states plainly: "In May 2026, Anthropic averaged around 2,500 code changes merged per day; as of September, we merged over 30,000 per day." The bottleneck, they say, "is all of the developer infrastructure built for human scale: source control, builds, and CI."
Even at ordinary-company scale, the load is visible. GitHub reported that developers and agents made 7.38 billion commits on the platform in September 2026 alone, a figure reported by GeekWire alongside several significant outages in recent months, including one in August that lasted nearly eight hours. When the review layer was designed for human-scale throughput, agent-scale throughput turns it into the choke point.
The pull request assumed a human author
On October 26, 2026, Entire, a startup led by Thomas Dohmke, who ran GitHub until 2025, launched what it calls the first Git forge built for agent-human collaboration. Dohmke's diagnosis of the classic review flow is blunt: "The pull request has become an audit log that only the agent reads. It does not provide the information for the developer to decide whether they can merge with confidence."
His point is not that review is dead. It is that the shape of review is wrong. A linear comment timeline written for two humans now fills with long agent-authored descriptions and agent-to-agent feedback loops. The person deciding whether to merge no longer finds decision-ready information in the format that was supposed to deliver it.
What the rebuild looks like
The new pattern shows up in three different places at once:
- Machine-scored review loops. Entire's "Trails" run customizable evals scored by review agents on every code push. Each agent runs independently in a cloud sandbox and submits a score and a rationale, with the last five runs shown so teams can see whether scores are stabilizing or thrashing.
- Humans as gate-setters, not line-readers. In the same system, "Gates" define what is required before approval, and those gates can include human approvals and passing CI checks. The human decision moves from reading every diff to deciding what evidence must clear before merge.
- Infrastructure rebuilt for agent throughput. Anthropic built an in-house version control system called Scion and migrated its monorepo off Git in five months. Cursor launched its own code-hosting service, Origin, in August 2026 (as reported by GeekWire). Entire claims pushes up to 89x faster than GitHub in its own open-source benchmarks, a vendor claim worth reading with that framing attached.
Three unrelated organizations, one shared conclusion: when generation gets cheap, the review layer is what gets rebuilt.
Judgment is the scarce resource
This is not only a tooling story. The team at deepsense.ai put the underlying rule in one line back in April 2026: "AI makes code cheaper. That makes engineering judgment more precious." Their warning about metrics applies directly: when PR counts go up, "in practice, it often means the system is accumulating surface area faster than the team can validate it."
Their sharpest observation is about what review is even for: "AI can fill in a pull request. It cannot certify that the decomposition is sound." Agent-scored evals push the volume problem down to machines, but the design judgment (are these the right boundaries, the right trust model, the right rollback path?) does not automate. It concentrates at the gate.
The useful rule
Never let review capacity be the thing that silently limits your automation. Measure whether your team can validate what your agents produce, and put the human decision where the risk is, not where the line count is.
What to actually do
If agents are writing a growing share of the code your business runs on, the checklist is short:
- Watch the ratio of agent-produced changes to human-reviewed changes. When the ratio climbs, your review process, not your agents, becomes the constraint.
- If you run agent review loops, look for score stability across repeated runs, not just a green flag on one pass. Systems that stabilize are converging; systems that thrash are hiding disagreements between reviewers.
- Keep the human gate for what machines cannot certify: design soundness, security posture, and anything irreversible.
- Treat vendor speed benchmarks as vendor claims. The pattern (rebuild review for agent throughput) matters more than any single multiplier.
The pull request is not dying because agents are careless. It is being rebuilt because they are prolific. The teams that win are the ones that spend their scarce human judgment on the decisions machines cannot make.
If you are working out where review gates and human approvals should sit in your own agent-driven delivery process, get in touch. We help teams design that control layer.
Sources
- The Git Forge for Agent-Human Collaboration (Entire blog, October 26, 2026)
- Former GitHub CEO launches rival platform built for AI coding agents (GeekWire, October 26, 2026)
- Redesigning source control at Anthropic (Anthropic engineering blog)
- When Code Gets Cheaper, Judgment Gets More Precious: Quality Bottlenecks in Enterprise AI Systems (deepsense.ai, April 22, 2026)
