Most advice about iterative prompting stays abstract. People tell you to "refine your output" or "give feedback to the model," but they rarely show the actual exchange that moved a draft from unusable to shippable. The mechanics live in the specifics: which instruction you added on the second pass, what you removed, how you reframed the failure so the model could correct it.
This article walks through six concrete loops pulled from real agency work across copywriting, code, analysis, and design feedback. Some succeeded in two turns. Some spiraled for ten turns and never recovered. The contrast is where the learning is. For each one we name the starting prompt, the problem with the first output, the refinement move, and why it worked or didn't.
Read these less as templates and more as a pattern library. The point is to recognize the shape of a productive loop so you can run one yourself when the first answer disappoints.
Example 1: Tightening a Vague Marketing Brief
The Starting Point
A strategist asked for "a positioning statement for a B2B logistics SaaS." The first output was generic—"streamline your supply chain with cutting-edge technology." Technically on topic, completely interchangeable with any competitor.
The Refinement Move
Instead of saying "make it better," the strategist added a constraint that exposed the failure: "Rewrite this so it could only describe this company and no competitor. The differentiator is same-day rerouting during port delays." The second output named the specific pain and the specific capability.
Why It Worked
Vagueness in the output almost always traces back to missing constraints in the prompt. The loop succeeded because the refinement supplied the discriminating detail the first prompt withheld, not because the instruction to "improve" carried any information.
Example 2: Debugging a Function That Looked Right
The Starting Point
A developer asked for a function to deduplicate records by email. The code ran but silently dropped records with uppercase variations of the same address.
The Refinement Move
Rather than describe the bug in prose, the developer pasted the failing input and the wrong output back into the conversation: "Given these three rows, your function returns two. It should return one. The emails differ only in case." The model immediately added normalization.
Why It Worked
Showing the model the exact discrepancy between expected and actual output is far more reliable than narrating it. This mirrors the discipline covered in Case Study: How a Three-Person Team Rebuilt Their Editing Workflow Around Refinement Loops—concrete evidence beats description every time.
Example 3: The Loop That Spiraled
The Starting Point
A copywriter wanted a landing page headline and kept saying "punchier," "more energy," "still not quite there" across eight turns. Each output drifted further from the brand voice.
What Went Wrong
"Punchier" is a direction without a destination. The model had no fixed target to converge on, so each turn was a guess. The loop never terminated because there was no stopping condition.
The Recovery
The copywriter finally pasted two headlines they admired and said "match this register, this length, this level of specificity." Convergence happened in one turn. The lesson: a loop without a defined target is a random walk.
Example 4: Structured Analysis From a Messy Dataset
The Starting Point
An analyst asked for "insights" from a churn dataset summary. The first output listed obvious correlations everyone already knew.
The Refinement Move
The analyst constrained by surprise: "Skip anything an experienced ops lead would already assume. Surface only counterintuitive findings, and flag your confidence level for each." The second pass produced two genuinely useful observations and honestly labeled them as tentative.
Why It Worked
Asking the model to filter against the user's existing knowledge turns a generic summary into a differential one. The confidence flag also made the output safe to act on, a theme explored in Which Numbers Tell You a Refinement Loop Is Actually Healthy.
Example 5: Refining Tone Without Losing Substance
The Starting Point
A consultant needed a client email softened after a missed deadline. The first draft was either too apologetic or too defensive on each attempt.
The Refinement Move
The consultant separated the two axes: "Keep the factual content exactly as is. Change only the tone to accountable-but-not-groveling. Do not add new commitments." Isolating tone from substance stopped the model from inventing new promises.
Why It Worked
When you don't constrain what should stay fixed, the model rewrites everything. Naming the invariant—"keep the facts, change only the tone"—is one of the highest-leverage moves in any refinement loop.
Example 6: Knowing When to Stop
The Starting Point
A designer iterated on alt-text descriptions for a gallery and could have kept polishing indefinitely.
The Refinement Move
They set an explicit good-enough bar up front: "Stop when each description is under 125 characters, names the primary subject, and avoids the word image." Once the output met the bar, the loop ended.
Why It Worked
Defining "done" before you start prevents the diminishing-returns spiral from Example 3. A good loop has both a target and a termination test.
Example 7: Salvaging a Loop With a Restart
The Starting Point
A researcher asked for a literature summary, and the model latched onto a wrong assumption in turn one—it treated the topic as clinical when the intent was economic. Every subsequent turn inherited the error.
The Refinement Move
After three turns of trying to correct the framing in place, the researcher abandoned the thread entirely and opened a fresh conversation with one added line up front: "This is an economics topic, not a medical one." The new thread produced a usable summary in a single pass.
Why It Worked
Some failures are not surface defects you can patch; they are contamination baked into the thread's context. When the model has anchored on a wrong interpretation, restarting beats fighting it. Knowing which situation you are in is the whole skill, as laid out in Iterate, Restart, or Rewrite the Prompt When Output Disappoints.
Example 8: Refining a Prompt Instead of the Output
The Starting Point
A marketer needed product descriptions for fifty SKUs. The first description was decent, but refining each of fifty by hand would defeat the purpose of using AI at all.
The Refinement Move
Instead of iterating on the output, the marketer iterated on the prompt itself using one SKU. Once a prompt reliably produced a good description for the test SKU—after three rounds of constraint-tuning—they applied that fixed prompt across all fifty with no per-item refinement.
Why It Worked
When you need volume, the object to refine is the prompt, not each output. A few rounds of loop investment on one example pays off across the whole batch. This is the inverse of the one-off loops above, and it is worth recognizing which situation you are in before you start.
What These Examples Have in Common
The Productive Pattern
Across the successful cases, the same moves recur: supply the missing constraint, show the discrepancy rather than describe it, name the invariant, and define done before starting. None of these required clever wording—just specificity about what was wrong and what good looks like.
The Failure Pattern
The failures shared one trait: a vague direction with no destination. "Punchier," "better," "more energy"—each gave the model a vector but no target, so the loop became a random walk. Recognizing this pattern early is what lets you stop and rediagnose before you have burned ten turns.
Frequently Asked Questions
What separates a productive refinement loop from an endless one?
A productive loop has a defined target and a stopping condition. The spiraling examples failed because "better" and "punchier" gave the model nothing to converge on. The moment you supply a concrete reference or a measurable bar, loops tend to resolve in one or two turns.
Should I tell the model what was wrong, or show it?
Show it whenever you can. Pasting the failing input alongside the wrong and expected output corrects errors far more reliably than describing the problem in prose, as Examples 2 and 4 demonstrate.
How many turns is too many?
There is no fixed number, but if you are past three or four turns without measurable convergence, the problem is usually the prompt, not the model. Stop, diagnose what target is missing, and restart with that constraint rather than adding another vague nudge.
Why does naming the invariant matter so much?
Models rewrite whatever you don't pin down. If you only say "change the tone," substance drifts too. Stating explicitly what must stay fixed keeps the refinement surgical instead of wholesale.
Can these examples transfer across domains?
Yes. The underlying moves—supply the missing constraint, show the discrepancy, name the invariant, define done—apply equally to code, copy, analysis, and design. The domain changes; the loop mechanics don't.
Key Takeaways
- Vague output usually signals a missing constraint in the prompt, not a model limitation; supply the discriminating detail.
- Show the model the gap between expected and actual output instead of describing it.
- Loops without a defined target become random walks; provide a concrete reference to converge on.
- Name what must stay fixed so refinement stays surgical rather than rewriting everything.
- Set a good-enough bar before you start so you know when to stop iterating.