back
loading skill details...
A prompt repetition technique for improving LLM accuracy. Achieves significant performance gains in 67% (47/70) of 70 benchmarks. Automatically applied on…
Prompt Repetition
Problem Being Solved
LLMs are trained as Causal Language Models, where each token attends only to previous tokens. This leads to:
Context-Question Problem: The question is unknown when processing context
Options-First MCQ Problem: Cannot fully understand the question context when viewing answer choices
Position/Index Problem: Attention weights weaken for specific position information in long lists
Prompt repetition enables the second pass to reference the entire first pass, effectively mimicking some benefits of bidirectional attention.
When to use this skill
When using lightweight models: claude-haiku, gemini-flash, gpt-4o-mini, etc.
Options-First MCQ: Multiple choice where answer choices appear before the question
Context + Question: Searching for specific information in long contexts
Index/Position Tasks: Position-based queries in inventories or lists
NPC Dialogue: Maintaining consistency for game AI characters
Non-Reasoning Tasks: Tasks that do not use Chain-of-Thought
How It Works
Limitations of Causal Attention
[Context] → [Question]
↓
Cannot reference Question content when processing Context tokens
Attention weights for Context are already finalized by the time Question tokens appear
How Prompt Repetition Solves This
[First Pass] [Second Pass]
Context → Question → Context' → Question'
↑ ↑
Can reference entire first pass
In the second repetition, the model reprocesses information across the entire first prompt and strengthens attention weights on key concepts, resulting in improved performance.
Note: This does not change the model architecture to bidirectional; it is a prompt engineering technique to mitigate the limitations of causal models.
Research Results (Google Research 2025)
Metric
Result
Significant improvement (p < 0.1)
47 / 70 benchmarks
Performance degradation
0
Neutral
23
Improvement rate
67%
Most dramatic improvement: Gemini 2.0 Flash-Lite on NameIndex: 21.33% → 97.33% (+76%p)
Tested Models
Gemini 2.0 Flash / Flash Lite
GPT-4o / GPT-4o-mini
Claude 3.7 Sonnet / Claude 3 Haiku
Deepseek V3
Tested Benchmarks
ARC (Challenge) - Scientific reasoning
OpenBookQA - Open-domain QA
GSM8K - Math problems
MMLU-Pro - Multitask language understanding
MATH - Mathematical problem solving
NameIndex / MiddleMatch - Custom position tasks
Application Procedure
Step 1: Verify Auto-Apply Target Models
Provider
Auto-apply models
Excluded models
Claude
haiku series
opus, sonnet
Gemini
flash, flash-lite
pro, ultra
OpenAI
gpt-4o-mini, gpt-low
gpt-4o, gpt-4
Step 2: Determine Repetition Count by Task Type
Task Type
Keyword Pattern
Repetitions
Expected Improvement
Options-First MCQ
A. B. C. D. choices first
2×
+15-40%p
Index/Position
slot, position, index, N-th
3×
+50-76%p
Context + Question
General question
2×
+5-15%p
With CoT
step by step, think through
0× (not applied)
~0%
Step 3: Check Token Limits
# Check context before auto-apply
max_context = model_context_window * 0.8 # 80% safety margin
if len(prompt_tokens) * repetitions > max_context:
repetitions = max(1, int(max_context / len(prompt_tokens)))
Step 4: Prompt Transformation
def apply_prompt_repetition(prompt: str, times: int = 2) -> str:
"""Repeat the prompt a specified number of times
Args:
prompt: Original prompt
times: Number of repetitions (default 2)
Returns:
Repeated prompt
"""
if times <= 1:
return prompt
return "\n\n".join([prompt] * times)
Practical Examples
Example 1: Options-First MCQ (Greatest Effect)
Before:
A. Paris
B. London
C. Berlin
D. Madrid
Which city is the capital of France?
Reply with one letter.
After (repetition ×2 applied):
A. Paris
B. London
C. Berlin
D. Madrid
Which city is the capital of France?
Reply with one letter.
A. Paris
B. London
C. Berlin
D. Madrid
Which city is the capital of France?
Reply with one letter.
Expected output:
A
Accuracy: original 78% → after repetition 93% (+15%p)
Example 2: Index/Position Tasks (Maximum Effect)
Before:
Inventory:
1. Iron Sword
2. Leather Armor
3. Health Potion (x5)
4. Magic Staff
...
25. Dragon Scale
...
50. Ancient Map
What item is in slot 25?
After (repetition ×3 applied):
Prompt repeated 3 times
Expected output:
Dragon Scale
Accuracy: original 21% → after repetition 97% (+76%p)
Example 3: Tool Call Prompt Handling
Note: Prompts containing tool call instructions are also repeated in their entirety. The full-repetition approach was adopted for implementation simplicity and consistency.
Before:
Use the calculator tool to compute 234 * 567.
What is the result?
After (repetition ×2):
Use the calculator tool to compute 234 * 567.
What is the result?
Use the calculator tool to compute 234 * 567.
What is the result?
Research results show that full repetition including tool call sections is also effective.
Production-Ready Implementation
Auto-Apply Transformer
"""prompt_repetition_transformer.py"""
from dataclasses import dataclass, field
from typing import Optional, Callable, List
import re
# Context window per model (in tokens)
MODEL_CONTEXT_WINDOWS = {
"claude-3-haiku": 200_000,
"claude-haiku": 200_000,
"gemini-flash": 1_000_000,
"gemini-flash-lite": 1_000_000,
"gemini-2.0-flash": 1_000_000,
"gpt-4o-mini": 128_000,
"gpt-low": 128_000,
}
# Models targeted for auto-apply
AUTO_APPLY_MODELS = list(MODEL_CONTEXT_WINDOWS.keys())
# CoT patterns (excluded from apply)
COT_PATTERNS = [
r"step by step",
r"think through",
r"let's think",
r"reasoning:",
r"chain of thought",
]
# Position/Index patterns (3× repetition)
POSITION_PATTERNS = [
r"slot \d+",
r"position \d+",
r"index \d+",
r"\d+(st|nd|rd|th)",
r"item \d+",
r"row \d+",
r"column \d+",
]
@dataclass
class PromptRepetitionConfig:
"""Prompt repetition configuration"""
default_repetitions: int = 2
position_repetitions: int = 3
separator: str = "\n\n"
max_context_ratio: float = 0.8
applied_marker: str = "<!-- prompt-repetition-applied -->"
class PromptRepetitionTransformer:
"""Auto-apply prompt repetition transformer for lightweight models"""
def __init__(self, config: Optional[PromptRepetitionConfig] = None):
self.config = config or PromptRepetitionConfig()
def should_apply(self, model: str, prompt: str) -> bool:
"""Determine whether to auto-apply"""
# Skip if already applied
if self.config.applied_marker in prompt:
return False
# Check target model
model_lower = model.lower()
if not any(m in model_lower for m in AUTO_APPLY_MODELS):
return False
# Skip when CoT pattern detected
prompt_lower = prompt.lower()
for pattern in COT_PATTERNS:
if re.search(pattern, prompt_lower):
return False
return True
def determine_repetitions(self, prompt: str, model: str) -> int:
"""Determine repetition count based on task type"""
prompt_lower = prompt.lower()
# Position/Index pattern detected → 3×
for pattern in POSITION_PATTERNS:
if re.search(pattern, prompt_lower):
return self.config.position_repetitions
return self.config.default_repetitions
def estimate_tokens(self, text: str) -> int:
"""Simple token count estimation (speed over precision)"""
# Estimate approximately 4 characters = 1 token
return len(text) // 4
def transform(self, prompt: str, model: str) -> str:
"""Apply repetition to prompt"""
if not self.should_apply(model, prompt):
return prompt
repetitions = self.determine_repetitions(prompt, model)
# Check context limit
model_lower = model.lower()
max_tokens = 128_000 # Default value
for m, tokens in MODEL_CONTEXT_WINDOWS.items():
if m in model_lower:
max_tokens = tokens
break
max_allowed = int(max_tokens * self.config.max_context_ratio)
prompt_tokens = self.estimate_tokens(prompt)
# Reduce repetitions if token limit exceeded
while prompt_tokens * repetitions > max_allowed and repetitions > 1:
repetitions -= 1
if repetitions <= 1:
return prompt
# Apply repetition + add marker
repeated = self.config.separator.join([prompt] * repetitions)
return f"{self.config.applied_marker}\n{repeated}"
def wrap_llm_call(self, llm_fn: Callable, model: str) -> Callable:
"""Wrap LLM call function"""
def wrapped(prompt: str, **kwargs):
transformed = self.transform(prompt, model)
return llm_fn(transformed, **kwargs)
return wrapped
How to Measure Effectiveness (Verification)
A/B Testing Method
def run_ab_test(prompts: List[str], llm_fn, model: str, ground_truth: List[str]):
"""A/B test for prompt repetition effectiveness"""
transformer = PromptRepetitionTransformer()
results = {"baseline": [], "repeated": []}
for prompt, expected in zip(prompts, ground_truth):
# Baseline
response_a = llm_fn(prompt)
results["baseline"].append(response_a == expected)
# With Repetition
repeated_prompt = transformer.transform(prompt, model)
response_b = llm_fn(repeated_prompt)
results["repeated"].append(response_b == expected)
baseline_acc = sum(results["baseline"]) / len(prompts)
repeated_acc = sum(results["repeated"]) / len(prompts)
print(f"Baseline accuracy: {baseline_acc:.2%}")
print(f"Repeated accuracy: {repeated_acc:.2%}")
print(f"Improvement: {repeated_acc - baseline_acc:+.2%}p")
Key Metrics
Metric
Measurement Method
Accuracy
Compare correct answer rates
Consistency
Variance across 10 runs of same prompt
Token cost
Input token increase rate
Latency
Compare p50, p99 latency
When NOT to Use
Case
Reason
Using CoT
Reasoning process already provides context
Reasoning models (opus, sonnet)
Already optimized; minimal effect
Very long prompts
Risk of exceeding context limit
Already repeated
Duplicate application wastes tokens
Cost-Accuracy Analysis
Metric
Baseline
With Repetition
Change
Input tokens
500/req
1000/req
+100%
Output tokens
100/req
100/req
0%
Latency (p50)
450ms
460ms
+2%
Latency (p99)
1200ms
1250ms
+4%
Accuracy
78%
89%
+14%p
Cost per correct answer
$0.019
$0.020
+5%
Key insight: The prefill phase is highly parallelized on GPU, so doubling input tokens has minimal impact on latency.
Multi-Agent Integration
Auto-Apply Strategy Per Agent
Agent
Model
Repetition Applied
Applied At
Claude Orchestrator
opus/sonnet
Optional
-
Claude Executor
haiku
Auto
skill_loader.py
Gemini Analyst
flash
Auto
On MCP call
OpenAI
gpt-4o-mini
Auto
skill_loader.py
Preventing Duplicate Application
To prevent duplicate application in multi-agent pipelines:
Use markers: Detect already-applied prompts with <!-- prompt-repetition-applied --> marker
Pass metadata: Pass x-prompt-repetition-applied: true header between agents
Orchestrator management: Claude Orchestrator tracks whether repetition is applied when calling sub-agents
Application Pattern
[Claude Sonnet] Planning (no repetition needed)
↓
[Gemini Flash] Analysis (repetition ×2 auto-applied, marker added)
↓
[Claude Haiku] Execution (marker detected → skip duplicate apply)
skill_loader.py Integration Guide
Recommended Implementation
# Code to add to skill_loader.py
from prompt_repetition_transformer import PromptRepetitionTransformer
class SkillLoader:
def __init__(self, ...):
# ... existing code ...
self.prompt_transformer = PromptRepetitionTransformer()
def apply_auto_skills(self, prompt: str, model: str) -> str:
"""Handle auto-apply skills"""
# Auto-apply prompt-repetition
for skill in self.skills.values():
auto_apply = skill.get('data', {}).get('auto-apply', {})
if auto_apply.get('trigger') == 'auto':
target_models = auto_apply.get('models', [])
if any(m in model.lower() for m in target_models):
prompt = self.prompt_transformer.transform(prompt, model)
return prompt
Constraints
Required Rules
Lightweight models first: Most effective for haiku, flash, mini series
Limit repetitions: 2× for general tasks, max 3× for position tasks
Context monitoring: Be cautious of context overflow due to repetition
Check markers: Mandatory marker check to prevent duplicate application
Prohibited Rules
No padding substitution: Increasing length with . etc. has no effect (per research)
Do not combine with CoT: Effects cancel out
Do not force-apply to reasoning models: Already optimized
No duplicate application: Consecutive application without markers wastes tokens
Quick Reference
=== Auto-Apply Target Models ===
claude-3-haiku, claude-haiku
gemini-flash, gemini-flash-lite, gemini-2.0-flash
gpt-4o-mini, gpt-low
=== Repetition Count ===
General tasks: 2×
Position/Index (slot/position/index keywords): 3×
With CoT: 0× (not applied)
=== Effect (Google Research 2025) ===
Improvement rate: 67% (47/70 benchmarks)
Performance degradation: 0 cases
Maximum improvement: +76%p (NameIndex)
=== Cost ===
Input tokens: +100%
Latency: +2% (Prefill parallelization)
Cost per correct answer: +5%
=== Duplicate Application Prevention ===
Marker: <!-- prompt-repetition-applied -->
References
Prompt Repetition Improves Non-Reasoning LLMs (Leviathan et al., 2025)
Chain-of-Thought Prompting Elicits Reasoning (Wei et al., 2023)
Re-Reading Improves Reasoning in LLMs (Xu et al., 2024)don't have the plugin yet? install it then click "run inline in claude" again.
separated intent from background research, made implicit decision logic explicit (model eligibility, cot detection, position pattern detection, context limit checks), added inputs section documenting model identifier and token estimation requirements, broke procedure into 6 numbered steps with clear input/output contracts, documented edge cases (duplicate markers, context overflow, excluded models), added explicit decision points for all conditional branches.
prompt repetition is a prompt engineering technique that re-runs the same prompt twice (or three times for position-based tasks) to let the model reference its entire first pass when processing the second pass. this mimics benefits of bidirectional attention in causal language models. use this skill on lightweight models (claude-haiku, gemini-flash, gpt-4o-mini, etc.) for multiple-choice questions with answer choices listed first, long-context searches, position/index queries in lists, or npc dialogue systems. do not use with chain-of-thought reasoning, reasoning models (opus, sonnet), or very long prompts near context limits.
model identifier (required). lowercase model slug from the auto-apply target list: claude-haiku, gemini-flash, gemini-flash-lite, gemini-2.0-flash, gpt-4o-mini, gpt-low. check that your model is in the auto-apply targets. excluded models (claude-opus, claude-sonnet, gemini-pro, gemini-ultra, gpt-4o, gpt-4) skip repetition.
prompt text (required). the full prompt you want to repeat. may include task instructions, context, question, answer choices, tool calls, or any combination.
task context (required). classify your task as one of: options-first-mcq, index-position, context-question, or npc-dialogue. if the prompt contains chain-of-thought keywords (step by step, think through, let's think, reasoning:, chain of thought), flag it as cot-excluded and do not apply.
model context window (required for pre-flight check). integer token limit for your model. hardcoded defaults: claude-haiku 200k, gemini-flash 1m, gpt-4o-mini 128k. verify against your provider's current specs.
existing marker detection (required). check whether the prompt already contains <!-- prompt-repetition-applied -->. if present, skip repetition entirely to avoid wasting tokens on duplicate application.
token count estimate (required). rough character-to-token ratio for your model. use len(text) / 4 as a conservative estimate.
validate model eligibility. take the model identifier from your api call. convert to lowercase. check if it matches any of the auto-apply target models (claude-haiku, gemini-flash, gemini-flash-lite, gemini-2.0-flash, gpt-4o-mini, gpt-low). if no match, return the original prompt unchanged and skip remaining steps.
input: model string (e.g., "gpt-4o-mini") output: boolean (true if eligible, false if not)
check for existing repetition marker. scan the prompt text for the substring <!-- prompt-repetition-applied -->. if found, return the original prompt unchanged. this prevents accidental double-application in multi-agent pipelines.
input: prompt text output: boolean (true if marker present, false otherwise)
detect chain-of-thought pattern. search the prompt for regex patterns matching: step by step, think through, let's think, reasoning:, or chain of thought (case-insensitive). if any pattern matches, return the original prompt unchanged. repetition does not improve cot tasks.
input: prompt text (lowercase version for matching) output: boolean (true if cot detected, false otherwise)
detect position or index patterns. search the prompt for regex patterns matching: slot \d+, position \d+, index \d+, \d+(st|nd|rd|th), item \d+, row \d+, or column \d+ (case-insensitive). if any pattern matches, set repetition count to 3. else set repetition count to 2.
input: prompt text (lowercase version for matching) output: integer repetition count (2 or 3)
estimate token count and check context limit. count characters in the prompt. divide by 4 to estimate tokens (rough but fast). look up the model's context window from the hardcoded map or use the provided value. multiply estimated tokens by the repetition count from step 4. if this product exceeds 80% of the context window, reduce repetition count by 1 (minimum 1). repeat until the product fits within 80% of the context window.
input: prompt text, model identifier, repetition count (from step 4) output: adjusted repetition count (1, 2, or 3)
construct repeated prompt. if adjusted repetition count is 1, return the original prompt unchanged. else, concatenate the prompt with itself (repetition count) times, separated by double newlines (\n\n). prefix the result with the marker string <!-- prompt-repetition-applied -->\n to flag it for downstream agents or subsequent calls.
input: prompt text, adjusted repetition count output: repeated prompt string with marker
if model is not in auto-apply targets (step 1): skip repetition and return original prompt. rationale: repetition benefit is strongest for lightweight models; reasoning models (opus, sonnet) are already optimized and show minimal gains.
if repetition marker already present (step 2): skip repetition and return original prompt. rationale: duplicate repetition wastes tokens and input cost with no additional benefit. multi-agent pipelines must check markers before applying.
if chain-of-thought pattern detected (step 3): skip repetition and return original prompt. rationale: cot tasks already provide contextual awareness through reasoning steps; repetition does not improve accuracy and may hurt performance.
if position or index pattern detected (step 4): use 3 repetitions instead of 2. rationale: position-based tasks benefit more from multiple passes (observed +50-76% improvement). general tasks use 2 repetitions (+5-15% improvement).
if repeated prompt would exceed context limit (step 5): reduce repetition count iteratively until it fits within 80% safety margin. if repetition count reaches 1, return original prompt unchanged. rationale: context overflow causes api errors or truncation; safety margin accounts for output tokens and buffer.
primary output: a string containing the repeated prompt, formatted as follows:
<!-- prompt-repetition-applied -->
<original prompt>
<original prompt>
(repeated 2 or 3 times, separated by \n\n).
metadata: the repetition count applied (integer: 1, 2, or 3).
token impact: input token count increases by approximately 100% (2 repetitions) or 200% (3 repetitions). output tokens unchanged. latency increase minimal (p50 ~2%, p99 ~4%) due to gpu prefill parallelization.
cost impact: cost per request increases by ~100-200%. cost per correct answer increases by ~5-10% (due to accuracy gains offsetting token increase).
file location: none. output is returned as a string to be passed directly to the llm api call.
accuracy improvement: baseline accuracy increases by +15-40 percentage points for multiple-choice questions, +50-76 percentage points for position-based tasks, +5-15 percentage points for general long-context questions. research shows 67% of benchmarks (47/70) improved significantly (p < 0.1). zero cases of performance degradation observed.
latency change: user perceives no noticeable delay. server-side latency increases by 2-4% due to doubled input tokens, but gpu prefill is highly parallelized.
api behavior: llm returns correct answer on the second pass with higher confidence. typical pattern is that the first pass may miss nuance (especially for position data or options-first questions), but the second pass locks in the answer. marker presence in subsequent requests confirms technique was applied.
a/b testing confirmation: run side-by-side comparison on your own test set. measure accuracy of baseline prompts vs. repeated prompts. calculate improvement percentage. if improvement >= +5 percentage points, technique is working. if improvement < +5 percentage points, verify that model is eligible (lightweight, not reasoning) and task type is appropriate (not cot).