In the chaotic world of Large Language Model (LLM) optimization, engineers in recent years have developed increasingly esoteric rituals to get better answers.
We’ve seen ‘Chain of Thought’ (which asks the model to think step by step and often shows those ‘reasoning trails’ to the user), ‘Emotional Blackmail’ (telling the model that their career depends on the answer, or that it being accused of sexual misconduct), and complex multi-shot prompting frameworks.
But a new article from Google Research shows that we may have been thinking about it too much. The researchers found that simply repeating the input query (literally copying and pasting the prompt so that it appears twice) consistently improves the performance of major models including Gemini, GPT-4o, Claude, and DeepSeek.
The paper, titled “Fast iteration improves non-reasoning LLMsreleased last month just before the holidays, presents a finding that’s almost suspiciously simple: For tasks that don’t require complex reasoning steps, stating the prompt twice yields significantly better results than saying it once.
In fact, because of the way the transformer architecture works, this “one weird trick” incurs virtually no penalty in terms of generation rate.
The causal blind spot
To understand why repeating a question makes a supercomputer smarter, consider the architectural limitations of the standard Transformer model.
Most modern LLMs are trained as ‘causal’ language models. This means that they process text strictly from left to right. When the model processes the fifth token in your sentence, it can “attend” tokens 1 through 4 (note), but it has no knowledge of token 6 because it hasn’t happened yet.
This creates a fundamental limitation in how models understand user queries. As the authors note, the order of the information is extremely important.
A query formatted as
Prompt repetition hacks this restriction by taking an input of
By the time the model starts processing the second iteration of the query, it has already “read” the first iteration. This allows the tokens in the second copy to take care of every single token in the first copy.
In fact, the second iteration enjoys a form of bidirectional attention: it can ‘look back’ at the entire question to resolve ambiguities or retrieve specific details that may have been missed in one sitting.
The benchmarks: 47 wins, 0 losses
The researchers, Yaniv Leviathan, Matan Kalman and Yossi Matias, tested this hypothesis in a series 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 grim. When asking for models not to use explicit reasoning (i.e., just giving a direct answer), prompt repetition won 47 out of 70 head-to-head trials over baseline, with no losses. The gains were especially dramatic on tasks that required accurate retrieval of 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.
Basic performance: Gemini 2.0 Flash-Lite scored a dismal score 21.33% accuracy.
With repetition: Accuracy skyrocketed 97.33%.
This enormous leap perfectly illustrates the ‘causal blind spot’. In one go, the model may lose track of the count by the time it reaches the 25th name. On the iterative pass, the model actually has the entire list in its “working memory” before attempting to solve the retrieval task.
The “free lunch” of latency
Normally adding text to a prompt increases cost and latency. If you double the input, don’t you also double the waiting time? Surprisingly not. The paper shows that prompt replay is essentially “free” in terms of user-perceived latency. LLM processing is divided into two phases:
Prime: The model processes the input prompt. This is highly parallelizable; the GPU can process the entire prompt matrix simultaneously.
Generation (decoding): The model generates the answer per token. This is serial and slow.
Rapid repetition only increases the work in the prefill phase. Because modern hardware handles pre-filling so efficiently, the user hardly notices the difference. The researchers found that repeating the prompt did that not the length of the generated response was increased, nor the latency of the “time to first token” for most models. The only exceptions were Anthropic’s models (Claude Haiku and Sonnet) on extremely long requests, with the prefill phase eventually hitting a bottleneck. But for the vast majority of use cases, the technique improves accuracy without slowing down the chat experience.
Reasoning versus repetition
There’s a caveat: This technique is primarily intended for “non-reasoning” tasks: scenarios where you want a direct answer rather than a step-by-step derivation.
When the researchers tested rapid repetition in combination with “Chain of Thought” (where the model was asked to “think step by step”), the gains mostly disappeared, showing neutral to slightly positive results (5 wins, 1 loss, 22 ties).
The authors argue that reasoning models naturally perform a version of repetition themselves. When a model ‘thinks’, it often repeats the premise of the question in the generated output before solving it. Therefore, explicitly repeating the prompt in the input becomes redundant.
However, for applications where you need a quick, direct answer without the verbosity (and expense) of lengthy reasoning, prompt repetition offers a powerful alternative.
Strategic implementation for the company
For enterprise leadership, this research represents the rarest of things in AI development: a “free” optimization. But capitalization requires nuance; this is not a setting to blindly switch across an entire organization, but rather a tactical adjustment that spans technology, orchestration, and security.
For tech leads balancing the eternal triangle of speed, quality, and cost, rapid iteration offers a way to punch above your weight class. The data shows that smaller, faster models, such as Gemini 2.0 Flash Lite, can achieve near-perfect retrieval accuracy (from 21.33% to 97.33%) by simply 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 iteration allows their current “Lite” models to close the gap. It is a potential strategy to maintain 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 iteration should likely become a standard, invisible part of the pipeline logic rather than a user behavior.
However, because the technique is neutral for high-reasoning 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 question-and-answer sessions) and double the prompt before passing it to the model. This optimizes performance at the infrastructure level and delivers better results without requiring end-user action or increasing the generation budget.
Finally, this increased attention introduces a new variable for security teams.
If repeating a prompt clarifies a user’s intent toward the model, it stands to reason that malicious intent can also be clarified. 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’) causes the model to ‘attend’ the breach more effectively. Conversely, this mechanism provides a new defense tool: repeating system prompts.
Mentioning security railings twice at the beginning of the context window could force the model to adhere more stringently to security constraints, which could act as a cheap reinforcement for robust security operations.
Why this matters
This research highlights a crucial insight for developers building on LLMs: our current models are still deeply limited by their unidirectional nature. While we wait for new architectures that could solve causal blindness, crude but effective solutions like fast iteration provide immediate value. The authors suggest that this could become a default behavior for future systems.
We could soon see inference engines that silently double-check our cues in the background before sending them to the model, or ‘Reasoning’ models trained to internalize this iteration strategy to be more efficient. If you’re currently struggling to get a model to follow complex instructions or extract specific details from a long document, the solution may not be a better prompt. Maybe you should just say it again.
#deadsimple #prompting #technique #increases #LLM #accuracy #nonreasoning #tasks