Pull requests are, frankly, a pain in the ass now. The problem isn’t simply the volume of AI-generated code or slop, though. PRs are failing us because they’re relics of a model designed for good ole’ fashioned manual coding, not agents.
For years, we’ve modeled software development as a set of sequential loops, including a fast inner loop for local coding and a slower outer loop for CI/CD. The pull request sits in the middle, a pause where humans stop and ask, “Does this look correct?” That model worked when the pace of development was bounded by humans, but it’s breaking down now.
Agents don’t live inside loops. They move fluidly between them, writing code, testing against real infrastructure, deploying incrementally, and continuously adapting. An agentic software development lifecycle (SDLC) looks more like a figure-eight, with agents weaving between development and production, not stopping at a fixed checkpoint.
Press enter or click to view image in full size
In that model, the question “Does this look correct?” becomes “Does this behave correctly under real conditions?” And the rest of the SDLC follows.
The Old Model Was Built for Humans
The traditional mental model of development looked like this:
Press enter or click to view image in full size
You iterate locally in the inner loop. You validate more thoroughly in CI/CD. You observe and refine in production. Each stage expands in scope and time:
- Inner-loop: Local development happens in milliseconds to seconds
- Outer-loop: CI/CD pipelines take minutes to hours
- Scale-loop: Production feedback unfolds over days or weeks
This structure made sense when humans were the bottleneck. Every delay interrupted flow, so we optimized aggressively. But in an agent-driven world, the optimization target is different.
The Figure-Eight Model
A better way to think about the agent-driven SDLC isn’t as a set of sequential loops, but as a continuous figure-eight. Instead of moving step-by-step from local development to CI to production, agents weave between them. They edit code, provision infrastructure, run validations, and deploy changes without pausing for human intervention unless they truly need to.
On the left-side of the figure-eight, agents validate continuously during development. On the right, they gather evidence during release, roll out changes, and observe behavior.
Press enter or click to view image in full size
The intersection — the place where humans traditionally review pull requests — becomes a bottleneck that prevents us from getting the most from our agents. Because the cost of change is so small, agents can explore multiple approaches in parallel, discard failures, and converge on solutions through iteration rather than upfront planning. But they can’t do that efficiently if a human is reviewing every code diff.
The End of Pull Requests
If agents are continuously validating changes during development and continuously proving safety during release, the importance of a discrete “review moment” starts to diminish. Pull requests exist because humans needed a checkpoint: a place to stop, inspect, and approve changes before they reached production. But what happens when there is no natural stopping point?
In a continuous flow, changes aren’t bundled into a single proposal. They evolve. They are tested against real infrastructure. They are evaluated based on evidence, not intuition. In that model, the PR becomes less of a safeguard, and more like a relic of a system designed for human-paced collaboration.
That’s not to say humans shouldn’t be “in the loop”, we absolutely should, but with a different role. Instead of reviewing enormous diffs line by line, human’s need to start reviewing behavior and evaluating outcomes. Reviewing evidence and validating that the right thing happened becomes just another point in the figure-eight.
Press enter or click to view image in full size
From Code Review to Evidence Review
Today’s version control systems are built around human authorship. We track who wrote what, review diffs line by line, and manage merge conflicts through approvals. But when agents generate and refine code continuously, those tools start to add unnecessary friction.
In the figure-eight model, authorship becomes less meaningful. Iteration is constant, not discrete. Correctness isn’t something you infer from reading code, it’s something you demonstrate through evidence.
Instead of versioning code changes, we start versioning outcomes. A developer no longer opens a pull request with hundreds of lines of AI-generated code changes. Instead, they specify intent: what the system should do. The agent implements that intent, tests it against real systems, encounters edge cases, asks for clarification, adapts, and validates again. It rolls out changes gradually, gathers telemetry, and only progresses when evidence supports it.
The final checkpoint isn’t a human approving a diff. It’s a system reaching a confidence threshold.
What We Gain, What We Lose
This shift won’t be free. We’re losing code review as a collaborative practice, Git blame as a narrative of authorship, and even the psychological safety of a human checkpoint before production.
But what we gain is more aligned with reality. Continuous validation is often more rigorous than human review. We gain systems that operate 24/7 without waiting for us. We gain the ability to explore multiple solutions in parallel and converge based on evidence. Most importantly, we’ll move from trusting people to trusting proof. Not because humans are unreliable, or agents are superior, but because evidence is stronger than either.
This will be uncomfortable. We’re going to have to let go of practices that have served us well. But those practices were built for a world where humans were the primary authors, not agents.
Beyond the Old Loop
The inner-outer-scale model worked because it matched the constraints of its time. But in an agent-driven system, the constraint isn’t how quickly a human can react. It’s whether the system can maintain forward motion at all.
The figure-eight model better reflects that reality. Agents move fluidly between development and production, continuously testing, validating, and adapting. They don’t wait for permission. They operate within boundaries and escalate when necessary.
As that system matures, the central checkpoint (the pull request) diminishes in importance. Not because we optimized it, but because we no longer need it.