Practical prompting, backed by research

The paradox: A model can fix an error 95% of the time but can't find it. Ask it to 'improve this text' and you get cosmetic edits and a plateau at 30% quality. Give it a list of 3-5 specific notes and the model reaches 90-98%. A 3x gap. The method lets you get high-quality revisions of content (text, code, presentations) through guided iteration instead of a useless 'try harder'. The trick: move diagnosis outside the model. You say WHAT to fix (item A, item B), the model repairs it with 95% execution accuracy. It doesn't guess what's broken; it works through a clear list.

Ask an LLM to check its own answer for errors and it misses 67% of hallucinations. Ask point-blank 'is anything inaccurate here?' and the model answers superficially, like an expert asked in passing. HalluClean lets you detect hallucinations in already generated text: fact-checking answers, summaries and dialogues. The trick: split the check into 4 explicit steps. The model first drafts a verification plan (what and how it will check), then executes it step by step with reasoning, delivers a verdict and fixes the problem spots. F1 accuracy rises from 33% to 68% on the same GPT-3.5.

An LLM reports 90% confidence even when its real accuracy is 60%. The problem: the model picks an answer and rates it in isolation, without seeing competition from the other options, like a lawyer who only notices the arguments in their client's favor. The Verbalized Probability Distribution (VPD) method gets you an honest confidence estimate from the model by forcing it to analyze every alternative. Instead of 'give an answer and your confidence' → 'distribute probabilities across all options so they sum to 1'. The constraint creates a zero-sum game: to give one answer 80%, the model has to 'take' those points from the others. This triggers deep analysis of each alternative, and the confidence becomes calibrated (90% from the model now means 90% real accuracy, not 60%).

The paradox: show the model a concise example and it writes concisely. Ask it to "improve error handling" and it bloats the answer as if the examples never existed. This method lets you hold a code style even when you ask for revisions, not just on the first turn but across 2-3 iterations. The trick: few-shot examples set the shape but don't create a rule. They work as a template for the first answer. Explicit instructions ("write the minimum, no docstrings if the name is obvious"), however, act as operational constraints that the model applies on every generation. The combination gives -70% tokens up front and minimal bloat on revision.

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.

The paradox: an LLM is better at critiquing other people's answers than at generating correct ones of its own. The reason is autoregressive egocentrism: the model clings to its first draft and defends it instead of looking for errors. Verification-First breaks that defense: it makes the model check someone else's answer first (even an absurd '1'), which switches on critical thinking instead of defensiveness. The trick: checking someone else's answer turns off defense mode. The model looks for contradictions, writes out equations, builds counterexamples, and that structure leads to the right solution. +5-7% accuracy on math from adding one line.

Ask an LLM to solve a business problem and you'll get a mashup of Medium posts and Hacker News threads. That's not creativity; that's averaging the training data. Universe of Thoughts (UoT) lets you generate unconventional solutions for ill-defined problems (business strategy, innovation, product design). The trick: the model doesn't look for a solution inside the familiar domain but steps outside it: it finds structurally similar problems from other fields, takes their solutions apart into components, and plugs them into your problem. For maximum creativity, it changes the rules of the problem itself.

Finding: LLMs are catastrophically bad at counting words on the fly: ask for 100 words and you get 80 one time, 150 the next. The model doesn't track how much it has written. Plan-and-Write lets you generate text with a precise word count (ask for 50 = get exactly 50, not 45 and not 55). The trick: the model counts not "in its head" but through explicit numbering: first a draft `1:word 2:word 3:word...`, then a clean copy between tags. Accuracy up to +37.6%, especially on texts under 500 words.

The paradox: The more context you give a model, the worse it performs. Feed it the question + a big table at once and the model "forgets" parts of the question. A multi-hop request ("calculate X, then compare with Y") turns into an answer about X only. TabDSR lets you get accurate answers to complex questions about tables, especially when you need several calculation steps and the data is dirty ($3,275, "N/A", notes in parentheses). The method's trick: it splits the process into three independent steps. The decomposer breaks the question into sub-questions (it works ONLY with the question text and ignores the table). The sanitizer cleans the junk out of the table (currency symbols, percent signs, footnotes). The reasoner generates Python code for each sub-question. Each step covers a separate LLM weakness instead of trying to do everything in one prompt.

