Guide · Reviewing agent PRs

Review the intent, let the machines check the rest

When agents open more pull requests than you can read line by line, review has to change. Let machines check everything they can before a PR reaches you — and review against the story, not just the diff.

Mio Nilsson, creator of AerunitBy · Last updated

A crystal magnifying lens inspecting floating glass code panels in purple and cyan light
The problem

Why agent PRs are different

Agent pull requests arrive in larger numbers, they look confident, and you can't ask the author "what were you thinking?" afterwards. Early research is starting to show what that means in practice.

A study of 7,156 agent PRs found that the type of task matters more than which agent wrote it: "documentation tasks achieve 82.1% acceptance compared to 66.1% for new features." No agent won every category. [2] A second study looked at 654 rejected agent PRs and found seven rejection modes that occur only in agent PRs — and that "a large proportion of rejected PRs (67.9%) lack explicit reviewer feedback." [1] In other words: most of the time, nobody tells the agent why.

Both studies use the same public dataset of agent PRs (AIDev), and both were published in February 2026; agents have changed since — read the numbers as direction, not as a leaderboard.

Before it reaches you

Push checks left

Anything a machine can check should never reach a human: formatting, types, lint, complexity, tests. Each of those belongs earlier in the ladder — at the agent's edit, at commit, in CI. We cover how to set that up in our guide to instant feedback for coding agents.

Google's code review guide still applies to agents: the reviewer looks at design, functionality, complexity, tests, naming and comments — the things that make a codebase healthier over time. [3] The difference with agents is that the mechanical part of that list can be automated almost entirely.

The handoff

Ask the agent for evidence, not assertions

"Done, all tests pass" is an assertion. Ask for evidence instead. Put a handoff line in every story asking the agent to "summarize changed files, checks run, failures encountered, and any remaining risk." [8] Cursor's Cloud Agents can also attach screenshots, videos and log references to the pull request, so you can see the change working without checking out the branch. [7]

Example PR handoff
## What changed
- auth/login-form.tsx — locked-account message + reset link
- auth/login-form.test.tsx — new test for the locked case

## Checks run
- npm run typecheck ✔
- npm test -- auth ✔ (14 passed)

## Failures hit
- First run broke the signup error style; fixed by reusing ErrorBanner.

## Remaining risk
- Copy not reviewed by product. Lockout threshold unchanged (non-goal).
Fresh eyes

A second, independent reviewer

Don't let the agent grade its own work. An automated reviewer in a fresh context catches things the writer is blind to. Claude Code's docs describe a writer/reviewer pattern: "A fresh context improves code review since Claude won't be biased toward code it just wrote." [4] Cursor Bugbot "analyzes PR diffs and leaves comments with explanations and fix suggestions" [5], and GitHub Copilot code review does the same on GitHub. [6] Claude Code on the web can go a step further and auto-fix pull requests: it watches a PR and responds to CI failures and review comments — a good example of sending the findings back to the agent. [9]

There's a flip side, and the same docs are honest about it:

"A reviewer prompted to find gaps will usually report some, even when the work is sound, because that is what it was asked to do. Chasing every finding leads to over-engineering." [4]

So act only on findings that affect correctness or the stated requirements. Everything else is optional.

The human part

What only you can review

Intent

Is this the behavior the story asked for — not just behavior that passes the tests?

Product feel

Does it feel right to use? Screenshots and videos help here.

Naming

Will the next person (or agent) understand these names without the PR description?

Architecture direction

Does this move the codebase where you want it to go, or just somewhere that works?

Anything off-story

Changes the story didn't ask for are a question, not a bonus.

Close the loop

Leave feedback the agent can act on

Remember the 67.9%: most rejected agent PRs carry no explicit reason. [1] When you reject a PR or ask for changes, say why — in the PR or in the story. "Wrong" teaches nothing. "This should reuse the existing ErrorBanner, see signup-form.tsx" fixes this run and the next one. If the same feedback keeps coming up, it belongs in your shared conventions, not in another comment.

Where we come in

Where Aerunit fits

This guide's argument is that review should be layered: machines first, an independent reviewer next, you last — measured against the story. Aerunit covers the middle layer and the yardstick. When an agent opens a pull request, Aerunit reviews it automatically and can send the findings back to the same agent session to fix, so the PR you open has already been through one round.

The yardstick is the story itself: Aerunit's story writer proposes Linear issues with scope, acceptance criteria and non-goals, so you review against a named target. And team conventions you'd otherwise repeat in review comments live once in shared context and skills, fed into every story and run.

Automatic review

Every agent PR reviewed, findings sent back to the agent's session.

A clear yardstick

Acceptance criteria and non-goals in the story you review against.

Fixed in the same session

Findings go back to the agent that wrote the PR, so you review a second pass, not a first draft.

Quick answers

Common questions

Should I review every line an agent writes?

Not line by line, once you have the machine checks in place. Let formatting, types, lint, tests and an automated reviewer cover what they can. Your review should cover what they can't: is this the behavior the story asked for, the right shape, the right names, the right direction for the codebase.

Can an AI review AI code?

Yes, and it helps — as long as it's an independent reviewer in a fresh context, not the same agent grading its own work. Claude Code's docs note that a fresh context improves review because the reviewer isn't biased toward code it just wrote. Products like Cursor Bugbot and GitHub Copilot code review do this on pull requests. [4] [5] [6]

How big should an agent PR be?

Small enough that you can judge the intent in one sitting — one story, one slice. If a PR touches areas the story didn't mention, that's a signal to split the story, not to read harder.

What do I do with a PR that's 90% right?

Don't fix the last 10% by hand in silence. Leave the reason as a review comment or update the story, then send it back to the agent. That way the fix is recorded, and the next run starts from the corrected brief.

Aerunit

Keep the agents busy. You do the thinking.

Sign-up is open — create an account and start with pay-as-you-go credits. No subscriptions, and teams share one credit pool at no extra cost.

Create account