Duplicate Prompts Can Lift Accuracy Fast

A Google Research study looked at seven proprietary models and 70 model-benchmark pairs, then tried one oddly simple tweak: repeat the prompt once. That single copy improved results in 47 pairs and produced one eye-popping jump from 21.33% to 97.33% on NameIndex.

For teams chasing better output without touching model weights, that is the kind of result that gets attention fast. The catch is that the effect depends on the task, the prompt format, and whether the model is doing reasoning or straight recall.

What the study actually tested

The paper, published by Google Research, focused on prompt concatenation rather than model training. Researchers duplicated each prompt exactly once and measured raw accuracy across widely used benchmarks, including ARC Challenge, OpenBookQA, GSM8K, MMLU-Pro, and MATH.

That matters because the study did not rely on synthetic proxy scores or vague quality judgments. It used direct accuracy measurements, which makes the results easier to compare with production systems that care about right-or-wrong outcomes.

The headline numbers are hard to ignore, especially for product teams that need quick wins:

• Prompt repetition won 47 of 70 model-benchmark pairs.
• No statistically significant loss appeared in the winning cases.
• Gemini Flash-Lite moved from 21.33% to 97.33% on NameIndex.
• Latency stayed flat in most setups because the extra text was only in the input.
• Triple repetition often brought smaller gains and sometimes added latency.

The study also included padding checks to make sure the gains were not just caused by longer inputs. That detail is important, because it points away from simple token-count effects and toward how the model attends to repeated context.

If you want a broader primer on prompt behavior and evaluation habits, our related piece on prompt evaluation basics covers the testing mindset teams should use before shipping anything to users.

Why repetition changes the answer

The explanation is less magical than it first sounds. In a causal language model, tokens are processed in sequence during the prefill stage, and the repeated half of the prompt can attend to a fuller key-value cache than the first half did. In plain English: the model gets a second pass at the same information, but with more context already in memory.

That can help in tasks where the answer depends on retrieval, pattern matching, or stable formatting. It helps less when the model has to reason through a chain of steps, because repetition does little to improve deliberation itself.

“The model is a stochastic parrot.” — Emily M. Bender, University of Washington

Bender’s line is old enough to be widely quoted, but it still fits this result well. Repetition does not make the model smarter in a human sense; it changes how the model weights and re-reads the same input, which can expose quirks in attention and decoding.

That distinction matters for teams deciding whether this trick belongs in a prompt library. If your task is extraction, indexing, or short-form classification, repetition may help. If your task is multi-step reasoning, the effect can shrink fast.

It also helps explain why the paper’s gains were strongest on tasks that reward direct recall. A repeated prompt can act like a second cue, and in some cases that extra cue is enough to stabilize the answer.

Where the gains were largest

The study covered six widely known benchmarks plus two custom long-context tasks. The most dramatic results showed up on tasks that stress memory and input recall rather than step-by-step reasoning.

That pattern is consistent across model families too. The paper reports benefits on models from OpenAI, Anthropic, Google DeepMind, and DeepSeek, though the size of the lift varied by benchmark.

• Gemini Flash-Lite: 21.33% to 97.33% on NameIndex.
• GPT-4o-mini: about 12 percentage points higher on OpenBookQA.
• Claude Haiku: no losses and 18 benchmark ties.
• Non-reasoning tasks: the clearest and most repeatable gains.
• Reasoning tasks: muted or inconsistent effects.

Those numbers are why some teams are already treating repetition as a cheap reliability patch. It is not a substitute for model quality, but it can change the economics of a workflow when the task is simple enough.

For developers comparing prompt tricks, the interesting part is not that one model improved. It is that several vendors improved under the same basic protocol, which suggests the effect is tied to model behavior rather than a single provider’s implementation.

If you are following adjacent AI workflow changes, our coverage of model evaluation trends is a useful companion read.

What this means for production teams

The practical takeaway is straightforward: try repetition first on narrow, low-risk tasks where accuracy matters more than response style. That includes lookup flows, classification, and structured extraction. Start with a baseline prompt, duplicate it once, and compare the results against a control group.

Do the test with real traffic, not a toy dataset. Measure accuracy, latency, output stability, and token cost. Some providers bill input and output separately, so a “free” improvement can still carry a real cost if your prompts are already long.

Here is a simple rollout checklist teams can use:

• Run an A/B test with at least 1,000 calls per variant.
• Separate reasoning tasks from non-reasoning tasks in your evaluation set.
• Track latency and token usage, not just accuracy.
• Keep the repeated version behind a feature flag.
• Document prompt versions so audits and rollbacks are easy.

There is also a governance angle. Repetition should not be treated as a magic fix for weak prompts or poor data. It can improve recall, but it can also hide bad evaluation habits if teams stop testing edge cases once the first metric moves up.

That is why structured training matters. The AI CERTs certification mentioned in the source is aimed at ethical deployment, and that is the right lens here: use prompt tricks as controlled experiments, not folklore.

The catch: this is not a universal win

The paper is promising, but it is not a blank check. It is also still a preprint, so peer review and broader replication matter. Earlier repetition studies found smaller or inconsistent gains, which means protocol details can change the outcome a lot.

Two details matter most. First, the repeated prompt format itself matters; full prompt duplication is different from repeating only the question. Second, the task type matters even more. Once the model is asked to reason step by step, the benefit gets weaker.

There are also operational limits. Very long inputs can hit token ceilings or push latency up, especially on some Anthropic endpoints. And the study says little about safety side effects such as hallucination rate, which should worry anyone planning to use this in production.

So the smartest reading is not “repeat everything.” It is “repeat the right things, then measure carefully.” That is a much narrower claim, but it is the one teams can actually act on.

What to watch next

If this result holds up under replication, vendors will probably start documenting where prompt duplication helps and where it does nothing. That would be useful, because it would turn an odd trick into a clear operational pattern.

My bet is that the next wave of tests will focus on open-source models like Llama and Mistral, plus agent workflows that depend on extraction and routing. If the same gains show up there, repetition will move from curiosity to a standard prompt option for specific workloads.

For now, the takeaway is practical: if your AI system fails on recall-heavy tasks, duplicate the prompt once and test it before spending weeks on fine-tuning. If your system depends on reasoning, skip the shortcut and spend your time on better task design instead.

The next question is simple: which of your prompts are doing retrieval work, and which are doing reasoning work? Answer that first, and you will know whether this trick belongs in your stack.