Intuition says: the more times a model re-checks itself, the more accurate the result. The data says the opposite. After 1-2 iterations self-correction stops working: accuracy plateaus or drops. The method shows where to stop re-checking. In text generation the model starts to drift after 2 iterations: it rewrites correct passages, adds fluff, wanders off topic. In multiple-choice tasks (A, B, C, D) the model gets stuck on its first option: if the first pick is wrong, reasoning almost never changes it. The sweet spot: one targeted re-check, then stop.

Finding: LLMs recognize a transformation rule (for example, 'if headcount grew 2.5x → licenses grow 2.5x too'), but 55% of the time they don't apply that rule to their answer. The model is like a student in an exam who can explain the formula but ignores it in the calculation. Derivation Prompting makes the model explicitly trace the link between the first and second question through three mandatory steps. The trick: three steps create a forced chain: you can't answer step 3 (apply the change) without doing step 1 (what changed) and step 2 (what change should follow). Result: +15.2% accuracy, beating Chain-of-Thought and Few-Shot.

Finding: a model can be 90%+ sure of a wrong answer and, without outside critique, stick to it. The study logged 577 such cases. The CRAwDAD method lets you find and fix errors in causal reasoning: telling correlation from causation and stress-testing logic through argument. Two models argue until consensus (4 rounds max). The first gives a structured answer + a confidence percentage. The second looks for holes in the logic and critiques it. If they disagree, rounds of arguments and counterarguments follow. The paradox: even a strong model gains from arguing with a weak one. Qwen3 starts out more accurate than DeepSeek-R1, yet debating it still gives Qwen3 +5% accuracy. The weaker model gains even more: +9%.

Finding: LLMs "lock onto" the first plausible option: they build reasoning for it alone and drop the rest without analysis. BiasPrompting lets you make well-weighed decisions when choosing among several alternatives: the model explores every option, not just the first one it stumbles on. The trick: make the model find arguments FOR every option, even an absurd one. The model defends each as if it were definitely right. Then, with all the arguments in front of it, it picks the most convincing.

Ask an LLM to do several things at once and you get filler like 'check the logs' or 'review the changes'. The study showed that 98.3% of answers to a single comprehensive prompt were this vague. Sequential decomposition fixes it: you split one complex prompt into a chain of three simple ones. Each does one thing; the output of the first goes into the second, and the second into the third. The model stops spreading its attention across several tasks, and you get concrete actions instead of generic phrases.

The problem: LLMs are bad at checking their own reasoning. Ask "find the mistake" and you get "all good" or something vague. An error in step 3 breaks everything after it, but the model can't tell you exactly where it messed up. SSR lets you find weak spots in multi-step reasoning (financial models, math, logic problems) by checking each step individually. The trick: split the solution into sub-questions and have the model re-solve each one 3-5 times without knowing it's a check. The model thinks it's solving new problems. If the answers disagree, that step is unreliable. Disagreements pinpoint the error more precisely than "look at the whole solution".

Finding: GPT-4o grades written work almost like a human, with a 0.98 correlation. But there's a skew: it grades lower in 39% of cases and higher in only 6%. The method lets you automate grading of tests, essays and reports transparently: the model doesn't just assign a score, it explains every deduction. The trick: a reference answer + a fixed set of scores + a requirement to justify. The model doesn't invent a scale; it works within boundaries. Result: 55% exact agreement with instructors.

The paradox: 10 of 15 "obvious" improvements to product descriptions (FAQ, technical language, authoritative tone) lower your position in AI search. The E-GEO method lets you rewrite descriptions so that AI assistants (Amazon's Rufus, ChatGPT with search) rank your product above the competition. The key: make relevance explicit. Instead of "premium knives for connoisseurs" → "solves the problem of dull knives you sharpen every week". An LLM doesn't get subtext; it looks for direct matches with the user's query.

The paradox: a short 170-token summary works more accurately for Q&A than the full 11,000-token document: 0.80 vs. 0.76 F1. The reason: models suffer from the "lost in the middle" curse. Information in the middle of a long context gets ignored. The Chain of Summaries method lets you build dense summaries that cover all of a document's key facts without the noise. The trick: not a single "shorten this text" but a self-check loop: generate questions about the original → check whether the summary can answer them → fill in what's missing. Repeat 5-10 times. Each loop closes gaps, so the summary grows under the pressure of the questions.