Review and iterations: a workflow without slop

The psychology of the first answer

The biggest trap in working with AI isn’t in the model - it’s in the moment the first answer arrives. It looks finished: coherent, polished, on topic, neatly split into paragraphs. After a blank page it feels like a small miracle, and your hand reaches for “copy” all by itself.

Hold that hand back. Remember the mechanics from the previous lessons: to a request without details the model returns the weighted average, and the first answer is almost always exactly that - even with a good prompt, the model doesn’t yet know your refinements. The first answer is a version for discussion, not for publication.

Why does the first answer disguise itself as finished so convincingly? Because the model is flawless at everything that has nothing to do with quality: spelling, grammar, smooth transitions between paragraphs. In human writing, smoothness usually means someone worked on the text - and your brain carries that habit over to generations. Don’t. For a model, smoothness is the default property, like the font. Judge not “how it’s written” but “what it says” - and what the first answer says is usually the average.

Watch it play out in a real example. Request: “Write a post saying we’ve launched delivery.” The answer will be roughly: “Great news! We’re excited to announce that we’ve launched delivery. Ordering our products is now even easier and more convenient. Place your order on the website and we’ll bring it to you in no time!” Error-free? Yes. Slop? One hundred percent: it would fit any business on the planet - replaceability test failed.

Now the refined request: “Write a post for our coffee shop’s followers. Facts: we’ve launched delivery within a 3 km radius, we deliver ourselves by bike, so the coffee arrives hot within 20 minutes. Beans and desserts can be ordered too. First week - delivery is free. Tone - warm, neighborly, no exclamation-mark shouting.” The result is night and day - and you’re barely two minutes in.

The norm for a quality result is two to four passes. That’s not a flaw in the technology, that’s how the process is built: an editor works with an author the same way, and a client with a designer.

The anatomy of a prompt

Let’s break down what a working prompt is made of. Five elements, each with its own function and its own type of slop it prevents.

1. Role. “You’re an editor at a business publication”, “you’re an experienced head of sales”. Why: a role shifts the model from “the average of the whole internet” to “the average of a strong segment”. A letter from “an experienced salesperson” and a letter from “nobody” have a different vocabulary, a different structure, different emphasis.

2. Context. Who you are, who you’re writing for, what those people know and want, what data and circumstances you’ve got. Why: this is the only element the model can’t take from its training - your situation isn’t in there. No context, and the model fills the holes with the average - you get the “article for no one” from lesson three.

3. Task. What exactly to do and what should happen to the reader as a result: “after reading, they should want to book a free audit”. Why: a task without an outcome - “write about…” - produces a text for nothing.

4. Constraints. Length, tone, what not to do: “under 1,500 characters”, “no corporate-speak”, “no exclamation marks”, “don’t promise anything that isn’t in the facts”. Why: constraints cut off the model’s stock reflexes - peppy cliches, bloated intros, empty promises.

5. Example. A snippet of text you like: an old post of yours that worked, a fragment of someone else’s email with the right tone. Why: an example communicates the one thing that’s nearly impossible to describe in words - the voice. One good sample replaces a paragraph of explanations about a “friendly but not chummy tone”.

Not every task needs all five elements - for a quick edit, the task and constraints will do. But when the result matters, walk the full list.

Role: you are [who: an editor, a marketer, an instructional designer…].
Context: I am [who you are and what your product is]. I’m writing for [audience: who they are, what they know, what they want]. My facts and data: [numbers, cases, observations - everything specific you have].
Task: [what to do]. After reading, the reader should [action or takeaway].
Constraints: length [how long], tone [what kind], do not use [cliches, corporate-speak, exclamations…], do not invent facts - use only the data above.
Tone example - here is a text whose voice I like: [paste the fragment].
First show me a plan in 3-4 bullet points, then wait for my OK.

The last line of the template is a small trick with a big payoff: the model shows you a plan first, and you correct the direction before it writes a thousand words in the wrong one.

Productive iteration: an edit instead of “redo it”

