How to stop LLMs from overthinking and over-writing

Symptom: long answers, same result

A one-line arithmetic question comes back as a page of "let's work through this step by step". A list request turns into fifteen padded items. A coding agent "compares approaches" for minutes and then writes the fix it would have written anyway. You pay for the tokens, wait for them, and often have to dig the answer out.

The waste is measured. Reasoning models can spend 1500+ tokens on a question that needs 50-100 (AdvPrompt). In BenchOverflow, ordinary plain-text prompts across 9 models produced answers 3-10x longer than normal ones. In evaluation-awareness tests, "show the steps" and "be careful" made texts up to 10x longer, while accuracy moved by ±0.02.

This page is about cutting the excess. For when step-by-step reasoning is worth turning on, see the chain-of-thought and adaptive-reasoning technique pages.

Why it happens

• No built-in sense of task difficulty. Reasoning models apply the same long style to "2+3" and to a proof (AdvPrompt).
• Prompts carry deliberation signals. "Analyze", "as an expert", "consider all options" switch on reasoning even for a recall question (SynapseRoute). Models execute "compare several approaches" literally; in a preregistered coding-agent benchmark that phrase inflated reasoning tokens 2.4-7.4x on all six models while the final code did not change.
• Helpfulness reads "all" as "until the limit". Words like "every", "in detail" and "completely" push generation toward the cap (BenchOverflow).
• Exam cues trigger exam style. Rubric phrases look like evaluation, so the model pads; answer-only format compliance fell from 80% to 30% (evaluation awareness).
• Short prompts cause long answers. A telegraphic request leaves gaps the model fills in the output; cutting the prompt by 15% raised total cost 3-15%, and up to 2.7x in the worst cases (CAVEWOMAN).

Fixes ranked by measured effect

1. Route: reason only when the task needs it. Classify each request as SIMPLE (fact, list, definition) or COMPLEX (math, logic, trade-offs) and answer directly or with chain of thought. On 12,000 MMLU-Pro queries this gave +10.2% accuracy, -47% latency and -48% tokens versus always or never reasoning; on knowledge domains forced reasoning cost 5-10% accuracy (Selective Reasoning).
2. Remove deliberation triggers; add scope, done criterion and stop condition. The bounded template did not increase tokens on any of six models and halved spend on GLM-5.2 with the same result; "think deeply/carefully" cost 1.6-2.2x for nothing, while extra context cost almost nothing (×1.03) (bounded efficiency).
3. Compress the answer, not the prompt. Keep the request complete and add an output instruction: what to drop, what to keep, a structure template. Cost fell 1.4-2.4x with accuracy held across eight models, because output tokens cost 4-8x more than input (CAVEWOMAN).
4. Add a one-line brevity reminder. "Reminder: Please provide a concise, precise response without unnecessary elaboration" cut cap-hitting answers by 20-60% across 9 models with no quality loss on everyday prompts; closed models responded more reliably (BenchOverflow). Replace "all possible" with a number and a format.
5. Persuade, don't threaten. Authority-style and role-style brevity instructions compressed reasoning 63-78% on simple math with accuracy kept within 1%; threats managed 4-25%, and hard competition problems only about 20% (AdvPrompt). The paper's best prompt cites an invented study; an internal standard works as the authority instead.
6. Extract the givens, then solve. Structuring the facts first and solving from that alone cut tokens 2-3x without accuracy loss on wordy problems (Focused CoT).
7. Name the choice first. For picking from a set, choice on line one plus 2-3 arguments kept the +45% gain of brief reasoning; long reasoning fell below no reasoning (FR-CoT).
8. Cap reasoning where nothing can be verified. On motives and intentions, GPT-o3 dropped from 84% to 69% with more reasoning, and open questions without options gave +14-26% (slow thinking hurts); on ethics and strategy, extended reasoning cost 17 points across 7 models (meta-uncertainty regime).

A combined prompt stack

1. System level: a default style line (concise, facts and numbers, no preambles) plus a structure template for typical outputs.
2. Per request: write the task in full sentences; say whether it is SIMPLE or COMPLEX, or let the model classify.
3. For agents: scope, done criterion, stop condition; no "compare approaches", no "tidy up around it", and double-check technical hints, since a wrong one cost 2.6x tokens in the coding-agent study.
4. For choices: decision first, 2-3 reasons, then output. For judgment calls, limit to 2-3 steps and one main factor.
5. Exceptions: "brief, except code: write that in full", so compression never eats the part you need.

What does not work

• Telegraphic prompts. Saving input tokens raised total cost and lowered accuracy (CAVEWOMAN).
• Threat prompts. The weakest compression of the five styles (AdvPrompt).
• Expecting hidden reasoning to shrink. Visible text gets shorter, but models with an internal thinking block did not shorten it on request, and those tokens are still billed (CAVEWOMAN).
• Squeezing too hard. Word caps that are too tight skip needed steps; some benchmarks lost 1-3% accuracy at maximum compression (AdvPrompt). Even correct short answers took a different route about half the time, so check the logic in audit-style work.
• One fixed rule for every model. In the coding-agent study "think deeply" barely affected Claude Sonnet 5, while "maximum confidence" was its most expensive phrase (bounded efficiency). Test on your model.

You are a {role, e.g.: data analyst, developer assistant, marketer}.

Before answering a question:

1. Determine the task's complexity:
   - SIMPLE: a fact, a definition, a list, well-known information, a standard process
   - COMPLEX: math, logic, cause-and-effect, trade-offs, multi-step analysis, non-obvious patterns

2. Choose the response mode:
   - For SIMPLE → give a direct answer with no reasoning
   - For COMPLEX → use chain of thought:
     a) break the problem into parts
     b) analyze each part
     c) synthesize a conclusion

Question: {user_question}

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.

Answer {brevity_style}.
Remove: introductory phrases, repetition, "it's worth noting," explanations of the obvious.
Keep only: {what_to_keep}.
Answer format: {structure_template}.
{exception_if_needed}

{your_usual_request_unchanged}