TL;DR
Researchers tested how specific wording in a prompt affects the hidden "reasoning tokens" (what models like Claude, DeepSeek and Kimi spend on internal deliberation before answering) in AI agents that write code. It turns out some everyday phrases inflate those costs several times over without improving the solution one bit.
The headline finding: the phrase "develop several approaches and compare them before choosing" is the most expensive of everything tested. It raises reasoning-token spend by 2.4–7.4x on all six models checked, and this held up even on hidden, never-before-seen tasks. The model dutifully starts "juggling options in its head," even though the final solution comes out exactly the same as if it had been asked for one solution right away. Phrases like "think deeply" and "think carefully" have a similar effect — the model honestly spends longer deliberating, but the result doesn't change.
The fix is simple and free: a template with explicit task boundaries — what exactly to change, what the done criterion is, when to stop. That prompt doesn't increase token spend on any model, and on one of them (GLM-5.2) it cut spend in half at the same result quality.
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.
Findings at a Glance (what hurts, what's safe, what helps)
HARMFUL: "develop several approaches and compare" → ×2.4–7.4 reasoning tokens, quality unchanged
HARMFUL: "think deeply / carefully" → ×1.6–2.2 tokens, quality unchanged
RISKY: "tidy up around it", "act autonomously" → the model wanders into files outside the task
EXPENSIVE: wrong technical hints in the prompt → ×2.6 tokens (the model chases a false lead)
SAFE: verbosity, extra context, repetition → nearly free (×1.03), no need to skimp on explanations
HELPFUL: "scope + done criterion + stop condition" template → free, sometimes saves up to 2× tokens
Example in Action
Task: You ask Claude Code (or ChatGPT/Claude in extended-thinking mode) to fix a bug in an online store's discount function — it goes negative when the coupon is bigger than the order total.
Bad prompt (gut instinct — "the more detail, the better"):
Explore several different approaches to fixing this problem, compare their pros
and cons, and pick the best one. Think step by step and check everything carefully.
If you see anything else nearby that could be improved, fix that too.
Prompt using the "bounded efficiency" method:
Task: the calculate_discount() function returns a negative discount
when the coupon is larger than the order total.
Scope: change only the file discount.py. Do not touch any other code.
Done criterion: the test test_discount_negative passes,
and no other tests break.
Stop condition: as soon as the tests pass, stop.
Do not look for extra improvements and do not suggest alternative solutions.
Result: The first prompt makes the model "juggle options in its head" — you'll see a longer wait and more reasoning tokens spent, and the final fix will be the very same. The second prompt delivers the same (or a better) result faster and cheaper — the model won't spend resources on an imaginary comparison and won't change code outside the specified file.
Why It Works
Reasoning models follow instructions literally — if you ask them to compare several approaches, the model honestly starts generating that comparison internally, even when the final answer doesn't change because of it. That's not cleverness or depth of meaning — it's extra text you're asking it to produce, and it's billed like any other tokens.
The strength of these models is that they respect explicit boundaries and stop conditions well. Tell them precisely what to do and when to finish, and the model won't "keep mulling" beyond what's needed.
The method exploits this: by removing triggers of excess reasoning ("compare," "think deeply") and adding a clear stop signal, you give the model a reason to finish earlier — with no loss of quality.
Control knobs: - Remove phrases like "compare several options," "consider different approaches" → token savings, if you don't need the comparison as an output - Add a "done criterion" and a "stop condition" → the model doesn't redo what already works - Remove "tidy things up," "act autonomously" → the model doesn't touch code outside the task (this is the only category of phrases that expands the scope of changes) - Don't fear long, detailed prompts → extra text barely raises the cost, so there's no need to skimp on explaining context - Verify technical hints before putting them in the prompt → a wrong guess about the architecture is the most expensive thing of all — the model conscientiously follows the false lead
Prompt Template
Task: {short description of the problem}
Scope: change only {specific files/functions}.
Do not touch any other code.
Done criterion: {what must work / which tests must pass}
Stop condition: as soon as the criterion is met, stop.
Do not look for extra improvements and do not suggest alternative solutions.
Fill {short description of the problem} with the concrete gist of the bug or task, {specific files/functions} with the exact boundaries the model is allowed to touch, and {done criterion} with a clear sign the task is solved (a test passes, the function returns the right value, etc.).
🚀 Quick start — paste into the chat:
Here is a prompt template for a lean, precise request to an AI coding agent.
Adapt it to my task: {your task}.
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask about the specific files, the done criterion and the task boundaries — because those three things are exactly what strip away the model's excess "reasoning" without hurting quality.
Limitations
⚠️ Task size: the effect was measured on small tasks (up to 4 files). On large projects the result may differ — the researchers say so directly.
⚠️ The model matters: on newer "frugal" models (e.g., Kimi K3) the relative effect is stronger (the "think deeply" phrase inflates spend ~15x), though absolute token spend still stays low — don't panic over percentages, look at the real numbers.
⚠️ The tool matters more than the prompt: the same prompt can cost 5–30x more depending on which interface you work through (e.g., Claude Code versus other agent shells) — that's not always in the user's hands, but it's worth knowing when you pick a tool.
⚠️ Cache discounts aren't efficiency: if a provider shows your bill went down thanks to caching, it doesn't mean the model got more efficient — it does the same work, you're just charged less for the repeated parts of the prompt.
How They Studied It
The team took six large "thinking" models (DeepSeek, Kimi, Nemotron, GLM and others) and ran them through two different agent interfaces on 24 deterministic coding tasks — with hidden tests the agent can't see while working. In total they collected more than 4,600 valid runs costing about $166 in real spend.
A key design detail: all hypotheses and thresholds for "what counts as harmful" were locked in before the researchers looked at the results — that guards against fitting conclusions to the data. Some findings were additionally checked on 8 tasks that played no part at all in selecting the "harmful" phrases — and most effects held up.
The biggest surprise: when the new Kimi K3 model came out a few days later, the team tested it straight out of the box using the same protocol — and although the relative effect of harmful phrases was even stronger (the model is "frugal" by default, so any extra instruction stands out more against its baseline), absolute token spend stayed at or below that of the previous models. An important lesson: relative growth percentages can look scary, but you need to look at the absolute numbers.
They also tested the effect on the closed model Claude Sonnet 5 through the official API — and most findings replicated, though an interesting detail emerged: the "think deeply" phrase barely hurts this particular model (it decides on its own how much to think), while the phrase about "maximum confidence in the solution" turned out to be the most expensive there.
Resources
Sarel Weinberger, Amir Hozez (PointFive). "Prompt-Induced Waste in Large Reasoning Models: A Preregistered Two-Harness Benchmark of Coding Agents", July 2026. Code, tasks, prompt variants and usage logs are published: github.com/sarelWeinberger/prompt_efficiency