• Docs
  • Talk to an expert
Blog
Blog
BlogProductCase studiesNewsInsights
Blog

Reviewing code you did not write: the problem with agent PRs

Upsun DispatchAI AgentsAgentic SDLCdeveloper workflow
17 November 2026
Greg Qualls
Greg Qualls
Senior Director, Product Marketing
Share
This post is also available in German and in French.

TL;DR

  • An agent PR shows you what changed. It rarely shows you why, what the agent was asked, or what it considered and dropped.
  • Without that context, reviewers either re-derive the agent's reasoning from scratch or approve on trust. Both cost something.
  • A reviewable agent PR carries three things beside the diff: the plan it worked from, the checks it already passed, and a record of the run.
  • Upsun Dispatch™ posts the plan to the issue, runs a critic agent before the PR opens, and captures every prompt, diff, approval, and usage event as it happens.

It's 4pm and a PR lands in your queue. Fourteen files changed. The description says "Implements rate limiting for the public API, per issue #812." The tests pass. The code is clean, consistently formatted, and plausibly correct.

You didn't write it. Neither did anyone on your team. An agent did, from a two-line issue someone filed last week.

So you start reading. Why a sliding window and not a token bucket? Why does the limit live in middleware instead of at the gateway? Was the Redis dependency a deliberate choice, or the first thing that worked? Did the agent know about the internal client that hammers this endpoint every night?

The diff can't tell you. The commit message can't either. And the author isn't available for a quick question, because the author was a model that finished its work and moved on.

Why agent PRs are harder to review than human ones

Key takeaway: an agent PR arrives without an author you can question, so its reasoning is lost unless something captured it during the run.

Code review has always relied on something outside the diff. When a teammate opens a PR, you know roughly how they think. You were in the planning meeting. You can ask them in Slack why they picked one approach over another, and they can answer.

An agent PR removes all of that. The reasoning happened inside a model run: the prompt it received, the files it read, the options it weighed, the plan it settled on. Unless something recorded that run, it's gone by the time the PR reaches you. What's left is the output, and output alone is a poor guide to intent.

Agent code also tends to fail quietly, because it usually looks right. In Stack Overflow's 2025 Developer Survey, 66% of developers named "AI solutions that are almost right, but not quite" as their biggest frustration with AI tools, and 45% said debugging AI-generated code takes more time. Code that is almost right is hard to review, because nothing in it flags itself as wrong.

The same survey found that experienced developers are the most cautious group, with the highest rate of strong distrust in AI output. Those are often the same people who get the review requests.

What reviewers end up doing instead

Key takeaway: without the reasoning, review becomes a choice between slow, risky, or wasteful. The fix is to give reviewers the context back.

Faced with a diff and no reasoning, reviewers tend to fall back on one of three habits. Each makes sense in the moment, and each has a cost that shows up later.

The careful option is to re-derive the reasoning. You read the issue, read the code, and reconstruct what the agent must have been thinking. It works, but a quick review turns into a long one, and you've redone the planning work the agent was supposed to save.

The fast option is to approve on trust. The tests pass, the code looks idiomatic, and the queue is long, so you skim and approve. That holds up until an assumption the agent made turns out to be wrong and nobody can say why the code was written that way.

The safe option is to send it back, or rewrite it yourself. You don't merge what you can't follow, and you also throw away most of the time the agent saved.

All three are reasonable responses to the same situation: being asked to sign off on work without the context you'd normally have. As agents take on more of the code, the review queue grows, and the cost of each habit grows with it.

What a reviewable agent PR needs

Key takeaway: plan, checks, and record turn an agent PR from an unexplained diff into work a reviewer can actually evaluate.

You can't ask an agent what it was thinking once the run ends, but you can make the context travel with its work. A reviewable agent PR carries three things beside the diff.

  1. The plan it worked from. Before writing code, the agent should state what it intends to do and how, in a place the team can see. A plan answers most of the "why" questions up front: which approach, which files, which trade-offs. It also gives someone a chance to catch a wrong direction before any code exists.
  2. The checks it already passed. Tests are one check. A second pass that reads the change against the plan is another, and it catches a different class of problem: code that compiles and passes tests but doesn't do what was asked. When those findings arrive with the PR, the reviewer starts from a known baseline instead of a blank page.
  3. A record of the run. What was the agent asked? What did it change, step by step? Who approved what, and when? A record captured as the run happens lets a reviewer answer those questions quickly, and lets anyone debug the change months later when the original reviewer has moved on.

These three things have costs. A plan adds a step before any code exists, and approving it puts a person in the loop earlier. Checks have limits too: a review against the plan won't notice if the plan itself was wrong. A person still makes the call on every agent PR, and the plan, checks, and record make that call better informed.

How Upsun Dispatch puts the reasoning back next to the code

Key takeaway: Upsun Dispatch keeps the plan, the critic's findings, and the run record attached to the agent's work, so reviewers start with context instead of a bare diff.

Upsun Dispatch is the platform for governed collaboration between AI agents and cross-functional human teams. It works alongside the tools your team already uses: GitHub, GitLab, Jira, and Linear. Its Issue to code workflow is built so the plan, the checks, and the record arrive with the work.

The plan goes to the issue first. A planning agent reads the issue and writes an implementation plan, and Upsun Dispatch posts it back to the issue or ticket before any code is written. For runs started from Jira, you can turn on a plan approval gate (it's off by default) so the run waits for a person to approve, reject, or revise the plan.

A critic reviews the change before the PR opens. After the coding agent finishes, a separate critic agent reviews the change against the plan. Serious problems, such as code that won't compile or that contradicts the plan, stop the PR from opening at all. Lesser findings go into the PR description, so the reviewer sees them up front. The critic runs once, and Upsun Dispatch doesn't rewrite the code in response to its findings, so anything short of a blocker is yours to weigh.

Every run leaves a record. Every prompt, diff, approval, and usage event is captured as it happens. In the Upsun Dispatch console, each run shows its status, its steps, a timeline of events, and its logs. When questions come up later, there's a record to check.

The Code review workflow adds one more layer: it reviews pull requests and merge requests and posts its findings as inline comments and, depending on your settings, a summary, alongside your team's own review.

See what a run record holds

Months after a merge, the run record may be the only place the agent's reasoning still exists. Our technical guide walks through what Upsun Dispatch captures for each run, and how an engineer uses it to reconstruct intent and debug a change later.

Read the guide: Reconstruct any agent run later: what gets captured, and why 


 

Frequently asked questions (FAQ)

Why are AI agent pull requests hard to review?
The diff shows what changed but rarely why. The prompt, the plan, and the options the agent weighed usually aren't recorded anywhere the reviewer can see, so the reviewer has to reconstruct the reasoning or approve without it.

Is passing tests enough to approve an agent PR?
Tests confirm the code does what the tests check. They don't confirm the change matches what was asked, or that the agent's assumptions were sound. Agent code is often almost right, which is exactly the kind of problem tests can miss.

What should an agent PR include to be reviewable?
The plan the agent worked from, the results of any checks it already passed, and a record of the run: what it was asked, what it changed, and who approved what.

How does Upsun Dispatch help reviewers?
In the Issue to code workflow, Upsun Dispatch posts the agent's plan to the issue, runs a critic agent that can block the PR if it finds serious problems, and captures every prompt, diff, approval, and usage event as it happens.

Does Upsun Dispatch replace human code review?
No. People still review and approve agent work. Upsun Dispatch gives them the context to do it well. 

Stay updated

Subscribe to our monthly newsletter for the latest updates and news.

Deploy possibility.
Try Upsun for free.

Build with DispatchDeploy on Cloud