On a small lookup task — "find the 25th name in this list of 50" — Gemini 2.0 Flash-Lite scored 21.33%. The model had every name in front of it and still got it wrong four times out of five. Then someone made one change: they pasted the prompt in twice, so the model read the identical question back-to-back. Accuracy jumped to 97.33%.
That's a 76-percentage-point swing from copy-paste. No fine-tuning, no chain-of-thought, no extra output tokens. It comes from a recent Google Research paper, Prompt Repetition Improves Non-Reasoning LLMs, and once you see why it works, you'll want it in your prompt toolkit for a specific class of task.
The trick, in full
There's nothing to install. You take your query and send it twice:
<QUERY><QUERY>
That's the whole method. The paper also tests a "verbose" variant that adds a seam between the copies, which reads more naturally in a chat template:
{query}
Let me repeat that:
{query}
And a ×3 version that repeats three times, which pushed the custom lookup tasks even higher. In code, the wrapper is a one-liner you can slot in front of any completion call:
def repeat(query: str, n: int = 2) -> str:
return "\n\nLet me repeat that:\n\n".join([query] * n)
The single most useful thing to internalize: your output length does not change. The model reads a longer prompt and still returns one normal answer. You pay for a few more input tokens on the prefill and nothing on generation.
Why a decoder-only model needs to read twice
The gain isn't a quirk — it falls straight out of how these models attend to text. A decoder-only LLM is trained with causal masking: every token can attend to the tokens before it, never the ones after. That's fine for generating text left to right, but it's a real handicap when the question comes after a wall of context.
Picture a multiple-choice item where the passage and answer options are laid out first, and the actual question lands at the very end. While the model encodes that passage, it hasn't read the question yet, so it can't weight what matters. By the time it reaches the question, the passage tokens are already locked in behind the mask — they can't look forward to see what they were supposed to notice.
Repeating the prompt patches this. On the second pass, every token of the query sits after a complete copy of itself, so it can attend backward to the entire question.
Repetition gives a one-directional model a cheap taste of bidirectional encoding: the first copy becomes global context that the second copy is finally allowed to read in full.
This also explains a result that rules out the boring alternative. The researchers ran a padding control — they lengthened the prompt with meaningless periods instead of a real second copy — and it did nothing. The win isn't from a longer context window or more compute; it's from the model getting a second, fully-visible look at the actual words.
How well it holds up
This isn't one lucky benchmark. The study covers seven models — Gemini 2.0 Flash and Flash-Lite, GPT-4o and GPT-4o-mini, Claude 3 Haiku and Claude 3.7 Sonnet, and DeepSeek V3 — across seven benchmarks including ARC-Challenge, OpenBookQA, GSM8K, MMLU-Pro, and MATH, plus two custom lookup tasks.
In non-reasoning mode, plain repetition won 47 of 70 model-task combinations with zero statistically significant losses (McNemar test, p < 0.1). The rest were ties. Read that again: across a wide grid of frontier models and task types, repeating the prompt either helped or did nothing — it never measurably hurt. For a technique this cheap, "no downside" is the headline as much as the 76-point best case.
The one condition that flips the result
Here's the boundary, and it's sharp. The benefit lives in non-reasoning mode — direct answers, no chain-of-thought, no thinking tokens. Turn reasoning on and the effect largely evaporates: the paper reports a near-wash (5 wins, 1 loss, 22 neutral) once models are allowed to think step by step.
The reason is almost funny. Reasoning models already restate the problem to themselves as the first move of their scratchpad. They re-read the question on their own, so handing them a second copy is redundant. You've already got what repetition buys you, for free, from the reasoning behavior.
That gives you a clean decision rule:
- Reach for repetition when you're calling a fast, cheap model in direct-answer mode — classification, extraction, lookup, multiple choice — especially when the context is front-loaded and the real question comes last.
- Skip it when chain-of-thought or a dedicated reasoning model is doing the work. You'll add input tokens for no gain.
The cost side, honestly
Because the extra tokens hit only the prefill stage — which is parallelizable — latency is unaffected on most models even though the prompt is longer. The exception the authors flag: Anthropic models showed latency creep on very long inputs or the ×3 variant, so don't blindly triple a 10,000-token prompt. For typical short-to-medium queries in direct-answer mode, the added cost rounds to a rounding error.
Worth noting this isn't a brand-new idea, just a cleaner and better-measured one. An earlier line of work, Re-Reading Improves Reasoning in Large Language Models (RE2, EMNLP 2024), showed that appending "Read the question again:" helped on reasoning benchmarks. The newer study strips it down to raw copy-paste, quantifies where it wins and loses, and pins the mechanism to causal masking.
The takeaway
Add a two-line wrapper to your non-reasoning API calls and route your lookup, extraction, and multiple-choice prompts through it — especially any prompt that buries the question under front-loaded context. Keep it off your reasoning-model paths. Then measure: run your own eval set with and without the wrapper, because the win concentrates on recall-style tasks and you want to see the delta on your workload, not the paper's. The cost of trying is one string join; the upside, on the right task, is the difference between a model that has the answer and one that can actually retrieve it.
Sources: Prompt Repetition Improves Non-Reasoning LLMs (arXiv 2512.14982), Re-Reading Improves Reasoning in Large Language Models (arXiv 2309.06275, EMNLP 2024)