AI code review vs verification: check the card, then the diff

AI code review vs verification is two jobs. Abstract agent review produces nits and drifts off the card. Check the intent, the run, and the evidence, then let a person merge.

AI code review vs verification is two different jobs. An agent reviewing another agent's diff mostly produces nits, and it steers the pull request away from what the card asked. What matters is verification against that intent. Did it do what was asked, does it run, and did a person who knows the goal say yes.

Adversarial review burns the tokens on nits

maybe a hot take but i now consider adversarial reviews mostly a waste of tokens. far better to use those tokens on empirical combined with formal verification. i have updated pstack to use the interrogate skill less, and eventually i think i may remove it altogether

i have found very little value with code review in the abstract, agents tend to just get lost in the nitpicks and yagnis

X

lauren @poteto

· 7,274 likes · 265 reposts · 551 replies

as of

Yup. The second agent gets lost in nits, and the authoring agent treats every nit as a task. Claude or Codex will comment on names, extra abstractions, and cases nobody asked for. The diff gets longer. The card gets quieter.

i think you can get into overfitting or "overcooking" a PR by going through multiple rounds of abstract code review from agents. the reviewers likely have 0 context around your goals and intent, and they tend to pick up things that don't matter or steer the authoring agent in the wrong direction. and the author agent is usually too sycophantic and will accept and all feedback without really thinking about whether it makes sense

X

lauren @poteto

· 171 likes · 4 reposts · 18 replies

as of

A few rounds of that overcooks the pull request. The reviewing agent has no context on the goal. The authoring agent accepts the feedback without asking whether it belongs. I would rather spend those tokens on a run I can look at.

She is also talking about formal verification. That is a different tool from a product pull request. The check I want here is empirical. The card, a run, evidence, and a person.

The time you saved is sitting in the queue

Developers are shipping code twice as fast with AI.

Then why does the release cycle take the exact same amount of time?

When you speed up local code generation without connecting your specs, docs, and review workflows, you just move the bottleneck downstream to the pull request queue.

X

Brij Pandey @LearnWithBrij

· 70 likes · 15 reposts · 8 replies

as of

Yup on the bottleneck. Faster local generation moves the wait onto the pull request. The post is sponsored by Atlassian, so I'm not taking any numbers from it. The point stands without them.

Chen and Stratton (Harvard) measured a version of the same shape in "Artificial Intelligence in the Firm: Bottlenecks in Software Production", a job market working paper, version dated Nov 1, 2026. It is not peer reviewed. They write: "After adoption of AI agents, the average time from the code's review submission to its approval increases by 56.1%." The same paper says "79.1% of firms have adopted AI code review tools, but still largely keep humans in the loop." Teams added an AI reviewer and still kept a person on the approval. The approval got slower anyway.

AI code review vs verification

Diagram with two columns. Abstract code review checks style and hypotheticals, done by another agent with no intent, and comes back as nits. Verification checks the card, that it runs, and tests on the latest commit, done by CI and a person who knows the goal, and comes back as evidence plus a yes or a send-back.
Diagram. Abstract code review and verification check different things.

Abstract code review asks whether the diff looks like good code. The reviewer is usually another agent. It has the diff and almost none of the intent, so it picks nits and suggests a refactor. The authoring agent takes the suggestion. A couple of rounds later the pull request solves a slightly different problem than the card.

Verification asks a shorter list.

  • Did it do what the card asked, and nothing else.
  • Does it run.
  • Did the tests run on the latest commit, not on an earlier one the agent already moved past.
  • Is there evidence you can look at, instead of a paragraph saying it works.
  • Does a person who knows the goal sign off.

AI agent pull request verification is that list. The abstract review is optional, and on most cards I skip it. A second model telling me the names are fine does not tell me the change did what the card asked.

Write the intent on the card before you hand it over

Before the agent starts, the card says what done looks like. The acceptance you will check later. Files to leave alone. A decision that is still open stays on its own card, because the agent will guess if you hand it the open question. That setup is the one in Sprint planning for small teams when agents ship in hours.

On Kahoona the agent reads the title, the description, and the last 20 comments. If the description is under 60 characters and the card is waiting to start, the card asks you to add what done looks like. Write it anyway. Standing rules go in the repo's CLAUDE.md or AGENTS.md. The specifics of this job go on the card.

The card has one owner before an agent starts. Who owns the next one is in A Claude Code kanban board: who owns the next task?.

