Every coding agent has the same reflex built into it: a test fails, so the failing code and the error go back to the model with instructions to fix it. Almost every study of that loop compares it against a model that only gets one shot, which hides an obvious confound: trying a second time helps on its own, whether or not that try is informed by anything useful. This study adds the missing comparison, a "blind" retry that just asks the same question again with no mention the first attempt failed, and pits it against the usual fix-the-error loop.
On three small, locally-run coding models, the blind retry beat the standard repair loop outright at the two smaller sizes, and tied it at the largest. For the smallest model, showing it its own broken code before asking for a fix cost about six points of accuracy compared with asking it to try again from a blank slate, and that gap closed almost completely by the largest model tested.
More surprising is what didn't matter at all. Telling the model exactly what went wrong (which input failed, what it should have returned, what it actually returned) made no measurable difference next to a version only told, with zero detail, that its answer was wrong. The diagnostic information developers assume is doing the heavy lifting turned out to add nothing.
The explanation is that seeing its own failed code anchors a model onto small edits of that code, instead of a different approach. Shown its previous attempt, the model went on to write something close to identical to it on anywhere from a third to two-thirds of retries; asked fresh, with no memory of the failure, it did that only rarely.
"Shown its own code, the model edits; asked afresh, it reconsiders."
A follow-up check ruled out the simpler explanation that any extra text just distracts a small model: feeding it unrelated example code that had already solved a different task changed nothing. The cause is specifically seeing its own past mistake, not prompt length. Adding a step where the model writes out, in its own words, what went wrong before retrying eased the effect somewhat, but still didn't beat the blind retry, and cost several times as many tokens getting close.
"Measured against a no-repair baseline our feedback condition appears to gain 12.2 points at 1.5B; measured against blind resampling at matched budget it loses."
That line is the paper's real point. Most coding agents, including large frontier ones, are built around exactly the loop being tested here: fail, look at the error, retry with that error in view. This isn't an argument that error messages are useless in principle; it's a demonstration that almost nobody checks whether an error message helps more than simply trying again would, because the obvious control, a retry with zero information attached, is rarely run. A team building or buying an agent's "self-correcting" feature is often trusting a claim that, on this evidence, hasn't been tested against the cheap version of itself. That's a fair discipline to demand of any vendor's benchmark, not just this paper's.
For a team running smaller, local, or self-hosted coding models, the practical instinct is close to the opposite of the usual one: instead of accumulating context about what failed, throw the failed attempt away and start clean. The scope is narrower than the headline, though: the gap had already faded by the largest model tested, the tasks were single functions rather than changes across a real codebase, and most of the benefit of retrying at all showed up in the first couple of attempts. Retrying forever isn't the finding either.
Sources
- Verma, Y., "Try Again, Don't Look Back: Blind Resampling Outperforms Self-Repair in Small Code Models" — https://arxiv.org/abs/2607.26117