The math of the 6,000-commit pull request
AI generates code too fast for human review, transforming the Git commit from a readable narrative into an invisible intermediate compilation step.
By Theo Marsh
Sparked by Making Postgres 300x faster for analytics: batching, operator fusion, and SIMD · discussion
Someone recently shared a blog post about rewriting a Postgres query engine to run hundreds of times faster. The team deployed an AI agent fleet to grind through the refactor, resulting in an astonishing 6,000 commits generated over just 29 days. Over on Hacker News, the community immediately descended into deep, familiar debates about vectorization limits and database performance tuning.
But scrolling through the thread, a different detail snagged my attention. A single commenter zoomed out from the benchmark wars to point out a crumbling assumption in our software development lifecycle: "commit count used to mean review time."
Let's take out a napkin and actually model what that means.
Imagine we assign an entirely average human bottleneck to this project. We'll call him CousinVinnyTheReviewer. Vinny is a senior engineer whose sole responsibility is to sit at his desk and manually review the output of this agent fleet so it can be safely merged into production. To clear 6,000 commits over a 29-day sprint, Vinny has to review and approve roughly 206 commits every single day.
An eight-hour shift gives Vinny exactly 480 minutes. Divided by 206 commits, our reviewer has exactly 2.3 minutes to evaluate each pull request.
That is 138 seconds to read the diff, understand the blast radius, check for edge cases, and click approve. Every single time. There are no coffee breaks in this schedule. There is no time allotted for checking Slack, staring out a window to puzzle through a complex loop, or realizing the AI hallucinated a variable name deep in a nested conditional. It is just a raw, unblinking stream of machine exhaust flashing across a monitor.
If we put a diagram of this workflow on a whiteboard, it would look like a heart monitor flatlining. You have an 8-hour block of time sliced into frantic 138-second slivers, stacked against a process that demands deep, sustained cognition.
This completely shatters our empirical understanding of how human beings process logic. Years of research into software engineering hygiene mathematically guarantee the collapse of this workflow. Foundational studies from companies like SmartBear cap effective human review at fewer than 400 lines of code at a time, recommending 60-minute blocks of deep review. Even Google's engineering practices assume a reality of focused, time-intensive attention where a reviewer builds a comprehensive mental model of the proposed change.
Vinny's 2.3-minute window leaves no room for mental models. He isn't verifying logic. He is just mashing a green button to clear an inbox that fills up faster than he can read it..
The friction here stems from a deeply ingrained assumption that a Git commit remains a story written by a human. Historically, a commit was a discrete unit of human reasoning. You could read it like a paragraph. It had a beginning, a clear intention, and an end. When a developer submitted a pull request, they were handing you a narrative of their problem-solving process.
We are currently watching that narrative capability shatter. Code is being generated at speeds that render human reading physically impossible. As Ted Benson has pointed out regarding Turing-checkable generations, when systems write logic this fast, the output must be verified by deterministic tests rather than human eyeballs. You cannot scale CousinVinny. You have to remove him from the loop entirely.
The nature of the repository has fundamentally inverted. The Git commit is transitioning from a unit of communication into an intermediate compilation step.
Think about how we treat lower-level languages today. We don't read the intermediate assembly code our C++ compiler spits out because we trust the compiler & we verify the final binary through rigorous testing. We accept that the machine handles the translation. We should be treating the AI's intermediate commits with the exact same hands-off detachment. If the test suite passes, the commit merges. The code itself becomes a temporary artifact -- an invisible byproduct of the agent's work.
My guess? In five years, opening a Pull Request to manually review an AI's commits will feel as absurd as opening a hex editor to verify your C++ compiler. Git is the new Assembly.