Put the evidence on the pull request

The pull request should show its work. A screenshot or a short recording if a person can see the change. The command and its output if they can't. The card it came from. Green checks on the commit you are about to read. Put that in the file the agent already reads, so you are not retyping it into the prompt.

How I sort the queue after that, boring against risky, is the companion piece, How to review AI agent pull requests without drowning. This post is the split before that sort. Proof against the card, not another abstract pass.

Several Claude Code or Cursor sessions do not change the rule. The evidence still has to land somewhere you open on purpose, not in five terminals. That is How to manage multiple Claude Code sessions without watching them.

Check the evidence, then read the diff

This is how I verify AI agent pull requests.

Diagram of five steps. Check the card, the evidence, and tests on the latest commit first. Then read the diff, and a person who knows the goal signs off. Agents never merge. Skip the list for a tiny change.
Diagram. Check the card, the evidence, and the latest commit before you read the diff.

Open the card first. If the pull request did something the card did not ask for, it goes back. You do not need a style comment to see that.

Then the evidence. If there is nothing to look at, it goes back. An explanation is cheap. A screenshot is not.

Then the checks, on the latest commit. A green run from three commits ago is not this pull request. If CI is red, it is not ready. On Kahoona the agent can run the project's checks on its own computer. I don't treat that paste as the merge gate. GitHub's CI is the gate, and it has to be this commit.

Then read the diff. That read is for intent and risk, not for hunting nits a second agent already listed. Billing, auth, migrations, and CI still get a careful read from someone who knows why the card exists. A copy change does not.

Agents never merge. A review comment from Claude or Codex is a first pass. It is not the yes.

This is overkill for a tiny change tbh. A dependency bump, a typo, a comment. Checks pass, someone glances, done. A recording of a lockfile bump is how the queue gets silly.

Where I use Kahoona, and where I would not

I built Kahoona, so weigh this part with that in mind. It is one web board for a team and its agents. You hand an agent a card and it comes back as a GitHub pull request. The team reviews it and merges it. Agents never merge. The board, the standup, and the Friday update keep themselves current from GitHub. Clients only see the snapshots you publish, through the Client Inbox. Claude, Cursor, and other agents connect over MCP.

Kahoona board. Backlog shows Hide archived from the export, not started. In progress shows Receipt emails on the step Running the checks. In review shows Export archived cards with pull request 229 ready.
Sample cards on the Kahoona board. A finished run shows the pull request as ready in review. A person merges it.

Kahoona does not check that the pull request matched the card. It does not read the evidence and decide. That is still you. It also does not run a second agent whose job is abstract review.

It is the wrong tool if the pull requests are not on GitHub. The loop is a card in and a GitHub pull request out. It is the wrong tool if you want the agent to merge. It is the wrong tool for a one-line change that does not need a board. If the company already lives in Linear or Jira and the reviews are happening there, keep that. I compared the boards in Kahoona vs Linear and Kahoona vs Jira. The same call if the tasks already live in ClickUp: Kahoona vs ClickUp. GitHub Projects is the right board if you want it inside GitHub and you do not want another product in the middle. That comparison is Kahoona vs GitHub Projects.

Kahoona is free for one person. On a team the first chair stays free and each extra chair is $5 a month, so five people pay $20 and ten pay $45. No card needed. It is a web app.

I build it, so this is the loop I use, and a person still merges.

Questions

What is the difference between AI code review and verification?

Abstract code review asks whether the diff looks right, and an agent doing that mostly finds nits. Verification asks whether the change did what the card asked, whether it runs, whether the tests ran on the latest commit, and whether a person who knows the goal signs off.

Should an agent review another agent's pull request?

A first pass on the small stuff is fine. Several rounds are not. The reviewing agent has no context on the goal, and the authoring agent tends to accept the comments and drift off the card. The approval stays with a person.

How do I verify AI agent pull requests?

Write the intent on the card before you hand it over. Ask the pull request for evidence. Check the card, the evidence, and the tests on the latest commit before you read the diff. A person merges. Agents never merge.

Is this worth it for every change?

No. A typo, a copy tweak, or a dependency bump needs green checks and a glance. The full pass is for a card that changed behavior, and always for billing, auth, migrations, and CI.

What does Kahoona cost?

Free for one person. On a team the first chair stays free and each extra chair is $5 a month, so five people pay $20 and ten pay $45. No card needed.