Practical prompting, backed by research

Ask a model to "develop several approaches and compare them before choosing" — and it dutifully inflates reasoning tokens by 2.4–7.4x. The final code doesn't change by a single line. The bounded efficiency method lets you cut these hidden costs without losing quality — just by removing trigger phrases and adding clear task boundaries. The "scope + done criterion + stop condition" template doesn't increase tokens on any of the six tested models, and on GLM-5.2 it cuts spend in half with the same result.

LLMs fail at complex tasks — accuracy drops from 46.6% to 8% (WebChoreArena). The reason: cognitive overload. The model tries to search for information, apply filters, count and plan the next step all at once — it loses focus and misses important things. WEBDART lets you solve multi-step tasks with many sources and filters by decomposing them into three sequential stages. The method's trick: a conservative strategy — first collect EVERYTHING (don't filter while collecting; that's where errors come from), then structure the data into a table, and only then apply the constraints. Each stage focuses on one skill, lightening the load on the model.

The longer and more complex the document, the worse one big prompt works. The model tries to cover everything at once and starts making things up. The TTD-DR method (Test-Time Diffusion Deep Researcher) lets you build accurate, detailed reports iteratively, with no fine-tuning and no special tools. The key: start with a deliberately incomplete draft, not a request for the final text. The draft reveals the holes. You fill the holes with real data. The model stitches the data back in, and the draft gets more accurate. Three or four rounds like this turn a sketch into a polished document.

41% → 96% accuracy: the difference between "figure out what to do yourself" and "here's your plan." Routine lets you reliably execute complex multi-step tasks without skipped steps, freelancing or losing context halfway through. The trick: you move the planning outside the model. You lay out the task step by step right in the prompt and specify a concrete action for each step. The model no longer spends resources on "what do I do next?" and focuses purely on execution. From 41.1% to 96.3% on GPT-4o with one structured prompt.

The paradox: giving a model more room to reason when picking from a ready-made set breaks the result. Think a little — accuracy jumps +45%. Think longer — the model falls below the "no reasoning at all" level. FR-CoT keeps accuracy at the peak when choosing between options with one simple rule. The trick: the model names its choice on the very first line — before any explanation. This isn't style — it blocks "sliding" into another option along the way. Accuracy stays at the peak, with no made-up options.

Finding: LLMs spend up to 50% of their tokens on filler: restating the conditions, "let's break this down", switching approaches instead of solving. F-CoT cuts token usage 2-3x with no loss of accuracy. The method splits the work into two stages: first extract the facts from the problem into a structured format (numbered XML tags), then solve over that distilled version only. The model never sees the original text; it works from a compact context. Result: straight to the solution, no spinning its wheels in verbosity.

For hard problems, reasoning saves the day; for summarization, it kills. The model starts creatively reinterpreting instead of compressing faithfully. The study shows how to pick a strategy for the task: when you need style (Self-Consistency), when you need accuracy (GPT-5 with built-in reasoning), and when a simple prompt with examples is enough. A hard trade-off: explicit strategies (SC, IR) add more generative steps → reads better, but higher risk of speculation. LRMs (O1, O3, GPT-5) add more checks → more accurate facts, but drier text.

That complex prompt you spent an hour writing can lower a powerful model's accuracy — not raise it, actually lower it. That's the main finding from testing 23 prompting techniques on 12 different models. The relationship is direct: the stronger the model, the worse it tolerates multi-step instructions — it kicks into something like "overheating," where extra directions get in the way instead of guiding. The study gives a clear rule: choose your prompting strategy by model strength, not by task complexity. For top models (Claude 3.7 Sonnet, GPT-4 Turbo), a minimal, clean prompt. For budget ones (GPT-4.1-mini, Claude Haiku, Llama 3), two moves that significantly boost accuracy: Step-Back and Rephrase.

