Practical prompting, backed by research

The paradox: Forced thinking (reasoning before replying) in conversational tasks makes results worse. GPT-5 drops 6%, Gemini-2.5-Pro 37% in customer support. The method helps you see when NOT to use popular techniques like ReAct and Chain-of-Thought. Thinking turns agents into "introverts" — they start thinking to themselves but stop disclosing information to the user. Instead of "this item can't be cancelled on its own — only the whole order; you also have X in your cart, what would you like to do?" the agent writes "do you want to cancel?". The user acts blind → wrong decision → task failure.

An LLM confidently names the IPO year of a company that never went public at all. The problem: the model can't tell knowledge from a guess, so it generates plausible text either way. Standard checks ('Are you sure?', an instruction to 'say I don't know') fall flat: the model either stays overconfident or abandons correct answers. DBA (Disagreement-Based Abstention) lets you detect unreliable answers without fine-tuning or external sources, and it works in a regular chat. The mechanics: ask one question two ways, directly and broken into steps, then compare the answers. If the answers differ, the model is unsure, so don't trust it. If they match, that's a good sign: for Gemini Pro, correct answers occurred about 50 times as often among agreeing cases as among disagreeing ones (2-10x for 30-70B models; a ratio of counts, not accuracy).

Finding: LLMs lose 30-60% of their quality in multi-turn conversations, but context length isn't the problem. The model makes an early assumption about your goal and gets stuck on it, even when you clarify. The Lost in Conversation (LiC) phenomenon explains why you end up rephrasing a request 3-4 times — and offers a way to fix it. The root cause is that the model guesses the intent of the 'average user' from its training data. But real people express themselves in their own ways — the same phrase means different things to different people. The fix: separate understanding the intent from executing the task. An intermediate layer rewrites the vague request into a clear instruction based on your communication patterns. Then the model executes against a clear spec — the quality drop shrinks from 60% to 15%.

Same meaning, different form — and the model changes its position. Write “I'm convinced that X” and it agrees. Ask “is X true?” and it may push back. The Ask Don't Tell method gets you a real critical teardown of your ideas instead of thinly veiled compliments — even when you're clearly in love with the idea and it shows in your request. The trick isn't asking it to “be honest” — that works less well. The trick is asking the model to first rephrase your statement as a question, then answer it. It strips away the “agree” signal itself — before it starts generating the answer.

The paradox: "Think like Steve Jobs" makes ideas more boring, not more original. "Steve Jobs" is a super-dense center of the model's knowledge: innovation, design, Apple. The model gravitates there and produces the predictable. The CoT + ordinary personas method yields idea sets that, in the study, turned out more diverse than human brainstorming. The trick: you don't need celebrities — you need "a divorced kindergarten teacher from Toledo." A specific, ordinary biography anchors the model in an atypical corner of its knowledge — a place it would never go on its own.

66 percentage points — that's the gap between the conclusions of a skeptical and an optimistic LLM analyst working on the exact same data. Not a hallucination, not a mistake. Both are methodologically sound — the skeptic clusters deviations and weights the regression, the optimist drops outliers and simplifies the specification. The framing simply decides which analytical chain the model launches. Multiverse analysis lets you see the shape of the uncertainty instead of the illusion of a single correct conclusion. You run one question through three analysts in parallel — skeptic, neutral, optimist — and look at the distribution of conclusions. Where all three converge, you can trust it. Where they diverge, you need data, not yet another LLM opinion.

The paradox: Stuffing everything into the prompt is worse than giving the model files and search tools. 9,649 experiments on SQL generation showed that frontier models (Claude, GPT, Gemini) became +2.7% more accurate when they looked up data in files via grep/read instead of reading it from the prompt. But for half the open-source models, files killed accuracy: Qwen and Llama Maverick lost up to 22%. The trick: a navigable knowledge base instead of a monolithic context. You spread information across files (schema.yaml, rules.md, navigator.md) — the model finds the relevant chunk on its own and reads only that. It fixes "lost in the middle" and saves tokens.

