I never let the AI that wrote the code review the code

I do not let the same AI session that wrote a piece of code review that code. Not because I distrust the tool. Because ten minutes after writing something, it is defending a decision it just made, not examining one with fresh eyes. The justification for a choice and the blind spot behind that choice come from the exact same place in that moment.

The rule I run instead: a different agent reviews it. No memory of the conversation that produced the change. Just the diff, and the instruction to find what is wrong with it, not to confirm it looks fine.

Here is what that rule actually caught. One of my own backup monitoring scripts shipped without going through this step. It reads the result of a scheduled Windows task by parsing PowerShell output, and its whole job is to alert me if the last backup failed.

A fresh review agent, with no context on why the parsing logic looked the way it did, found this: if the PowerShell output ever comes back garbled instead of clean, the parsed result becomes NaN. And in JavaScript, NaN !== 0 evaluates to true. The script would have reported a backup FAILURE on a run that had actually succeeded, purely because the output it was reading got mangled in transit.

That specific failure mode matters more than it looks. A monitoring script that cries wolf on a clean run is not a minor bug. It is the exact mechanism that teaches you to stop trusting the alert. A few false FAILURE messages and the real one, when it eventually comes, gets ignored along with the noise.

The fix was one line: if the parsed result is not a valid number, report nothing rather than guess. Silence on an ambiguous read beats a confident wrong answer.

I would not have caught this reading my own code. I wrote the parsing logic with a specific picture in my head of what the PowerShell output should look like, and that same picture was standing directly in the way when I went back to check my own work. You do not review past your own assumptions by reading harder. You need eyes that never had the assumption in the first place.

The honest caveat, because it matters: this is not true independence. It is the same underlying model, reviewing with a fresh prompt and no conversation history. That is distance, not a different mind. It is still the best cheap approximation of a second pair of eyes I have found, and on this one script, it found a bug that would have quietly trained me to ignore my own alarms.