The fastest way to improve an LLM's answer is to ask the same LLM to tear it apart. This method turns any draft into a polished result with no new tools and no fine-tuning. The gist: split the task into three steps: first a draft, then critique from a specific role ('now you're a skeptical investor'), then a revision that addresses the comments. The trick: diverse critic roles matter more than how many critics you have. 'Critique this as a marketer, then as a lawyer' delivers sharper, more useful critique than three identical viewpoints. Repeat the loop 2-3 times: each iteration adds another layer of polish.

10 reasoning steps at 90% accuracy each — overall accuracy is just 35%. This isn't theory. It's the math of compounding error, observed in real production systems at Trane Technologies. An error in the first step drags all the following ones with it — and the answer looks plausible but rests on guesswork, not facts. The study produced five prompt techniques against this effect — no fine-tuning, no code, no complex infrastructure. The most effective one (100 wins out of 100): stop feeding the model raw data — add context to every parameter: what it is, what's normal, what's a fault. The model doesn't need to guess. It just reads and applies.

The paradox: Reasoning models (GPT-o3, DeepSeek-R1) can "think slowly" — which helps in math and code. But on tasks about understanding people (Theory of Mind) the longer the model thinks, the worse the result. GPT-o3 dropped from 84% to 69% accuracy when given more time to reason. Qwen3-8B-Reasoning (trained specifically to think long) lost to plain Qwen3-8B. The method lets you read people's motives, intentions and reactions more accurately in negotiations, conflicts and review analysis. The trick: cap the reasoning length at 1000-1500 tokens — the model doesn't drift into convoluted deliberation and stays focused. An open question with no answer options gives +14-26% accuracy — the model derives meaning instead of matching words to ready-made options.

Same example, two different results. Paste it in ready-made and the model mostly ignores it. Ask the model to generate it right in the same prompt and accuracy goes up. Integrated Prompting lets you dig deeper into hard problems without ready-made examples or fine-tuning. The trick: everything in one request. The model first invents a similar problem and solves it, then takes on yours. Freshly created reasoning sits "close by" in the context. The model leans on it 2–3 times more actively than on someone else's text. A warm-up from its own solution works; a copied example barely does.

One sentence at the end of any prompt — and the model stops "drifting" toward the answer. The Post-Reasoning method gets you a concrete conclusion right away, without the usual preamble "it depends on the context, but on the one hand...". The trick: add "First give the final answer, then justify it" — and the model, knowing it'll have to explain itself afterward, words its very first token more precisely. Works in 88% of the 117 tested model-task combinations — free, no fine-tuning, one line.

An LLM writes weak text not because it doesn't understand language, but because you never explained what you consider a good result. The CRMAgent method lets you consistently get text better than the originals: for announcements, newsletters, product descriptions, posts, cover letters. The key: make the model first study good and bad examples and derive the principles of success, and only then write by those principles. Not "rewrite it nicely," but "figure out what nice means, then write from that analysis."

Ask an LLM the probability of the same event twice and you'll get two different numbers: 55% and 75%. No logic involved, just guessing dressed up as expertise. AuditForecast lets you get a stable, checkable forecast that doesn't shift from question to question and that can be challenged step by step. The method separates the base rate from individual news-based adjustments — each adjustment gets its own multiplier, and at the end all the odds are simply multiplied together.

LLMs hand out confident advice on hard questions (fire an employee, take an offer, change contract terms) because that's how most advice on the internet is written: quick reasoning, ready-made recommendation. No "who else gets hurt" or "tell me what you don't know," just a confident answer looking in one direction. Narration-of-Thought (NoT) gets you an honest breakdown of any hard decision, with a list of everyone affected and an admission of uncertainty, before the model tells you what to do. The trick: five sections run strictly in order, and the model can't reach "Decision" until it has filled in "Stakeholders" and "What I don't know". It's a structural lock, not a request to "think deeper."

