When to Throw Away AI Code and Start Over

The most expensive mistake in AI-assisted development is not writing a bad prompt. It is refusing to throw away what the bad prompt produced. Once an agent goes down a wrong path, the sunk-cost instinct kicks in and you start patching, nudging, adding one more instruction to fix the mess. That path almost never converges. The move that actually saves time is to delete the output, reset the context, and start clean with what you learned. Knowing when to do that is a skill, and it is worth more than any prompting trick.

Restarting feels like failure and it is the opposite. Every attempt teaches you something about the task: where the ambiguity was, what constraint you forgot to state, which edge case the agent missed. A restart lets you fold that learning into a clean run. A patch just piles fixes on a foundation that was wrong to begin with, and the pile gets more fragile with each addition.

The signals that mean stop patching

There is a recognizable set. The first is the fix-and-break loop: you correct one thing, the agent breaks another, you correct that, the first thing comes back. When you are on your third round of whack-a-mole, the code is fighting you, and no fourth correction will win. Delete it.

The second is architectural wrongness. If the agent chose the wrong overall approach, no amount of local editing turns it into the right one. You cannot patch a bad structure into a good one; you can only rebuild on a better one. The third is a diff you no longer understand, where the agent has piled on enough attempts that you cannot say what the code does anymore. Unreviewable code is unshippable code, as I argue in reviewing AI-generated pull requests, and if it got unreviewable through patching, patching more will not save it.

The fourth signal is subtle: the agent keeps reintroducing bugs you already fixed. That means the context is polluted with its own failed history, and it is pattern-matching on its mistakes. That is a context problem, and the fix is a reset, which I cover in context window management for AI coding.

Why restarting beats debugging here

With human-written code, debugging usually wins, because the author understood the intent and the bug is a local slip you can find and fix. With agent-written code that went wrong, the "bug" is often not local, it is a wrong interpretation spread through the whole attempt. Debugging a spread-out misunderstanding is slower than restating the intent and running again.

There is also a cost asymmetry that favors restarts specifically with AI. Regenerating is cheap and fast. The agent will produce a fresh attempt in seconds. So the break-even point for "should I just restart" is much lower than it is for human code, where regenerating means someone rewrites it by hand. When the thing you would throw away can be remade in a minute, you should throw it away far more readily. This is part of why demo-to-shippable is the real gap: cheap generation changes the economics of when to cut losses.

Restart clean, not warm

A restart only helps if it is actually clean. Do not just tell the agent "no, try again" in the same session, because the failed attempt is still in the context, still steering it toward the same mistake. Clear the context. Take what you learned, fold it into a sharper spec and tighter acceptance criteria, and start the agent fresh with only that.

This is where the failed attempt pays off. Each dead end tells you exactly which constraint to add. The agent tried to use a library you do not want: state the library now. It misread the empty case: write that as a criterion now. A good restart is not the same prompt again, it is a better prompt built from the last one's failure, which is the planning-first discipline closing the loop. Getting good at this is one of the highest-return habits in the whole practice, which is why the workflow we build at Bootspring makes reset-and-restart a first-class move instead of an admission of defeat.

Set a mental limit before you start: two, maybe three corrections, then reset. When you hit it, delete without ceremony. The code was free to make and it is free to remake. What is expensive is your hour, and patching a doomed attempt is the fastest way to spend it.