How AI Code Review Quietly Turns Into Approval Theater
The team has been using the AI tool for three months. The outputs have been good. Not perfect, but good enough that the review process has quietly relaxed.
In the first month, every generated code block was reviewed line by line. In the second month, the review focused on the diff. By the third month, the review had become a glance: "Looks fine. Ship it."
Nothing dramatic happened. No meeting declared that AI output deserved automatic trust. The change arrived through shortcuts. Reviewers were busy. The generated code usually worked. Reading the same kinds of output over and over became tedious.
The Medallion of Unquestioning Trust is the artifact that makes this feel like progress rather than decay.
At first, the AI had to prove itself. Every output was suspect until somebody verified it. Over time, the burden flipped. The AI became trusted until proven wrong. That is a meaningful change in the team's operating model, even when nobody says it out loud.
The shift happens because humans are bad at sustaining vigilance around things that rarely fail. If a generated function is correct twenty times in a row, the twenty-first review feels unnecessary. The reviewer still knows that the tool can make mistakes, but the knowledge becomes abstract. The immediate pressure to finish the pull request feels more concrete.
"Has been fine" starts to feel like "will be fine."
Those statements are not equivalent.
Adaptive cruise control offers a useful comparison. The technology may work as designed, but a driver who stops watching the road is still exposed when conditions change. The danger comes from the relationship between the tool and the human, not only from the tool's failure rate.
AI code review has the same trap. A team can become less capable of spotting a problem precisely because the system has been reliable enough to reduce attention.
The decline is usually gradual. First, reviewers stop checking imports because the tool gets them right. Then they skim the error handling. Then they stop reading the tests because the tests look familiar. Eventually they read the commit message instead of the code.
If the commit message was also generated by AI, the review has become a summary of a summary.
That is the degenerate form of the Medallion: code enters production that no human on the team can explain. The process still contains a pull request, an approval, and a green status check. It looks like review from a distance. In practice, the organization has replaced understanding with ceremony.
This does not require the AI to be especially unreliable. A mostly correct system can create the conditions for careless review more effectively than an obviously bad one. If every output were dangerous, people would pay attention. Consistent, plausible output lets the habit weaken without creating an immediate crisis.
The fix is not to demand that every developer distrust every generated line forever. That would be exhausting and would probably fail. The fix is to preserve a minimum standard of understanding.
One useful rule is "Explain It." Before approving AI-generated code, the developer responsible for the change must explain what it does in their own words. They should be able to describe the inputs, the important branches, the failure behavior, and why the implementation fits the existing system. They do not need to recite every line. They do need to understand the behavior they are approving.
If they cannot explain it, the pull request goes back.
The rule does not assume the AI is wrong. It assumes that trust without understanding is not trust. It is abdication.
Teams can also make the review burden more honest. Mark generated code when that context matters. Require deeper review for security-sensitive paths, data handling, permissions, and infrastructure changes. Keep tests aimed at behavior rather than at whether the generated implementation looks tidy. Rotate reviewers so one person does not become the permanent rubber stamp.
A quick review is fine when the risk is low and the developer understands the change. A quick review because the tool has been right lately is a different thing.
The Medallion does not make the AI worse. It weakens the team's review process while making the team feel more efficient. That gap is where defects accumulate. The way out is not fear of the tool. It is a refusal to approve code nobody can explain.