When the first AI output falls short, you face a fork that most people navigate by reflex. You can keep iterating in the same loop, abandon the conversation and restart fresh, or step back and rewrite the original prompt before regenerating. These three moves feel interchangeable in the moment, but they have very different costs and payoffs depending on the situation.
The reason this matters is that the wrong choice wastes the most time precisely when you can least afford it. Iterating on a fundamentally misframed prompt produces ten turns of polishing a wrong answer. Restarting when you were one constraint away from done throws out useful context. Knowing which move fits which situation is the difference between a five-minute loop and a forty-minute slog.
This article lays out the three approaches, the axes that distinguish them, and a decision rule you can apply on the spot. It complements the structural view in The Draft-Diagnose-Constrain Method for Iterative Refinement Loops.
The reason this fork deserves its own treatment is that it is invisible to most people until it is named. They feel a disappointing output, reach for whatever move is most familiar, and never notice that two other moves existed. Making the three options explicit is half the battle; once you can see all three on the table, choosing well becomes a matter of reading the situation rather than acting on reflex.
The Three Moves
Keep Iterating
You stay in the same conversation and run another Diagnose-Constrain turn. This preserves all the context the model has accumulated and is the cheapest move when the output is close.
Restart Fresh
You abandon the thread and begin a new conversation, often with a sharper prompt. This sheds accumulated confusion when the model has anchored on a wrong interpretation that you cannot dislodge.
Rewrite the Prompt
You step back and rebuild the original instruction—adding the constraint or example you now realize was missing—then regenerate from scratch. This fixes structural problems that no amount of in-loop refinement will reach.
The Axes That Matter
Distance to Target
How close is the current output to what you want? If it is one specific defect away, iterate. If it is fundamentally the wrong shape, iterating will only sand a misshapen object. Distance is the single most important axis.
Cause of the Defect
Is the problem a surface issue (tone, a wrong fact, a clunky sentence) or a structural one (wrong framing, missing constraint, misunderstood task)? Surface defects respond to iteration. Structural defects demand a rewrite, because the flaw is baked into the prompt.
Context Contamination
Has the conversation accumulated confusion? In long threads the model sometimes locks onto an early wrong assumption and every subsequent turn inherits it. When you smell contamination, restarting beats fighting the thread.
Cost of Lost Context
Restarting throws away everything the model learned in the thread. If that context was expensive to build—a long brief, several useful clarifications—restarting is costly and iterating or rewriting is preferable.
The Decision Rule
A Simple Sequence
Ask three questions in order. First: is the defect structural? If yes, rewrite the prompt—no loop will fix framing. Second: is the thread contaminated by a wrong assumption? If yes, restart fresh. Third: otherwise, is the output close on a nameable surface defect? If yes, iterate.
The Default
When in doubt and the output is close, iterate—it is the cheapest move. But override that default the moment you notice a structural defect or a contaminated thread, because iterating through either is the slowest path of all. The spiraling sessions in Six Refinement Loops That Turned Mediocre AI Output Into Shippable Work were all cases of iterating when a rewrite was needed.
Common Mismatches
Iterating Through a Structural Flaw
The most expensive error. You keep nudging an output whose entire framing is wrong, because each turn looks like progress. The tell: you are on turn five and the core problem hasn't moved. Stop and rewrite.
Restarting Too Eagerly
The opposite error. You abandon a thread that was one constraint away from done, losing context you will have to rebuild. The tell: the defect was nameable and surface-level, and you restarted anyway.
Rewriting When Iteration Would Do
Over-engineering. You rebuild a careful prompt when a single Diagnose-Constrain turn would have fixed the tone. Reserve rewrites for genuine structural problems, a judgment informed by the metrics in Which Numbers Tell You a Refinement Loop Is Actually Healthy.
Walking the Decision Through Real Cases
A Case for Iterating
You asked for a product description and the output is solid except the tone is slightly too casual for a luxury brand. The defect is nameable and surface-level, the thread is clean, and you are one constraint away. This is a textbook iterate: pin the facts, adjust the register, regenerate once.
A Case for Restarting
You asked for a competitive analysis and the model decided in turn one that your product was a consumer app when it is enterprise software. You corrected it twice, but every turn still leaks the consumer framing. The thread is contaminated. Open a fresh conversation, state the category up front, and the confusion clears in one pass.
A Case for Rewriting
You asked for a blog outline and it is structurally wrong—too broad, aimed at the wrong reader, missing the angle entirely. No nudge fixes framing this deep. Step back, add the missing constraints to the original prompt (audience, angle, scope), and regenerate from a corrected foundation.
Reading the Pattern
In each case the right move follows directly from the cause of the defect, not from instinct or habit. The discipline is pausing for the half-second it takes to ask which kind of failure you are looking at before you act.
The Cost of Choosing Wrong
Time Is the Real Currency
Every wrong choice converts into wasted minutes. Iterating through a structural flaw can burn ten turns; restarting unnecessarily forces you to rebuild context; over-rewriting turns a thirty-second fix into a five-minute one. The decision rule exists to minimize total time-to-acceptance, the metric that actually matters and the one tracked in Which Numbers Tell You a Refinement Loop Is Actually Healthy.
Build the Reflex
At first, consciously running the three-question sequence feels slow. With practice it collapses into a reflex: you glance at a disappointing output and the cause—surface, contamination, or structure—is usually obvious within seconds. The goal is not to deliberate every time but to train the instinct so the right move becomes automatic.
Frequently Asked Questions
What's the single biggest factor in this decision?
Distance to target. If the output is one nameable defect away, iterate. If it is fundamentally the wrong shape, no amount of iteration will fix it, and you should rewrite the prompt instead.
How do I tell a structural defect from a surface one?
A surface defect is a tone, a clunky sentence, or a wrong fact—fixable with a targeted instruction. A structural defect is wrong framing or a missing constraint baked into the prompt. If the flaw would persist no matter how you nudge, it is structural and needs a rewrite.
When is restarting the right move?
When the thread has accumulated a wrong assumption you cannot dislodge. If every turn inherits the same misunderstanding, a fresh conversation with a sharper prompt clears it faster than fighting the contaminated thread.
Isn't iterating always the safe default?
It is the cheapest move when the output is close, so it is a reasonable default. But it is the slowest possible path when the defect is structural or the thread is contaminated. Override the default the moment you spot either.
How many turns before I abandon iteration?
If you are past three or four turns and the core problem hasn't moved, the issue is structural. Stop iterating, rewrite the prompt with the missing constraint, and regenerate.
Key Takeaways
- Three moves compete when output disappoints: keep iterating, restart fresh, or rewrite the prompt.
- Distance to target and cause of defect are the decisive axes; structural flaws need a rewrite, surface flaws an iteration.
- Restart when the thread is contaminated by a wrong assumption you cannot dislodge.
- The default is to iterate when output is close, but override it the instant you spot a structural defect.
- Iterating through a structural flaw is the most expensive and most common mistake.