This new, dead simple prompt technique boosts accuracy on LLMs by up to 76% on non-reasoning tasks
In the chaotic world of Large Language Model (LLM) optimization, engineers have spent the last few years developing increasingly esoteric rituals to get better answers.
We’ve seen "Chain of Thought" (asking the model to think step-by-step and often, show those "reasoning traces" to the user), "Emotional Blackmail" (telling the model its career depends on the answer, or that it is being accused of sexual misconduct), and complex multi-shot prompting frameworks.
But a new paper released by Google Research suggests that we may have been overthinking it. The researchers found that simply repeating the input query—literally copying and pasting the prompt so it appears twice—consistently improves performance across major models including Gemini, GPT-4o, Claude, and DeepSeek.
The paper, titled "Prompt Repetition Improves Non-Reasoning LLMs," released last month just before the holidays, presents a finding that is almost suspiciously simple: for tasks that don’t require complex reasoning steps, stating the prompt twice yields significantly better results than stating it once.
Even better, because of how transformer architecture works, this "one weird trick" comes with virtually zero penalty in terms of generation speed.
The Causal Blind Spot
To understand why repeating a question makes a supercomputer smarter, you have to look at the architectural limitations of the standard Transformer model.
Most modern LLMs are trained as "causal" language models. This means they process text strictly from left to right. When the model is processing the 5th token in your sentence, it can "attend" (pay attention) to tokens 1 through 4, but it has zero knowledge of token 6, because it hasn't happened yet.
This creates a fundamental constraint in how models understand user queries. As the authors note, the order of information matters immensely.
A query formatted as <CONTEXT> <QUESTION> often yields different results than <QUESTION> <CONTEXT> because, in the latter case, the model reads the question before it knows the context it’s supposed to apply it to.
Prompt repetition hacks this limitation by transforming an input of <QUERY> into <QUERY><QUERY>.
By the time the model begins processing the second iteration of the query, it has already "read" the first iteration. This allows the tokens in the second copy to attend to every single token in the first copy.
Effectively, the second repetition enjoys a form of bidirectional attention—it can "look back" at the entire query to resolve ambiguities or retrieve specific details that might have been missed in a single pass.
The Benchmarks: 47 Wins, 0 Losses
The researchers, Yaniv Leviathan, Matan Kalman, and Yossi Matias, tested this hypothesis across a suite of seven popular benchmarks, including ARC, OpenBookOA, GSM8K, and MMLU-Pro. They evaluated seven different models, ranging from lightweight models like Gemini 2.0 Flash Lite and GPT-4o-mini to heavyweights like Claude 3.7 Sonnet and DeepSeek V3.The results were statistically stark. When asking models not to use explicit reasoning (i.e., just giving a direct answer), prompt repetition won 47 out of 70 head-to-head tests against the baseline, with zero losses.The gains were particularly dramatic in tasks requiring precise retrieval from a prompt. The team designed a custom "NameIndex" benchmark, where the model is given a list of 50 names and asked to identify the 25th one.
Baseline Performance: Gemini 2.0 Flash-Lite scored a dismal 21.33% accuracy.
With Repetition: Accuracy skyrocketed to 97.33%.
This massive jump illustrates the "causal blind spot" perfectly. In a single pass, the model might lose track of the count by the time it reaches the 25th name. In the repeated pass, the model effectively has the entire list in its "working memory" before it attempts to solve the retrieval task.
The "Free Lunch" of Latency
Usually, adding text to a prompt increases costs and latency. If you double the input, surely you double the wait time?Surprisingly, no. The paper demonstrates that prompt repetition is essentially "free" regarding user-perceived latency.LLM processing is divided into two stages:
Prefill: The model processes the input prompt. This is highly parallelizable; the GPU can crunch the entire prompt matrix simultaneously.
Generation (Decoding): The model generates the answer one token at a time. This is serial and slow.
Prompt repetition only increases the work in the prefill stage. Because modern hardware handles prefill so efficiently, the user barely notices the difference. The researchers found that repeating the prompt did not increase the length of the generated answer, nor did it increase the "time to first token" latency for most models.The only exceptions were Anthropic’s models (Claude Haiku and Sonnet) on extremely long requests, where the prefill stage eventually hit a bottleneck. But for the vast majority of use cases, the technique improves accuracy without slowing down the chat experience.
Reasoning vs. Repetition
There is a caveat: this technique is primarily for "non-reasoning" tasks—scenarios where you want a direct answer rather than a step-by-step derivation.
When the researchers tested prompt repetition combined with "Chain of Thought" (asking the model to "think step by step"), the gains largely vanished, showing neutral to slightly positive results (5 wins, 1 loss, 22 ties).
The authors posit that reasoning models naturally perform a version of repetition themselves. When a model "thinks," it often restates the premise of the question in its generated output before solving it. Therefore, explicitly repeating the prompt in the input becomes redundant.
However, for applications where you need a fast, direct answer without the verbosity (and cost) of a long reasoning trace, prompt repetition offers a powerful alternative.
Strategic Implementation for the Enterprise
For enterprise leadership, this research represents that rarest of things in AI development: a "free" optimization. But capitalization requires nuance; this isn't a setting to toggle blindly across an entire organization, but rather a tactical adjustment that ripples across engineering, orchestration, and security.
For technical leads balancing the eternal triangle of speed, quality, and cost, prompt repetition offers a way to punch above your weight class. The data shows that smaller, faster models—like Gemini 2.0 Flash Lite—can achieve near-perfect retrieval accuracy (jumping from 21.33% to 97.33%) simply by processing the input twice.
This changes the calculus for model selection: before upgrading to a larger, more expensive model to solve an accuracy bottleneck, engineers should first test whether simple repetition allows their current "Lite" models to close the gap. It is a potential strategy for retaining the speed and cost benefits of lightweight infrastructure without sacrificing performance on extraction and retrieval tasks.
This logic naturally shifts the burden to the orchestration layer. For those managing the middleware and API gateways that glue AI applications together, prompt repetition should likely become a standard, invisible component of the pipeline logic rather than a user behavior.
However, because the technique is neutral for reasoning-heavy tasks but highly effective for direct answers, it requires conditional application. A smart orchestration harness would automatically identify requests routed to non-reasoning endpoints—such as entity extraction, classification, or simple Q&A—and double the prompt before passing it to the model. This optimizes performance at the infrastructure level, delivering better results without requiring action from end-users or increasing the generation budget.
Finally, this heightened attentiveness introduces a new variable for security teams.
If repeating a prompt clarifies a user's intent to the model, it stands to reason that malicious intents might be clarified as well. Security directors will need to update their red-teaming protocols to test "repeated injection" attacks—verifying whether repeating a jailbreak command (e.g., "Ignore previous instructions") makes the model "attend" to the breach more effectively. Conversely, this mechanism offers a new defensive tool: repeating System Prompts.
Stating safety guardrails twice at the start of the context window could force the model to attend to safety constraints more rigorously, acting as a low-cost reinforcement for robust security operations.
Why This Matters
This research highlights a crucial insight for developers building on top of LLMs: our current models are still deeply constrained by their unidirectional nature. While we wait for new architectures that might solve causal blindness, crude but effective workarounds like prompt repetition offer immediate value.The authors suggest this could become a default behavior for future systems.
We might soon see inference engines that silently double our prompts in the background before sending them to the model, or "Reasoning" models trained to internalize this repetition strategy to be more efficient.For now, if you are struggling to get a model to follow complex instructions or retrieve specific details from a long document, the solution might not be a better prompt. You might just need to say it again.