In October 2023 we published a trick on this blog. Inspired by the Chain of Density paper, we wrote prompts that told the model to draft, critique its own draft, write advice for improving it, and repeat until it could not do better. We called it iterative prompting, and it worked: the outputs were noticeably better, if slower. One of our production agents still carried the pattern years later.
You should not use it any more. This post explains why, and where the iteration actually went.
Why it worked in 2023
The models of that era had no plan. They generated text token by token, committed early to a path, and had no way to look back. Ask one to write exactly 200 words and it would fail, because it could only count the words once they were written, at which point it was too late. The self-review loop was a workaround: by forcing the model to re-read its own output, we gave it the second look it could not take on its own.
The models absorbed the loop
Reasoning models do internally what our five-step prompt did externally. Before answering, they draft, reconsider, and revise; the deliberation we used to script now happens unprompted, in the model’s own working space.
This changes the advice we give. Our team’s experience over the past year is that reasoning models often do better with less instruction, not more: a minimal prompt pointed at the right material can beat a detailed list of analysis steps and output rules, because the model effectively prompts itself, and a pile of upfront scaffolding gets in the way. The 2023 trick has become a mild liability – you are paying, in tokens and time, for a loop the model already runs, and constraining it besides.
The judgement that remains, and it is a real one, is knowing when minimal works and when structure is still needed. That varies by task and by model, and the only reliable way to find out is to try.
Iteration didn’t die. It got delegated.
There is still a loop in our work; we just stopped sitting inside it. The pattern we now build into agents is this: do the task, check the result against a reference, improve the approach, check again – and keep going until the result stops improving for that cycle.
The word that matters is reference. The 2023 loop asked the model to judge its own work by its own lights, which is better than nothing but circular. The loops we build now check against something external: the source text, a set of past examples, a measurable outcome, a specification of what good looks like. Our translation agent runs exactly this shape – one pass translates, a second verifies the translation against the original, and the result improves until the check passes.
One craft note from production: how you phrase the check matters. Asking a model to score a result out of ten works poorly, because language models handle numbers badly. Asking it to judge which of two versions is more faithful, more readable, more on-brief works remarkably well. Build your references around comparisons, not arithmetic.
The human contribution moved accordingly. We no longer write the nudges; we define the reference the loop runs against. That is a harder job, and a more valuable one.
The iteration that stayed human: context
The other place the effort went is before the prompt entirely.
What separates a useful answer from a plausible one is rarely the phrasing of the request. It is what the model knows when it receives it: who the audience is, what the organisation sounds like, what must never be invented, what happened last time. That knowledge does not arrive in a clever prompt; it accumulates. Every engagement, every correction, every decision recorded adds to a body of context that makes the next answer better than the last.
So the iterating we do with humans now happens at that level. Not “rewrite this paragraph again”, but “the agent got this wrong – what was missing from its context, and how do we make sure it is there next time?” Each cycle improves the environment rather than the utterance, which means the improvement compounds instead of evaporating when the conversation ends.
Your organisation already produces this material – the documents, the decisions, the conversations. The work is connecting it, structuring it, and letting the loops run against it.
What survived
Rereading the 2023 post, one line holds up: the point was never to accept the first result. That instinct was right; only the mechanism aged. The models took over the redrafting, the loops took over the checking, and the human effort moved to the two places it still pays – defining what good looks like, and building the context that lets a machine recognise it.
Iterate there. The models will handle the rest.
Originally published 17th October 2023; rewritten July 2026. The original described a self-review prompt pattern that reasoning models have since made redundant – this version records what replaced it.
Leave a Reply