The AI Pull Request Stampede: Generation is Cheap, Trust is Expensive

Bam! The 10,000-line PR hit my inbox like a blind seagull diving into hot garbage. All the stinks were in place: gratuitous verbiage, tests safe-guarding against guardrails breaking, correct-looking code with subtle errors, and Git history full of missteps and back-tracks.

Time to grill this whale before serving it to my fellow humans!

The barbarians are at the gates

Code is landing in bigger chunks and there's more of those. In an outage post-mortem, GitHub reported monthly commits doubling from 1.4 billion to 2.9 billion in just four months. The Pragmatic Engineer charted the macro trend: monthly merged pull requests jumped fivefold to 130 million across three years, accelerating after late 2025. Meanwhile, DX telemetry showed weekly throughput rising from 1.42 to 1.94 PRs per engineer, with median change size expanding from 42 to 72 lines. Cursor Insights similarly revealed that mega-PRs over a thousand lines shot from 8.0% to 13.8% of all merged diffs.

If AI does not cause the trend alone, it certainly accelerates its growth. Telemetry from Linear showed teams with connected coding agents opened 65 PRs weekly, while teams without agents opened just 10. Direct code contributions from non-engineering roles are expanding fast: PR attachments rose from 3% to 10% in Product and from 1% to 8% in Design.

The sound you hear is the horde of commits crashing against your review gates.

Crawl out from under your rock

Most engineering teams rarely track PR statistics, so no one hears the AI gears grinding. Developers adopt personal tools quietly, spin up background agents, and push diffs without any blip registering on a dashboard. Worst offenders skip the human touch entirely, forcing unsuspecting teammates to review AI-generated dumps straight from the slop tube.

The five-person engineering team at Duckbill Group learned this the hard way when sixty pull requests accumulated over four weeks. The backlog forced the entire team into two straight days of uninterrupted code review (a fate worse than filling out timesheets for a government contract). Without tracking pull request throughput and review turnaround times, you are blindsided with the stampede once the review queue breaks.

Flying blind like a trash seagull

Here's an idea: let's stop reviewing code. As Mike Julian bluntly asked when Duckbill Group hit their review gridlock, "what if we just didn't review the PRs?". If the team cannot drink from the AI firehose, turn them into ceremonial rubber-stampers for silicon-sourced production code. Frontier models write passable code anyway, and another agent can review the output.

Code review is not just about quality assurance, though. Microsoft has the empirical data to show that reading code is primarily about sharing context and discussing architectural tradeoffs. A study of 1.5 million Microsoft review comments found that as diffs get bigger, PRs get less useful remarks.

You may soar like an eagle for a brief while, but you soon find yourself Flying Blind over a garbage dump. Merging code with minimal comprehension strips away awareness of architectural tradeoffs and technical debt. Etienne Dilocker at Weaviate warned that delegating review entirely to agents leads straight to scope creep or missed critical bugs. You end up blindly prompting and praying the infallible LLM figures things out.

Incidental complexity creeps up without a human steward. Velocity slows down. Messy code forces agents into longer thinking loops that feed tokens into the furnace. When development hits a snag, the team lacks the mental map to retreat from the dead end.

Offload review trivia to computers

Humans have limited cognitive capacity. It makes sense to focus on what matters: high-risk changes and long-term, hard-to-revert architectural decisions. Start by writing a clear plan with explicit constraints and test requirements. AI can actually help with this phase, for example, Matt Pocock's /grill-me skill extracts human insight during upfront planning. Experienced developers remain indispensable for robust long-term decisions. As Jackie Luo, CEO of Sigil, observed, stateless application logic is fluid and easily regenerated by models, but the database schema represents the irreversible state machine of the entire system. A few hours spent planning core schemas and building blocks saves days of false starts and incident resolution.

Linters, type checkers, and build pipelines catch syntax errors and formatting violations effortlessly. Professional teams relied on these deterministic tools long before LLMs became the latest distraction. Nitpicking about variable naming and semicolons was always wasted time. Having AI nitpick about formatting is a waste of fresh water and GPU cycles. Use boring technology for the boring day-to-day stuff.

Once the AI-augmented delivery train is rolling, you can no longer assume that a human reads every line of code. Guidance from OpenAI on harness engineering highlights the emerging balance: humans steer while agents execute, with low-risk changes verified through automated pipelines and human review reserved for critical boundaries. Tooling can help spotlight dangerous changes. Automated risk triage at Duckbill Group let them merge low-risk changes in a median time of one hour, while human review for high-risk changes averaged 26 hours. Uber's uReview scores reviewer confidence and visually flags changes touching Tier 0 services. As a counter-example, travel tech company WeTravel evaluated commercial review bots and chose not to deploy tools that harass developers with low-value nagging. Different codebases demand different tooling and have different tolerances: one size does not fit all.

Cutting review fatigue helps teams move fast while keeping developers sane. Automation can apply routine patches and filter out low-confidence bot remarks. As Charity Majors argued, human brains are fundamentally unsuited for repetitive validation. Instead of treating code review as an all-purpose filter, teams need more engineering discipline: tight feedback loops and rigorous automated testing. Make the reviewer's job easy, but keep them in charge: leave risky decisions and informed tradeoffs to humans, and empower them to reject the thousand-line diff coated in AI-slop.

Put the stochastic parrot on a leash

The difference between engineering velocity and technical debt is the discipline of your development loop. Code generation is easy and fast. Gaining trust for the results requires conscious effort.

Deliver software in self-contained incremental changes. Set up deterministic verifications and invest in regression testing. Automate code reviews, define clear code ownership, and experiment with risk-based triaging for your codebase. Collect metrics to verify whether these guardrails protect your team or if your levees are ready to break.

Humans are the final gatekeepers for your software. Give your carbon-based software team full permission to reject pull requests they cannot trust.