You ask the assistant to take one more look at a file you already know works, and it never comes back empty-handed — there is always one more thing it wants to change. Left alone, that habit costs you a moment’s review. Wired into a team’s pull-request pipeline, it costs more: Cursor’s Bugbot now spawns a cloud agent that autofixes issues it flags in a PR diff, with no failing test required to set it off. A study posted 9 September 2026, “If It’s Not Buggy, Don’t Fix It” , shows what happens once nothing external tells a model when to stop looking: it starts finding bugs that aren’t there, and repairing them makes the code worse, not better.
The loop that fixes nothing still claims something was wrong
The researchers — Xietao Wang-Lin of the University of Warwick, with Anton Isopoussu and Louis Mahon of UnlikelyAI — took 800 working C++ submissions from the CodeContests+ benchmark, 20 problems with 40 correct solutions apiece, and simply told two models to fix them. No test result, no error trace, nothing indicating a fault existed. The models found one anyway, consistently, and set about repairing it. Across configurations, the rate at which a “fix” broke previously working code ran as high as 0.424, against a repair rate — code genuinely improved — as low as 0.003. In one single-edit configuration, Qwen2.5-7B-Instruct’s repair rate was 0.041 while its damage rate held at 0.424 — it broke roughly ten working programs for every one it actually repaired, cycling through the identical change, added then removed — what the paper calls a “pseudo-bug-fixing cycle.”
The value in a repair loop lives in the verification signal, not in the model's judgment about the code.
Self-repair works — but only when a failing test is doing the deciding
The honest complication is that iterative self-repair is not, in general, a bad habit. In an April 2026 study, Johin Johny Arimbur tested seven models — from Llama 3.1 8B up to Gemini 2.5 Pro — across HumanEval and MBPP, feeding each attempt’s real execution error back for up to five tries. Every model improved: +4.9 to +17.1 percentage points on HumanEval, +16.0 to +30.0 points on MBPP, and none got worse. Gemini 2.5 Flash reached a 96.3% pass rate. Cursor, for its part, reports Bugbot’s resolution rate climbing from 52% to 76% over six months and says the tool is now “catching more bugs and flagging fewer false positives” — though that claim comes with no published methodology, and Wang-Lin’s team tested only two small-to-mid models, not the frontier systems shipping products actually run. The difference between these two results isn’t the technique. It’s whether the loop is anchored to something the code actually did wrong.
The urge to edit lives in the model, not in the code
What makes this more than a benchmark quirk is the mechanism underneath it. Probing Qwen2.5’s internals, the researchers located a representation, at layer 22, that predicts with near-perfect accuracy whether the model is about to claim it found a bug — and that signal fires whether or not a bug is actually present. Turning it down with negative steering stopped the pseudo-bug-fixing cycles outright. The study measured this in single-file edits on 38-to-42-line C++ submissions, using two models well short of frontier scale; it did not measure how the same mechanism behaves inside a multi-file production repository. Read across to the tools already running unanchored review loops, though, the finding suggests that the editing urge Bugbot autofixes on is a property of the model being asked to look — not a signal coming from the code it’s looking at. Cursor’s own documentation describes Autofix spawning an agent from a flagged diff, with no mention of a failing test as precondition, which is exactly the unanchored shape the study warns about.
That has a concrete cost for whoever sits at the end of the pipeline. If your team has an AI reviewer wired to open fix branches on every pull request, you are now reviewing patches written against code that was already correct — and the system that proposed the patch is the same one that decided there was a problem in the first place. That’s a close cousin of the finding that the plan-style explanations users prefer produce nearly triple the false alarms of a plain trace : confidence and correctness are not the same output, whether the artifact in front of you is a plan or a patch. It also sits oddly next to Wealthfront’s own reviewer, tuned specifically to say nothing on most pull requests — proof that restraint is achievable, just not the default a tool reaches for on its own. None of this is an argument against AI-assisted repair; the April study’s seven-model, zero-regression result is too clean to wave away. It’s an argument for building the check into the harness rather than the model’s discretion — because a repair loop with no brakes doesn’t coast to a stop, it just keeps finding something to fix.
