AI Scaled the Writing. Review Is Still One Person.
Watch the video version:
More pull requests, more design documents, more proposals: AI is producing work faster than your team can read it. The worry under that is easy to name. Something is going to ship that nobody really looked at.
At a roundtable in New York last month, one technology leader said their team now turns out so many AI-assisted documents that they can't keep up reviewing them: "I have like ten other documents to review in front of this." Another attendee's answer was an agent that watches what they accept and change in their reviews, and learns from it. A third runs work through one model and has a second model try to find the holes. Those are their accounts of their own teams, and the agent is the fix most leaders reach for first: train the AI on the reviewer.
An agent trained that way learns your verdicts. A verdict is approve, send back, or a comment on a line. What it doesn't carry is the list behind it.
Here is mine, in the order I check it. Does the code match the ask, with nothing extra? Is there reuse where there could be? Is this the simplest solution to the problem given? Coding standards I expect automated tools to have enforced before I ever see it. Then: what happens under load? What side effects could it have on other parts of the application? What security concerns does it raise? Last, I go back to the original request and ask whether we should be doing this work at all.
That is eight checks. A tool runs one of them. The other seven live in a reviewer's head, and a system leans hardest on whoever is most constant inside it. As AI adds output, every review that needs those seven waits on that person. When someone reviews in their place, they check what shows in the code, and the misses come from the checks that don't. In the teams I work with, those misses happen all the time.
The same limit applies to the agent. It learns the checks that show in the diff: the extra function, the duplicated code, the solution with three more moving parts than it needed. Load, side effects, and security rarely show there, and whether the work should exist never does. The agent can ask why, though. Every time a reviewer changes something or sends it back, it can ask for the reason, and the answers can be written beside the check they belong to. Reasons are what make a list usable by someone who isn't you.
The last check is the one no diff will ever teach. A product owner once directed a feature that went against how the system works and would have hurt the people using it. My team commented on it in Jira and kept working on it. I stopped it. The check worked; my team ran it and wrote it down. Nobody who ran it could stop the work. Only I could.
So sort your checks by who can run them:
- Automated: standards, formatting, anything a tool enforces before review.
- Anyone holding the list: matches the ask, reuse, simplest solution.
- Context needed: load, side effects, security. This is where an agent asking why earns its place, and where the answers get written down.
- Authority needed: should we be doing this work. This one gets a named owner who can stop it, not only comment on it.
When I hired a dev manager, I gave him the list in his first weeks, and he wrote it down. I am out of that review loop now, and I am not sure the rest of the team has the list. A list handed to one person is still one person.
Here is the test. Who on your team can stop a feature the team has already flagged? If the answer is only you, you handed off the queue, not the review. Write the four buckets this week, put a name beside the last one, and give the list to everyone who reviews.
TeamOS™ is the installation for writing down how your team actually decides, review included, so it runs without you: https://TeamOS.Coach
Ninety business days from an empty binder to version 1.0 of your team's own operating system: written down, distributed, and acknowledged.
