What happens if you keep making an AI check an algorithm that has been mathematically proven correct? The answer from Taelin (@VictorTaelin), the developer who created the HVM and Bend programming languages, was not what anyone expected. He posted the question on X in the early hours of August 9 (3:30 a.m. Korea time), and reported that perfect code broke within a few passes of the loop. The post drew 58,000 views, 84 reposts, and about 1,300 likes, and spread quickly through the developer community. You can read the original post here.
Keep Auditing "Correct Code" with AI, and What Happens?
Taelin's experiment was simple. He paired GPT-5.6 Pro (the top model in OpenAI's GPT-5.6 family, released in July 2026) with Fable 5 (the codename for the latest Claude-family model Anthropic introduced in June of that year) and ran the following loop repeatedly.
- Step 1: GPT-5.6 Pro audits the algorithm code and looks for bugs.
- Step 2: Fable 5 fixes the bugs GPT pointed out.
- Step 3: Repeat the process.
The catch was the trap. The algorithm he fed into the loop was code already proven correct, a literal "right answer". He ran the audit-and-fix loop on code with no bugs to fix. The result was a complete collapse. Within the first few passes the correct algorithm turned into an incorrect one, and later passes kept "patching" that wrong version. Those patches kept creating new cases and new bugs. Taelin said the process didn't stop until the code was completely destroyed.
Why Does Correct Code Look Like a "Bug"?
The principle Taelin pointed to is clear. When you ask an LLM to "audit this code," the model is really answering the question "Does this code contain patterns that look like bugs?" The problem is that many code patterns look like bugs while being perfectly correct. And "fixing" something that's already right only makes it wrong.
| Item | Patterns that look like bugs | Actual bugs |
|---|---|---|
| Basis for judgment | Unfamiliar structures, unidiomatic branches | Runtime results diverge from the spec |
| LLM's reaction | Flags "needs a fix" | The fix actually improves correctness |
| Result in the loop | Turns correct code into incorrect code | Turns incorrect code into correct code |
What makes the experiment interesting is that Taelin didn't end on pessimism like "LLMs can't see code." He predicted that as models get smarter, the gap between "looks like a bug" and "is a bug" will narrow until the two coincide in nearly 100% of cases. He added, "I think we're getting pretty close to that point, and it will be interesting when the error rate gets low enough that these loops start to actually work." His conclusion, though, is that "as of 2026, we haven't gotten there yet."
What Developers Building Auto-Review and Auto-Fix Pipelines Should Watch For
If you're designing a pipeline that hands code review and fixes to agents, this experiment is more than a curiosity. The intuition that "letting an AI audit and fix another AI's code improves quality" can, as this case shows, work in exactly the opposite way when applied repeatedly to code that's already verified. Here are some practical points to check.
- Don't set up an endless loop. A design that repeats audit and fix "until there are no findings" always leaves open the chance that the model will invent something to flag. Set the exit condition on objective criteria like passing tests and no regressions, not on the auditor going quiet.
- Verify regressions with a test suite before and after each fix. Without a safety net that checks whether existing tests break when you fix a "bug-looking pattern," it's hard for a human to notice a spiral where patches beget more patches.
- Consider excluding already-verified core logic from the audit loop. For code that has been proven, or has been battle-tested in production for a long time, rerunning an AI audit on every commit can become the risk.
- Don't assume using different models for auditor and fixer solves it. In Taelin's experiment, two different models (GPT-5.6 Pro and Fable 5) were used. You might expect that to cancel out bias, but the error rate of the judgment "this looks like a bug" itself can accumulate and make things worse.
A Personal Experiment, Not a Paper
This article's evidence is the result of an experiment Taelin described himself on X. It is not a reproducible study published as a paper or benchmark. Details such as the type of algorithm, the number of loop iterations, the basis for calling it "proven correct," and the prompt design aren't in the post, and there are no reports yet of a third party reproducing it under the same conditions.
Taelin is the founder of HigherOrderCO, which built HVM (a higher-order virtual machine) and Bend, a high-level language that runs on GPUs, and he has real achievements in programming languages and formal verification. He is also known for making strong public claims about LLM reasoning and running experiments to have them tested. In 2024, for example, he offered a $10,000 bounty, saying GPT-family models could never solve a certain reasoning problem (A::B), and the episode became controversial when other developers solved it with prompting alone within a day. This audit loop experiment should be viewed as a personal experiment in the same vein. The result is structurally convincing, but there isn't yet enough basis to claim that "every audit loop works this way." Before putting an automated audit-and-fix pipeline into production, treat this case as a warning sign and run a small-scale check on your own codebase and model combination first.