My AI Code Review Workflow: Review the Change, Not the Typing
The code got cheap. The review did not. The review workflow I actually use when AI agents write most of the diff, with three passes, an adversarial second agent, and the discipline of reading what ships.
The code got cheap. The review did not.
When an agent can produce a competent multi-file change in minutes, the bottleneck moves to the person reading the diff. What follows is the workflow I actually use, every day, on real systems.
The shape of the problem
A colleague's PR and an agent's diff do not review the same way. A colleague gets tired and writes less. An agent does not, so the volume is relentless and the failures look different. The code usually compiles, usually passes the obvious test, and usually looks right, and when it is wrong it is wrong in a confident, well-formatted way. The typos are gone. The bugs wear suits now.
So the review cannot be a typo hunt. It has to work at the level of the change itself, what was asked for, what was delivered, what came along for the ride.
Three passes
I read every diff three times, fast. Each pass asks one question.
Pass one, does it do the thing. A different question from "does it look like it does the thing." I run it. Tests, build, the actual command, the actual page. If the agent says tests pass, I want to see them pass, because a green checkmark I did not watch happen is a rumor.
Pass two, does it belong. The architecture pass. Is the change at the right altitude? Did the agent solve the problem where the problem lives, or patch the symptom three layers up? Did it invent a new pattern when the codebase already has one? Agents are eager, and they will happily add a second way to do something rather than find the first way. Most of my rejections come from this pass.
Pass three, what came along for the ride. Scope creep, dependency additions, config changes, the helpful little refactor nobody asked for. I read the file list before I read the files. If a one-line fix touches nine files, the diff has a story to tell and I want to hear it before I approve it.
Three passes sounds slow, but each one is a single question, and a single question reads fast. Ten minutes on a medium diff. The discipline is in refusing to let the passes blur together into one vague skim.
The adversarial second agent
One agent reviewing another agent's work is what changed my practice this year. I prompt the reviewer to refute.
"Assess this change" gets you a polite summary. "Find what is wrong with this change, assume something is" gets you a hunter. The reviewer agent does not get tired or attached to the code, and it did not write the code, so it has no ego in the game. It does not find a real bug every time. It finds them often enough, and the cost is a few minutes of wall-clock I was spending anyway on pass one.
The verdicts still come to me. The agents generate findings and I decide what they mean, and I do not expect that to move.
Gates that earned their place
Every automated check in my pipeline is there because something bit me once. Lint, typecheck, a security scan, and a couple of project-specific checks that would sound strange anywhere else but exist because a specific deploy broke a specific way. The pre-commit chain on this site started with four checks and has grown to nine, each one added after something went wrong.
So my test for adding a gate is whether it maps to a failure that actually happened. Speculative gates rot, and the earned ones get maintained because you remember the bite.
When an agent's change passes the gates it has cleared the floor, and the bar is somewhere above that. Gates catch the known failure modes and the review catches the new ones.
What I refuse to automate
The reading. The line holds most days, and the days it bends are worth describing too.
I will let agents write the code, run the tests, draft the commit message, and argue with each other about the diff. The standard I hold for myself is that I read what ships, and most of the time I meet it. I am not going to pretend it is absolute. There are changes I end up verifying mostly through testing. I run the suite, I exercise the real behavior, I watch it work, and I read the shape of the diff without tracing every line. A mechanical sweep across forty files, generated test coverage, a migration I have watched succeed before. I am not recommending any of that, only describing what a high-volume day looks like when the writing gets ahead of the reading.
The direction does not move, and there is always a lot of code to review, so reading is the thing I protect first and give up last. When the reading stops you can feel the mental model of the system drift, and a senior engineer running on a stale one is a slow junior with better stories.
The review is where I stay current with my own codebase, and handing that away is handing away the job.
Where this fits
This workflow is one loop inside a larger working method of specify, delegate, verify, record. I wrote the full manual in The AI-Assisted Engineering HOWTO, and the argument for why this is a discipline and not a shortcut in AI-Assisted Development Is Not Vibe Coding. If agent mode is still a fuzzy term, start with What Is Agent Mode? When the agents start reviewing the systems that build the systems, that is Recursive DevOps, and it is closer than it sounds. The tool you run all this in matters less than the discipline, but if you are weighing them, Claude vs Copilot for DevOps is my take.
The longer argument is the book: AgentSpek, free to start reading here.
Related reading: AgentSpek, chapter 9: Quality in the Age of Generation.