AI code review: agents verify, humans decide

Traditional code review, the kind that forces a senior to read every line of a pull request, is numbered. The news at hand describes how the Aviator team has redesigned the process so that AI agents verify and humans decide. At ForgeNEX we see it as an opportunity for SMBs that develop software: less time wasted on mechanical reviews and more focus on what really matters.

The problem: AI reviews without knowing your standards

Many teams already point a model at the diff and ask it to say whether the change is good. The model reads every line without tiring and keeps the same criteria on every PR. But it doesn't know your code standards. It doesn't know what decisions were made before or why. And, above all, it can't be held accountable. As the news says: “Judgment needs intent, and accountability needs a person”.

The proposal: two layers and seven steps

Aviator proposes a review model based on two layers: acceptance criteria (what this change must do) and invariants (the team's permanent rules, always true). Without invariants, standards remain in the seniors' memory; without criteria, the agent can drift or solve the wrong problem.

The process is divided into seven parts:

1. Invariants: rules written once and checked on every change. They are extracted from the PR history, from CONTRIBUTING.md or from instructions to agents. Each draft goes through human approval.
2. Intent and acceptance criteria: captured from the coding session with the agent, not from a prior document.
3. Key decisions: the points where the change could have gone another way, tagging whether a human or an agent decided them.
4. Test plan: scenarios built from criteria and invariants.
5. Evidence: tests from a running environment that back each verdict.
6. Human review: the person approves or rejects based on intent, decisions and evidence, not on the code line by line.
7. Updated invariants: after the merge, they are refined with recurring exceptions and comments.

What does it mean for an SMB?

For a small team, line-by-line review is a bottleneck. Seniors spend hours reviewing trivial changes and neglect design or architecture. With this approach, agents handle mechanical verification (is the rule against writing directly to the users table being followed?) and people focus on what requires judgment: does this change make sense? Do we take on this risk?

In addition, generative AI makes systematic errors that repeat. Invariants act as a log of “slop” (junk code) that the team keeps correcting. That is gold for an SMB that can't afford to rewrite the same thing every week.

ForgeNEX recommendations

• Start with the most painful invariants: those rules you always end up commenting on in PRs. Write them down and automate their check.
• Don't delegate the final decision: AI can verify, but approval must be human. Legal and technical accountability is not delegated.
• Capture intent while you code: don't wait to write a document. Use the questions and answers from the session with the agent to generate acceptance criteria.
• Measure the impact: before implementing a system like this, define metrics such as review time, number of recurring comments or escaped defects.
• Train the team: developers must understand that their role changes: less mechanical review, more review of intent and decisions.

This paradigm shift fits with other trends we have already analyzed, such as the use of compilers as a safety net for AI agents (Hydro de AWS) or the need to choose the right AI model for the SMB (Jassy augura 6-8 modelos parejos). In all cases, the key is not to lose human control over what AI produces.

Line-by-line review doesn't disappear, but it transforms. Agents become tireless verifiers and people become judges with context. For an SMB, adopting this model can be the difference between scaling development or getting stuck in endless reviews.

Source: The New Stack. Analysis and adaptation: ForgeNEX.