There’s a particular moment you’ll recognise if you’ve been using large language models seriously. You write a perfectly reasonable prompt. Clear context. Clean instructions. A well-formed question. You hit enter.
And the model responds with something that is… almost right. Not wrong enough to dismiss. Not right enough to trust. Just enough drift to make you wonder whether you’ve mis-specified something, or whether the system is quietly losing the thread. That ambiguity is the interesting part. Because it turns out, you probably didn’t do anything wrong.
I ran into this again, but in order to simplify things here is a simple scenario:
You’re baking a cake. It’s already in the oven. You realise you forgot to add sugar.
What now?
It’s not a trick question. It’s basic causality. A human doesn’t even pause: you take it out and fix it.
The model, on the other hand, starts negotiating with reality. It suggests workarounds, hedges, occasionally ignores the constraint entirely. It’s as if the key premise, you forgot sugar, is no longer firmly attached to the decision. That’s the moment where you realise something subtle is going wrong. Not knowledge. Not reasoning capacity.
The Paper That Should Make You Slightly Uncomfortable
A recent Google Research paper, Prompt Repetition Improves Non-Reasoning LLMs, puts a name, and more importantly data, to this behaviour. The premise is almost offensively simple:
Take your prompt. Repeat it. Send both copies together.
That’s it. No elaborate prompt engineering. No “act as an expert pastry chef”. No chain-of-thought incantations. Just duplication. If this feels like the sort of trick you’d expect to find scribbled in the margins of a Stack Overflow thread from 2009, you’re not wrong. It has that same energy.
To understand why this works, you have to drop the mental model that LLMs “read” your prompt in any meaningful sense. They don’t. They process tokens sequentially. Left to right. And, critically:
Past tokens cannot attend to future tokens
In other words, the model never sees your prompt as a fully connected object. It experiences it as a stream with a kind of structural amnesia. This is where things get interesting. When you write:
- Context
- Followed by instructions
- Followed by a question
You are assuming those elements coexist in a stable representation. They don’t.
By the time the model is generating an answer, parts of that earlier context are already “fading” in influence. Not gone, but weakened. Competing with everything that came after.
If you’re thinking “this sounds like trying to remember the opening scene of a Christopher Nolan film while watching the final act”, you’re not far off.
If you’ve spent time refining prompts—and let’s be honest, many of us have—this raises an uncomfortable question. How much of prompt engineering is actually about elegance, and how much of it is compensating for a structural limitation?
That’s not style. That’s survival. Through training, they’ve learned that reintroducing the prompt improves their chances of getting the answer right. You’re just moving that step earlier, into the input—where it’s cheaper and faster.
The real value here isn’t the trick itself. It’s what it forces you to confront. These systems are not reasoning over a clean, global representation of your input. They are navigating a sequence with constraints on how information flows. Once you internalise that, a lot of their behaviour stops being mysterious. And a lot of the frustration becomes predictable.
One Last Thing
Take a prompt that didn’t quite work.
Don’t rewrite it.
Don’t optimise it.
Just duplicate it and send it again.
If nothing changes, you’ve lost nothing.
If it improves, you’ve learned something more useful than most prompt engineering guides will tell you.
RogueLoop — where AI meets real-world applications.
📄 Based on research: Prompt Repetition Improves Non-Reasoning LLMs (Google Research) https://arxiv.org/pdf/2512.14982