Once you have the first answer, you tell the model what to change. This is where the taste from the last lesson shows up - in the quality of your wording.

“Redo it”, “don’t like it”, “make it more interesting” - garbage feedback. The model doesn’t know what “more interesting” means inside your head, so it just reshuffles the same average. You’ll get a different text with the same problems, get disappointed, and conclude that “AI can’t do it”.

Productive iteration is targeted: you name the spot, the problem, and the direction. “The first paragraph is filler - start straight from the second.” “In the third paragraph, replace the generalities with specifics: here’s the number - 9 out of 12 clients.” “The conclusion repeats the introduction - end with a call to sign up instead.” “The tone has drifted into ad-speak - bring back the conversational one, like in my example.”

Each such edit is an executable spec, and the model knocks it out in a single pass. Three targeted edits usually take a draft to “almost there”. Then comes the final check.

Iterations live: from draft to done in three edits

Let’s watch the full cycle play out on a real task: an announcement post for a free webinar for accountants.

The draft (after a prompt built on the anatomy). The model produced a coherent text, but the first paragraph is throat-clearing - “in today’s world it’s important for an accountant to keep growing” - and the call to action at the end sounds like “don’t miss this opportunity”.

Edit 1: “Cut the first paragraph entirely - open with the pain: the quarterly report eats three evenings. Replace the call to action with specifics: date, time, what the person will walk away with.” The model rewrites - the text comes back denser, but the middle is still generic: “we’ll cover useful tools”.

Edit 2: “In the middle, list three specific program items from my context: auto-importing bank statements, reconciliation in 20 minutes, a quarter-close checklist. One line per item.” Now you can see what’s worth registering for - but the tone has drifted into ad-speak in places.

Edit 3: “Cut the phrases about a unique opportunity. Tone - a colleague advising a colleague; compare against the example in my first message.” Done: three edits, eight minutes, and the text passes the replaceability test.

Notice: not one edit sounded like “make it better”. Each one named the spot, the problem, and the direction. That’s the whole secret - and it’s the taste from the last lesson in its purest form, put on the assembly line.

The review checklist: five questions before you use it

When the text feels done, run it through five questions. It takes five minutes, and it separates your work from slop more reliably than anything else.

1. Facts. Every number, name, date, quote, link - verified? The model invents things confidently and smoothly; everything checkable gets checked before publication, not after the screenshot in the comments.
2. Tone. Read it out loud. Does it sound like you - or like “dear valued customer, we are pleased to announce”? Rewrite the spots where you’d never say it that way.
3. The anchor detail. Is there at least one detail in the text that couldn’t be written about another product or another person? If not - add one: it’s the fastest way to bring a text to life.
4. The replaceability test. Substitute a competitor for yourself. Does the text still read as “correct”? If yes - bad sign: go back to the context and the raw material.
5. Adjectives. Mentally strike out the evaluative adjectives: “unique”, “innovative”, “high-quality”, “best”. Did the text keep its meaning? If the text was held up by adjectives - it was empty.

Passed all five - publish with a clear conscience. Failed one - you’ve just saved yourself a reputational incident at the cost of a single iteration.

A tip from practice: don’t keep the checklist in your head - put it where you can see it. A sticky note on the monitor, a pinned note, a template in your editor - anything, as long as the check fires automatically and not “whenever I remember”. A month in, the questions become a reflex and the sticky note can come down.

The process end to end

Let’s assemble the pipeline: a prompt built on the anatomy (role, context, task, constraints, example) - plan - draft - 2-4 targeted iterations - review checklist - publish. Sounds long on paper; in practice it’s 20-40 minutes for a text that used to take half a day. And the main thing: the result is reproducible. It’s not “got lucky with the generation today” - it’s a process that delivers stable quality on any topic.

One more consequence, which anyone working with contractors or a team will appreciate: this process is transferable. “Build the prompt from five elements, iterate with targeted edits, run the checklist” - that’s an instruction you can teach an employee in a day. Compare that with “well, it just sort of works for me” - a skill like that doesn’t scale and doesn’t sell.