Self-Critique delivers exactly 0% improvement on half of the unfinished projects. That's not a bug; it's the method's boundary. The framework lets you pick a code-improvement strategy that works instead of trial and error. The decision framework is a 'failure type → method' map: logic gaps (a forgotten function) → Self-Critique (the model spots them in review); external integration (RabbitMQ not configured) → RAG-Assisted (drop a tutorial into the context). The evidence: Self-Critique 0% vs. RAG 100% on integration, across 18 experiments on real GitHub projects.

The model doesn't double-check its past answers — it trusts them. MIT and IBM researchers removed the assistant's answers from real conversations and found that quality either held steady or improved. The method gets rid of "error drift" — when the model drags bugs, hallucinations and unwanted style from past iterations into every new answer. The kicker: 36% of questions in real conversations don't need the AI's past answers at all — for them a fresh chat works just as well, and often better. Three words that break the chain: "start from scratch."

The paradox: the smarter the model, the worse it holds neutrality. The study documented a structural failure: top LLMs change their analytical conclusions on the very same data if the request contains an indirect hint about the desired outcome. You don't need to say outright "I want to hear YES" — it's enough to phrase the request with the right slant. The neutral-frame method lets you get an analysis driven by the data, not by expectations baked into the wording. The trick: add "don't guess which answer I want" and "conclusion last" — the model stops adapting to the context and builds the logic before the verdict, instead of fitting the arguments to an answer it has already guessed.

Finding: On procedural tasks, LLMs rely on linguistic patterns: “sounds right” instead of “formally correct.” On symbolic tasks without semantics (blocks with names like “1jpkithdyjmlikck”), the model gets lost: no familiar words, nothing to latch onto. o1 scored 31.5% accuracy. TMK (Task-Method-Knowledge) lets you switch the model from probability-based guessing to formal manipulation, the way it works with code. Instead of a prose description of the task, you give a three-layer JSON structure: Task (why, the goal), Method (how, steps with explicit dependencies), Knowledge (what we know about the domain). The model sees a structure with `require`, `provides`, `given`, `makes` fields. It resembles pseudocode with clear “if X then Y because Z” logic. With TMK, o1 hit 97.3%, a gain of 65.8 percentage points.

LLMs are bad at finding errors in a continuous block of their own reasoning. Asked to point to where things went wrong in three paragraphs of Chain-of-Thought, the model misses the real first error 40-50% of the time. Thought-ICS solves this with a discrete structure: the model reasons one thought at a time with explicit boundaries between steps, which lets it pinpoint the first error and roll back to a clean prefix for resampling. The key point: each step is a deliberate decision about the next complete thought. That creates natural points for analysis. Large models get a clean rollback (no inherited errors) 97% of the time, versus much less on continuous CoT. Result: a 20-40% accuracy gain over regular Chain-of-Thought.

The paradox: The researchers gave GPT-5 the Idris language docs — it solved 30 of 56 problems. Gave it a reference guide — 34. Pasted in the actual compiler errors and asked for fixes — 54. The difference isn't knowledge, it's the format of the feedback. The method lets you get precise results even with 10+ hard requirements (character limits, banned words, mandatory items) — exactly where a model usually lets something slip. The gist: use any strict verifier (compiler, linter, validator, tests, checklist) that gives precise feedback. The model generates → the verifier finds a problem → you paste the error into the prompt → the model fixes it. Repeat 3-15 times until it passes every check. From 39% accuracy on the first try to 96% after iterating.

The paradox: You tell the model 'that's wrong, try again' — it acknowledges the mistake, but its next solution structurally copies the failed one. This explains why the iterative 'show the error → the model fixes it' approach works worse than you'd expect. A wrong solution in the context acts as an anchor. The model builds on its structure when generating a new answer. The attention mechanism latches onto the reasoning pattern from the history, even if the model has verbally admitted it was wrong. Performance drops by 10-20% for strong models, up to 50% for weak ones.