They removed every fact from the prompt — and accuracy went up. Not a single new fact, only structure: from 30% to 85%. That's not a bug — it's architecture. The LLM sees "100 meters" → triggers the "close → walk" pattern → outputs an answer, even if the purpose of the trip is written two lines above. The STAR framework lets you steer the reasoning where it needs to go — by stating the goal explicitly before any conclusions are drawn. STAR forces the model to first write "Task: get the car to the car wash" — and every following word is generated with an eye on that line, not along the shortest path from the question to the first convenient answer. Structure beat context by 2.8x.

The finding: an LLM picks each parameter so that it's "locally plausible", but taken together they don't fit. Ask for a product launch strategy (category + price + region + ads + budget) and the model gives you a premium segment in secondary markets, betting on organic reach, with a $2K budget. Each parameter sounds reasonable on its own, but together it's nonsense. TAFC (Think-Augmented Function Calling) fixes this with a forced generation order: explanation first, value second. The model can't spit out a parameter right away; it has to fill a [THINK_PARAMETER] slot with the selection logic. When it generates the value, its own explanation is already in context, and the model tries to stay consistent with what it just said. The result: parameters are consistent with each other, and you can see how the decisions connect.

An evaluator model is biased by default: it more often picks whichever option comes last in the prompt. That's positional bias, and it quietly breaks any attempt to get an objective judgment. Pairwise comparison lets you use an LLM as a reliable judge when picking the best code, text or idea, with no scales and no random noise. The trick: instead of 'rate it from 1 to 10', use 'pick the better of the two in one prompt', plus a bias check: swap the options and run it again. If the model changed its pick, the first answer was biased, not analytical.

"Think step by step" is prompt engineering's favorite mantra. On open-ended questions it knocks accuracy down by 17 percentage points. The method shows when reasoning helps and when it breaks the answer — and how to match reasoning length to the task type. A model can't check its own logic where there's no verifiable correct answer. On ethics or strategy, each new reasoning step pulls the position in a different direction. A short answer in 2-3 steps beats a sprawling analysis of 6-8 aspects.

The paradox: asking a model to solve a problem five times isn't verification. It's the same mistake paraphrased five times. If the reasoning has a systematic flaw, it reappears in most attempts. CoT-PoT gets you a genuinely verified answer on math and calculation problems — in two requests instead of the usual 5-40: first the model reasons in words step by step, then it writes and runs code. The trick: verbal analysis and code fail in different ways — when both give the same answer, that's agreement between two independent systems, not chance. 78.6% of problems are settled with exactly two requests.

The paradox: detailed examples ("here's how to do it right, now do the same") lose to simple forced reasoning out loud. Step-by-step decomposition classifies texts more accurately and reliably, without a single example in the prompt. Forbid the model from answering right away: make it first pull facts out of the text, then match them against the criteria, then explain its logic, and only then answer. The model stops guessing and starts analyzing, and classification reliability jumps several-fold.

LLMs are terrible at inventing solutions from scratch — but brilliant at picking from a ready list. That's not luck, it's architecture. HCoT gets you a structured breakdown of hard open-ended problems — not "it's probably the market" but "pattern 2 plus pattern 5, here's why and what to change." The trick: give the model a catalog of 6–16 patterns BEFORE it starts thinking — and "come up with a cause" becomes "pick from 10 options." Three steps: Abstract (generalize) → Match (find the pattern) → Refine (tailor to the situation). Accuracy goes up, and answers are specific instead of generic advice.

You asked the model to "think step by step" before coding and got reasoning that's logical but functionally wrong. An LLM optimizes for how plausible the text sounds, not for whether the algorithm is correct — hence hallucinated reasoning ("I'll handle the edge cases", and then the code doesn't). Structured CoT gives a rigid template with slots instead of free-form musing: problem analysis → algorithm → implementation. The model answers concrete questions ("Which edge cases?", "Which checks?") — the template works as a checklist, cutting off irrelevant reasoning. 85-95% of deep reasoning's accuracy for 10% of the tokens, +11% over a plain prompt on hard tasks.