TL;DR
Prompt Repetition is a technique that simply copies your prompt twice in a row: instead of <QUERY> you send <QUERY><QUERY>. It works in a regular chat, on any model (Gemini, GPT, Claude, Deepseek).
LLMs are trained as causal models: each token "sees" only the tokens before it, never the ones after. That's why word order affects accuracy: <CONTEXT><QUESTION> behaves differently from <QUESTION><CONTEXT>. When the answer options come BEFORE the question, the model processes them blind, with no idea what the task is. Hence the errors, especially in tasks where the order of information matters (finding an item in a list, picking from options, extracting data).
Repeating the prompt lets every token "see" all the other tokens twice: the first time linearly, the second time with full context. The study recorded 47 wins out of 70 tests, 0 losses across different models and tasks. Meanwhile the answer doesn't get longer and latency doesn't change: the model generates the same number of tokens, just more accurately.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
INSTEAD OF: <your prompt>
WRITE: <your prompt>
<your prompt>
That's it. One request, one answer. You just duplicate the prompt text.
Example in Action
Task: You have a long support thread with a customer (30+ messages) about an Amazon order. You need to quickly figure out whether the customer mentioned a refund, and if so, in which message.
Prompt:
Here is the conversation with the customer:
[Message 1] Customer: Hi, my order never arrived
[Message 2] Support: Hello! Could you share your order number?
[Message 3] Customer: 12345-AMZ
[...28 back-and-forth messages...]
[Message 31] Customer: Maybe I should just get my money back?
[Message 32] Support: We'll process the refund
Did the customer mention a refund? If so, in which message?
Here is the conversation with the customer:
[Message 1] Customer: Hi, my order never arrived
[Message 2] Support: Hello! Could you share your order number?
[Message 3] Customer: 12345-AMZ
[...28 back-and-forth messages...]
[Message 31] Customer: Maybe I should just get my money back?
[Message 32] Support: We'll process the refund
Did the customer mention a refund? If so, in which message?
Result:
The model will more reliably find the refund mention in Message 31. With a regular prompt it might miss the indirect phrasing ("get my money back") or cite the wrong message number, especially if the question came BEFORE the conversation in the prompt structure. With repetition, every token of the question "sees" the whole conversation twice, which cuts the risk of error.
Why It Works
An LLM reads text left to right with no way to go back. If the prompt lists the answer options first and the question second, the model processes the options blind, without understanding the task. Hence the random errors.
Repetition gives it a second pass over all the information. The first copy of the prompt is read linearly. The second copy is read with the context accumulated from the first. Now the model "sees" the links between all parts of the prompt: the question understands the options, and the options understand the question.
Control knobs:
Number of repetitions: you can repeat 3 times (×3) for especially hard tasks with long lists (NameIndex showed accuracy jumping from 21% to 97%). For simple tasks, ×2 is enough.
Explicit separator: add "Let me repeat that:" between the copies. Sometimes it gives a slightly better result, but not always. Test on your own data.
Part of the prompt: for very long prompts, repeat only the critical part (question + instruction), not the whole context. Saves tokens.
Prompt Template
{your_prompt}
{your_prompt}
Or with an explicit separator:
{your_prompt}
Let me repeat that:
{your_prompt}
Or triple repetition:
{your_prompt}
Let me repeat that:
{your_prompt}
Let me repeat that one more time:
{your_prompt}
Where {your_prompt} is any prompt you're using right now. Just duplicate it. Output-format instructions, context, the question: everything gets repeated in full.
Limitations
⚠️ Doesn't work with reasoning: When you ask the model to "think step by step" or use o1/o3, the effect is minimal. When reasoning, models already repeat parts of the prompt in their thoughts. Repeating the input adds nothing.
⚠️ Doubles input tokens: If the prompt is 1,000 tokens, with repetition it's 2,000. Request cost goes up (but not the cost of the answer, since output length doesn't change). Not a big deal for short prompts; for long ones (10K+ tokens) it can hurt the budget.
⚠️ Context limits: Very long prompts (close to the model's limit) can't be repeated; they won't fit in the context window. In those cases, repeat only the critical part (question + instructions), not the whole context.
⚠️ Latency on Claude: Anthropic models (Haiku, Sonnet) showed higher latency on very long prompts (from doubling 10K+ tokens): the prefill stage drags out. On short prompts there's no effect.
How They Studied It
A team from Google Research took 7 models (Gemini 2.0 Flash and Lite, GPT-4o and 4o-mini, Claude 3 Haiku and 3.7 Sonnet, Deepseek V3) and ran them through 7 benchmarks, from school-level tests (ARC, OpenBookQA) to math (GSM8K, MATH) and their own custom tasks.
They tested two modes: without reasoning (just answer) and with reasoning (think step by step). Multiple-choice tasks were run in two variants: question-first (question → options) and options-first (options → question). The second is tougher: the model reads the options without knowing what it's looking for.
The results were striking in their simplicity and consistency: across 70 model+benchmark+mode combinations they got 47 statistically significant wins and 0 losses. The effect was especially strong on the custom tasks NameIndex (find the 25th name out of 50) and MiddleMatch (find the item between two others), where accuracy rose from ~20% to ~97%.
Why it works: the authors explain it through the attention architecture. In causal LLMs, the token at position N "sees" only tokens 1..N, nothing further. When the prompt is repeated, a token from the second copy "sees" all tokens of the first copy plus itself. In effect, every prompt token gets two-way visibility: close to bidirectional attention, but without retraining the model.
Practical insight: the researchers noticed that reasoning models (trained with RL) learned to repeat parts of the prompt in their reasoning on their own. Prompt Repetition moves that work to the prefill stage (parallelizable), removing tokens from the generation stage (sequential). Efficiency goes up with no change in quality.
Surprise: the Padding method (adding dots "..." up to the same length as the repetition) had no effect. So it's not about input length; it's specifically about repeating meaningful tokens.
Original from the Paper
Base variants from the paper:
Baseline:
<QUERY>
Prompt Repetition:
<QUERY>
<QUERY>
Prompt Repetition (Verbose):
<QUERY>
Let me repeat that:
<QUERY>
Prompt Repetition ×3:
<QUERY>
Let me repeat that:
<QUERY>
Let me repeat that one more time:
<QUERY>
Context: The researchers tested all 4 variants on the same data. Verbose and ×3 sometimes did slightly better than basic repetition, especially on tasks with long lists. But the difference is small: plain <QUERY><QUERY> works great 90% of the time.
Adaptations and Extrapolations
💡 Adaptation for multi-step tasks with verification:
If the task requires generation + a check (for example, writing a text of exactly 100 words), repeat the instruction after generation:
Write a LinkedIn post about [topic]. Exactly 50 words.
Write a LinkedIn post about [topic]. Exactly 50 words.
---
Answer:
{the model will generate the text here}
---
Check: is it exactly 50 words? If not, rewrite it.
The doubled prompt gives precise generation; the check instruction gives self-correction.
🔧 Technique: repeat only the critical part → save tokens
If your prompt is 5,000 tokens (a long price list + a question), repeat only the question:
[LONG PRICE LIST: 4,500 tokens]
Find the item "ASUS ROG Laptop" and give its price.
Find the item "ASUS ROG Laptop" and give its price.
Instead of 10,000 tokens (full repetition) you get ~5,100. The effect holds: the model "sees" the instruction twice, and the context stays in memory.
💡 Adaptation for classification with examples (few-shot):
With few-shot (you provide examples of correct answers), repeat the whole block, examples + task:
Examples of the brand's tone of voice:
[Example 1: text → rating]
[Example 2: text → rating]
[Example 3: text → rating]
Rate the new text: [text]
---
Examples of the brand's tone of voice:
[Example 1: text → rating]
[Example 2: text → rating]
[Example 3: text → rating]
Rate the new text: [text]
The model picks up the pattern from the examples better with repetition. Especially useful when the examples come BEFORE the task: on a single read, the model may "forget" the first examples by the time it generates the answer.
Resources
Prompt Repetition Improves Non-Reasoning LLMs: Yaniv Leviathan, Matan Kalman, Yossi Matias (Google Research), February 2025
Related work: - Chain-of-Thought Prompting (Wei et al., 2023): the "think step by step" technique - Re-Reading Improves Reasoning (Xu et al., 2024): a study on the benefits of re-reading the question - Repetition Improves Language Model Embeddings (Springer et al., 2024): repetition improves embeddings