The finding: An LLM repeats the same mistakes across 10 independent attempts: forget an edge case in the first and it'll forget it in the tenth too. The cause: each generation happens in isolation, with no mechanism for passing knowledge between attempts. TRT lets the model learn from its own failures right while it's solving the problem, with no fine-tuning or external verification. The method works in cycles: generate solutions with different strategies → pick the best → extract an insight from the failures → pass the knowledge list to the next round. The model sees what has already failed and avoids repeating it. The result: open models hit 100% on AIME-25/24, and closed models gained +10-15 points on hard programming tasks.

An undergrad solves a problem with 99% accuracy while GPT-4o drops by 47%: same problem, just reworded. Logical obfuscation lets you check whether a model really understands the logic or just recognizes a familiar pattern from its training data. The trick: reword the question in a logically equivalent way ("A is B's father" → "A is the only son of B's grandfather"). If the answers differ, the model isn't reasoning, it's recognizing surface phrasings. Accuracy drops of up to 47% (GPT-4o) and 27% (o1) on tasks that stay trivial for a human.

The paradox: the better AI handles a task, the faster you lose the ability to handle it without AI. The Explanation Gate closes the gap between "the AI did it" and "I understand it" — right in the flow of work, with no extra courses or cramming. Before using an answer, explain it in your own words while the AI grades the depth: fall short of level 3 out of 5 and you get a leading question instead of a ready-made solution. The group that used the method showed 61.5% success versus 23.1% for those using AI without restrictions — 2.5x better.

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.

A model loses track of criterion independence when you score 5+ dimensions in one prompt. You get the halo effect: a high empathy score drags the ethics score up, even though they're different things. The Multi-Agent Framework lets you accurately score complex subjective criteria (pitches, essays, interviews) by splitting the task. The trick: instead of one prompt saying "rate on 9 criteria," you run a text cleanup + 9 separate agents. Each agent gets 3 examples for fine calibration (low/medium/high score) and scores only its own criterion. Agents never see each other's scores, so the criteria don't interfere with each other.

Zero. Without an explicit request for references, not one of the 10 models tested invented a single citation. Source hallucinations aren't a model defect, they're a response to the request: ask for sources and the model switches from reproducing facts to generating plausible-looking lines. The method weeds out phantom references before the final check, shrinking a list of "50 questionable" down to "8 probably real." Real sources reproduce consistently; fabricated ones are random and don't repeat. Ask three times, take the overlap, and accuracy climbs from 16% to 96%.

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 gets stuck on the first strategy it finds and drags it all the way to the end — even when the intuition is wrong. It's a greedy approach: the model doesn't explore alternatives, it commits to its first idea. DIP lets you produce a high-quality plan by synthesizing several draft approaches — instead of a single strategy or expensive multi-sampling. The trick: use the LLM's inductive capacity — its ability to synthesize patterns from examples. The model creates 5-7 different approaches to the task, expands each into a plan, then induces the final plan from all the drafts. 2-3x cheaper than Self-Consistency at comparable quality.

The paradox: you add examples to a prompt → jailbreak defense (protection against bypassing LLM safeguards) both rose by +4.5% and fell by -21.2%. It depends on the prompt type. The method lets you properly configure a chatbot's defense against provocations — not every prompt can be strengthened with examples. The trick: RoP ("you are a safe assistant") + few-shot examples = the role gets stronger. ToP ("follow these rules") + few-shot = the model's attention spreads across the examples and the instructions get lost. Tested on 9 models, 6 attack types, 4 benchmarks — the result is stable.

Personal context in a prompt always makes the answer warmer. Always. But honesty is a different story. The twist: the same words about yourself make AI more precise as an advisor and softer as a critic. The method lets you manage this on purpose: add a persona when you need precise advice, drop it when you need tough critique. The mechanics are simple: the model knows who you are, so it predicts what you'll like. That helps the advisor. It stops the critic from hitting the weak spots.