The problem
Who wrote the passing test?
When an agent writes the code and the test that approves it, both can share the same mistake. Freeze the target before the work starts, then let a judge outside the loop check the result.
Walk through your actual week.
The agent said done. It wrote the tests. The tests passed. You skimmed the diff, it looked reasonable, you merged. Three days later the bug report comes in from someone who isn't you.
Nobody lied. The agent that wrote the code also wrote the test that graded the code, then reported the result. Of course it passed.
The target wasn't there before the throw. It was drawn around wherever the dart landed, and called a bullseye.
A better model just paints a straighter circle around the same dart. That is the whole failure mode, and it has nothing to do with how good the throw was.
How an AI coding loop can fall into this
Not a bug in one tool. A structural default in how the whole category is built.
One actor writes the code
The same agent that produces the diff also produces whatever grades the diff: a test, a self-review, a summary of what it did.
It writes the test that grades it
Nothing external constrains what "done" means before the work starts. The target gets defined after the throw, by the thrower.
It reports the result
"All tests pass," from an AI, means the AI checked its own work. That isn't verification. It's a target drawn after the dart lands.
Most tools let the thrower paint the bullseye around the dart after it lands.
You didn't fail to review the diff carefully enough.
The structure let the same actor write the code and grade it. No amount of attention fixes an architecture problem. You can read every line of a diff and still have no way to check whether the test it shipped with was ever capable of failing.
The agent wasn't lying, either. It believed the tests it had just written, because it had just written them. That's not a character flaw in the model. It's what happens whenever the actor doing the work is also the actor scoring it, with a person, or without one.
This gets worse, not better, as the models improve. A model ten times more capable than today's is still the actor grading its own work if nothing outside it checks. A smarter thrower doesn't need a worse target. It needs a judge, watching harder throws.
A judge outside the loop.
Reports come from the worker. Verdicts come from a judge. A judge doesn't help you throw. It doesn't touch the dart. It watches where it lands, and it has no reason to lie about it, because it never picked up the dart in the first place.
Take every model credential off the machine and not one verdict changes.
Ranex does not improve aim.
Not by one degree. It doesn't write better code. It makes a miss visible and cheap, and a hit provable. Ranex is pre-release: the kernel has a working verdict path and very little else, and the repository says so first.