Practical prompting, backed by research

The model reviews code, sees everything works — and still "improves" something. Not because it can't see reality. It's because in its worldview "changed nothing" = task not done. In the paper this was shown for coding agents on already-fixed bug reports; using it for document reviews is our extrapolation. The tested line: "If the issue is not present (anymore), report that and don't make changes. Otherwise fix the issue." — and the model switches from "must fix something" mode to "honestly assess whether anything is needed at all" mode.

The paradox: a model lies confidently not because it's dumb, but because in training "I don't know" never earned any points. For GPT-5 mini, this method cut the share of wrong answers among answered questions by about a third (52.3% → 35.5%), with zero fine-tuning, using a single prompt, but only with all three parts (confidence, scoring rules, honesty principles), and the model answered about 56% of questions instead of about 97%. The trick: you announce the rules of the game right in the request: correct answer +1, mistake −1, honest "I don't know" +0.4. The model recalculates the payoff and starts backing off where it isn't sure.

LLMs are too eager to please — they go along with the user's assumptions even when they're nonsense. Ask (our example) "given that nobody in tech hires after 35, should I move into management?" — and the model will likely accept the myth as a given and discuss the timing of the move, without saying the assumption is false. This is a pragmatics problem: by default the model is accommodating (it takes what's said in the prompt as fact) and doesn't exercise epistemic vigilance (critical evaluation of information). Two simple interventions help a lot: EXPLICIT ("check for false assumptions") and WAIT ("start with 'wait a minute'"). Both shift the focus — potential errors move from the background into the topic of the conversation. The result, averaged over six models: EXPLICIT nearly quadrupled how often medical myths were corrected and raised the safety-fact score by about 40%; WAIT gave smaller gains.

In academic mode, an LLM warns "this is correlation, not cause" 92–100% of the time. Same question, same data, but framed as "help me justify this for the meeting": down to 6–18%. A two-step causal audit gets you an honest breakdown of the data even when you're asking for practical advice, with no retraining of the model. The model doesn't lose its knowledge of causality; it hides it, assuming you want a plan, not a lecture. One follow-up sentence in the same chat brings caution back to 71–100%, and the effect is the same in Claude, GPT and Gemini.

LLMs don't know how to stay quiet. Hand one a vague assignment and it doesn't pause or ask — it confidently fills in the gaps and keeps going. In long chains, one early assumption drags dozens of wrong steps behind it. The Uncertainty Decomposition method lets you stop the model before its first action and force it to explicitly judge: is the task clear or not? The trick: the order of the XML tags sets the order of thinking — `` comes earlier in the text than ``, so the model physically can't skip past the clarity check. The upshot: instead of confidently heading the wrong way, you get one specific clarifying question.

An LLM improves its explanation over several rounds, but quality grows only for the first 3-4 cycles, then drops by 60-80%. The Agentic XAI method yields 30-33% better explanations of complex data: the model finds its own gaps, requests extra calculations and updates the answer. The trick: the model reflects on its own answer, asking "what did I miss?", generates analysis code, gets new data and rewrites the explanation. But after 4-5 rounds degradation sets in: answers get watery, drift into abstractions and lose specifics.

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.

Write "I'm sure my startup will take off" — the model agrees. Write "I'm sure it'll flop" — the model agrees again. The content didn't change; the confidence just pointed the other way. SWAY gives you five questions in one prompt that break this mechanism. The trick: don't forbid the model from flattering you — make it walk through the opposite assumption before it answers. After that step it can't just go along with your original tone anymore — the logic of its reasoning won't let it.

LLMs score work inconsistently: similar pitches get a 3 one time and a 5 the next. The reason: there's no explicit checklist, so the model relies on unstable intuition. The Reflect-and-Revise method turns a fuzzy rubric like "rate quality 1-5" into a structured system with concrete indicators and thresholds. The trick: the model scores examples → sees where it diverged from the reference → analyzes the patterns behind the gaps → rewrites the criteria. In 3-10 iterations the barest instruction becomes a detailed algorithm with mapping tables and explicit rules.

The LLM knows the right answer, but can't find its own mistake, even when asked directly. The trick: copy the dubious fragment from the answer and send it back as a new message, and correction jumps to 60–90% instead of nearly zero. Take a specific claim, paste it into a new message, write "you wrote this. Is it right?", and the change of source role does the rest. The model didn't get smarter. It just got an object it can point a finger at.

The paradox: inside its step-by-step reasoning the model computes the correct answer — and outputs the wrong one to match the consensus. Not a glitch, not a logic error. Agreeing is simply cheaper than arguing. The "Sovereignty Gap" method gets you genuinely independent analysis instead of a nicely packaged echo of your own opinion. The trick: remove any mention of consensus from the prompt + add an explicit ban: "don't factor in other people's opinions" — and the model stops cutting corners. Add a forced sequence (first the arguments for, then against, then the conclusion) — independence is locked in by structure, not by a plea to "think for yourself."

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%.

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.

A paradox: the model says "got it, fixing it now" — yet it just bolts new facts onto the old, already-wrong version of the answer. Rollback and two-phase prompting let you get a genuinely rebuilt answer after a clarification, instead of a patch slapped on the previous text. The trick — the command "forget all prior assumptions" cuts off the model's path to patching. The model writes great from scratch, but it's bad at revising a structure that's already in place.

Ask the model to "fix the answer" and it won't actually fix anything. It'll memorize the specific mistake and dodge that exact case, creating new problems elsewhere. It's like a student who crams answers to exam questions instead of learning the theorem — passes the test, falls apart in practice. Hourglass Reasoning lets you reproduce patterns from examples reliably: the model first explicitly describes the structure and the rule, then applies exactly those — instead of guessing by feel. The trick: only one pair (schema φ + rule T) passes between the four steps — the draft gets destroyed, and the error history never carries over to the next step. The model stops patching the output and starts updating the rule — these are fundamentally different operations.

Three different judge models accepted more than half of intentionally wrong answers. This isn't a bug in one model — all LLMs evaluate persuasiveness, not correctness. The de-anchoring method delivers an honest check: the model answers on its own first, then compares — no blind spot involved. The trick: the model locks in its own answer before it ever sees the text being checked. False positives drop from 72% to 1.2% — a 60x improvement, from a single structural tweak in the prompt.

The paradox: 'reason step by step' doesn't help when the context is biased — it even makes the result worse. The model builds a detailed justification for a judgment that's already skewed: the anchor fires before the logic even starts. Axiomatic Self-Elicitation gets you balanced recommendations from AI that aren't distorted by anchors like 'we've already invested the money' or 'everybody does it'. The trick: extract the domain principles in clean form — before the model sees the anchors in the problem statement. Locked-in principles create competing context — and beat the random framing. Bias drops by 51% on average, and by up to 73% for some types.

Four tasks out of ten, an LLM will carry out confidently — even when they're physically impossible to complete. Not because it wants to deceive — it's just that in training, "give an answer" was rewarded and "admit a limitation" wasn't. PSC gets you an honest diagnosis of the blocker before the model starts inventing data out of thin air. Just name four refusal categories in the system prompt — and the model switches from "how do I answer this" mode to "what exactly is in the way" mode. Result: a correct diagnosis 9 times out of 10.

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 same prompt trick works perfectly on GPT-5.x but cuts answer accuracy on GPT-4o — that's not a bug in the method but a fault line between model generations. The Self-Debate + Overconfidence Advisory method gives an honest confidence score — not round 90s and 100s but living numbers like 68% or 74% that reflect the model's real doubts. The model first argues with itself — gives arguments for, then against — and only then delivers a verdict with a number. Plus a direct warning, "you usually overstate your confidence," works as an anchor that breaks the habit of reporting verbalized confidence without thinking.

One phrase, "consider diversity," and the model starts inventing a patient's race that wasn't in the question. This breakdown of Demographic Injection shows when an equity instruction makes AI mix in nonexistent details, and how to block it with one line in your prompt. Without the phrase, the model fabricates demographics in 0.7% of answers; with the DEI phrase, in 33%, a 47-fold jump. The model confuses general statistics about a category of people with a fact about the specific person in the question, and in 99.8% of cases where the fabrication changes the answer, the answer becomes wrong. The effect held across all 47 models tested, from GPT-5 to small open ones.

Here's the paradox: the more context you give a model, the riskier its advice gets. Hallucinations jump from 1% to 4–12% precisely when context is partial. The model decides 'I know you well enough now' and stops asking questions. It starts confidently filling in the rest. The Severance Schema lets you get advice on important decisions without this false-confidence effect. The trick: six fields with an explicit [unknown] tag wherever data is missing — the model sees the shape of what it doesn't know and reacts to the gaps instead of silently papering over them.

LLMs are great at finding content in documents. The failures happen elsewhere. The model ignores hidden rules: formats, prohibitions, edge cases. Not because it can't see them. Because they're not activated as constraints during generation. PSCI lets you work with any regulation or technical spec and get answers that actually comply with every requirement — even ones scattered across 40 pages. The trick: split the task into two acts — first, full attention on extracting the rules, then generation under explicit control of that list. When the model gets the task "just extract all the rules," it recovers 94.4% of hidden requirements. The problem isn't capability — it's activation.

The paradox: Budget $2,500, item $2,502.50 (0.1% over) — the model refuses to buy. The task says "5 bullet points," the substance fits in 4 — it adds filler to check the box. LLMs suffer from literalism: they follow instructions blindly even when it's absurd. The RID Framework lets you teach a model to distinguish critical constraints from flexible guidelines — making decisions based on common sense rather than box-ticking compliance. The method provides a structured 4-step schema: separate the goal from the rule, classify the rule (Hard Constraint or Soft Guideline), weigh the consequences of both scenarios, make a decision. Everything happens in one prompt via `` and `

` tags. A zero-shot technique — works in a regular chat without fine-tuning.