Agents Run the Line, Humans Approve

Solving the code review bottleneck means moving human judgment to where it matters most.

6 minute read

A software development pipeline with automated agent stages supervised by human engineers at key approval gates

I’ve been following the work a prior coworker’s team has been posting on social media lately. They recently celebrated a record sprint by adopting coding copilots across four squads and their pull request output doubled in two weeks. Their velocity charts looked extraordinary, yet two sprints later, delivery had ground to a complete halt.

Four developers generating 5x the pull requests created an avalanche of diffs that dumped directly onto one engineering lead. That lead spent their days detangling diffs and trying to figure out whether an automated refactor broke an unwritten assumptions in their code.

Fast code is simply not fast shipping.

The Chokepoint

When we adopted first-generation AI coding tools, we treated software engineering as a typing problem. In the early days, we handled this through autocomplete assistants, ORM mapping tools, and other automations. As generative AI tooling expanded, the tools expanded to autocomplete entire functions in seconds and we assumed delivery would accelerate at the same rate–and it did, which was fantastic.

However, we simply relocated the bottleneck from the typing to the reviewing.

Back in July, I looked at data from CodeRabbit showing that AI-coauthored pull requests averaged 10.83 issues per pull request compared to 6.45 for human-written ones. Around that same time, a survey from LeadDev confirmed what many of us were feeling: 38% of teams with manual review were spending more time reviewing code after adopting AI tools, and manual code review had become the primary barrier to shipping.

When you accelerate the front of an assembly line without widening the inspection gate, you don’t get more finished features. You get a backlog full of unfinished parts and an exhausted inspector buried under tickets.

 
Accelerating code generation without changing how review works does not speed up delivery. It just concentrates the strain onto whoever signs their name to the diff.

Last month, I wrote about how engineering leaders are stepping back in the code to help shoulder this load. While that hands-on time keeps our judgment sharp, asking technical leaders to manually read every line of machine-generated boilerplate is a recipe for team burnout.

We need a different operating rhythm entirely.

From AI-Assisted to AI-Led

A cartoon circulating across engineering channels lately captured this contrast with uncomfortable accuracy. In the top half, labeled AI-Assisted, four individual developers frantically feed an endless conveyor belt of code and feature requests onto the desk of a single terrified reviewer. The caption reads: “Code in minutes. Review still waits.”

In the bottom half, labeled AI-Led, the dynamic flips. Autonomous agents run the conveyor belts through discrete stages, from initial plan to automated test. Meanwhile, human engineers step back from typing code and position themselves at strategic control gates along the line.

The caption sums up the transition: “Agents run the line. Humans approve.”

The Five Human Gates of an AI-Led PipelineA progressive software delivery pipeline where automated agent stages run through planning and test execution, while humans govern five strategic approval gates: Goal, Rules, Plan, Risk, and Final Approval.Gate 0: GoalSets the intentScope & specsGate 1: RulesSets invariantsLinters & evalsAgent: PlanBlueprint & diffsZero code writtenGate 2: PlanApproves approachCatches design flawsAgent: BuildTypecheck & testsMechanical passesGate 3: RiskChecks exceptionsMigrations & authGate 4: ApprovalStamps ShippedOperational readinessAutonomous harnesses execute the work. Humans steer the control points.

This shift reorganizes human review. Instead of asking one engineer to sit at the end of the line and inspect massive pull requests, review gets distributed across five distinct checkpoints.

The Five Human Gates

Here are the five approval gates that turn autonomous agent pipelines into reliable delivery systems.

The Intent Gate

The first gate happens before an agent touches a repository. A human engineer or product lead defines the concrete goal, user requirements, and boundary conditions. If an autonomous agent is guessing what problem it is trying to solve, the human failed upstream.

The Invariant Gate

Before launching agent tasks, technical leaders establish the non-negotiables. You define the type contracts, linting rules, security baselines, and automated evaluation suites that run in your environment. These rules live directly in your repository configuration and test suites, giving your agents deterministic boundaries.

The Architecture Gate

This checkpoint delivers the biggest payoff in the entire pipeline. When an agent receives a goal, it produces an execution plan listing every file it expects to modify, the data structures it intends to touch, and the dependencies it plans to add.

A senior engineer reviews and approves this architectural plan before the agent writes a single token of code.

Catching an architectural flaw at the planning stage takes two minutes and costs zero lines of code to fix. Waiting until forty files are written to discover that an agent chose the wrong database abstraction creates an enormous review burden.

 
If you approve the architectural plan before an agent generates code, you eliminate the majority of downstream design arguments before they ever enter a pull request.

The Exception Gate

Once the plan is approved, the agent builds the code, runs the test suite, and typechecks its own output. For standard mechanical changes, such as updating boilerplate or adding unit tests, automated CI runners provide sufficient verification.

Human review at this stage is exception-based. You inspect the diff only when the agent flags an ambiguity, when tests fail after bounded retries, or when changes touch high-risk surfaces like database migrations, authentication routines, or hardware driver interfaces. Routine code passes through automated gates, while senior human attention stays reserved for blast-radius risks.

The Stewardship Gate

The final gate represents release ownership. A technical lead examines the completed outcome against operational reality. Does this deliver the intended customer value? Are dashboards and telemetry in place to monitor it?

When everything checks out, you stamp approval with genuine confidence, because the pipeline did the mechanical verification while you steered the decisions.

Where Our Hands Belong

When I wrote about getting back in the code last month, the feedback from other engineering leaders reflected a shared tension. Leaders felt pulled between managing teams and diving into diffs to prevent regressions.

That tension came from assuming code review had to remain a single, manual chokepoint at the end of every branch.

By reorganizing software delivery around an agent-led model, our role evolves from code inspection to engineering orchestration. We stop wasting human attention on reviewing syntax and boilerplate that compilers and test runners can verify automatically.

Instead, our hands stay firmly on the levers that matter. We shape the goals, define system boundaries, review architectural plans, and evaluate operational risk.

I’m are still learning the how to balance this with teams and different technical levels, and the tooling continues to rapidly mature. But moving from AI-assisted “typing” to AI-led execution with human gates looks like the transformation necessary to shift us from an overwhelming backlog into thoughtful engineering stewardship.