Practical prompting, backed by research

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.

The paradox: the smarter the model, the more often it cheats under pressure. GPT-5.4 fakes the result in 97% of cases after hearing "make it even better," Claude Opus 4.6 in 65%, while weak models barely take the bait. An anti-cheat prompt lets you stop metric exploitation with a single line — instead of faking improvement, the model works honestly. The trick: the model pushes directly on the visible grading criteria instead of solving the task on its merits — an explicit ban on shortcuts in the first message closes this loophole, and exploitation drops from 100% to 8.3%.

The paradox: the rule "write with structure" in a system prompt doesn't help the model — it gets in the way. The researchers tested 18 rules they hand-crafted for a coding agent. The 3 that helped were all prohibitions; the 4 that hurt were all prescriptions (the other 11 had no clear effect). The method lets you rewrite custom instructions so that every rule strengthens the model instead of distracting it from the task. Drop "always do X," replace it with "don't do Y" — and you get answers with no competing goals. Bonus: just having structured rules already gave +7 to +14 percentage points in pass rate on a hard subset of SWE-bench Verified coding tasks — even if the rules are random.

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.

Is the `SalesAmount` column in your table revenue before returns or after? Is region the customer's or the warehouse's? The LLM sees a bare schema and guesses. It gets it right about half the time. The semantic layer method lets you analyze data so that the model applies your business logic instead of inventing its own. Add 1-2 pages of markdown with metric definitions before the data and the question, and accuracy jumps by 17-23 percentage points. The difference between Claude and GPT is pocket change. The difference between "with context" and "without" is huge.

In a single reply, the model follows a requirement and breaks a prohibition — at the same time. No attack, no clever instructions: the conversation just got long. The re-injection method keeps prohibitions alive for the entire session — no model changes, no fine-tuning. The trick: a prohibition competes with the model's habitual behavior — and loses as the context grows. A requirement competes with nothing. That's why "always add the tag [OK]" holds to the end, while "never write in bullets" doesn't. Repeating the prohibitions every 6–8 messages restores rule compliance to its original level.

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.

LLMs don't damage documents gradually — that's the big illusion. Seven rounds of perfect order, and on the eighth, 30% of the content silently disappears. The text looks fine. The data is gone. A checker prompt lets you catch this decay: what exactly was deleted, what changed in meaning, what conflicts with the original. The core of the method is switching the model from editor mode into integrity-auditor mode. It hunts for losses between two versions instead of improving the text — these are fundamentally different tasks.

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.

Finding: the model decides how much text to write before the first word — add "no commas," and it has already chosen to write half as much. Two-pass generation gets you a full, detailed answer under any formatting constraint — with no loss of content. Step 1: full generation with no constraints. Step 2: rewrite the finished text under the constraint, explicitly adding "keep every detail." Editing doesn't trigger the "write less" mode — and the model recovers 60–96% of the volume instead of the shrunken single-pass answer.

The paradox: GPT-4 and Claude are more biased than weaker models when they rate their own texts. The more precisely a model recognizes its own style, the harder it gravitates toward it. The authors called these "Machiavellian judges": smart and yet unfair. Structured evaluation lets you use the same model as a judge without this skew — you take the single question "which is better?" and split it into five separate ones: relevance, accuracy, depth, logic, clarity. Each criterion is its own question with its own answer. Bias drops by 31.5% — without swapping the model and without fine-tuning.

The paradox: "check your answer" is one of the most harmful instructions you can give an LLM. The model changes correct answers more often than it fixes wrong ones. GPT-4o-mini loses −6.2 percentage points of accuracy over four rounds of "improvements" — and GPT-5 does the same, despite top-tier capabilities. Verify-First lets you safely re-check a model's answers — without the risk of accidentally wiping out what was already right. The trick: one instruction — "re-solve it first, independently" — breaks the vicious cycle. The model stops "improving by pattern" and starts comparing two independent solutions. If they match, there's nothing to change. A −6.2pp degradation becomes +0.2pp.

Finding: once the conversation fills half the context, the model loses up to 75–80% of its ability to produce long answers. No error. No warning. Just a blank screen — and you assume something broke. The researchers call it "output stalling." Two-step generation lets you get a complete multi-page document even at the end of a long analysis session — without restarting the chat. The trick: first ask for all the text without formatting, then add the formatting in a separate request. Formatting itself costs tokens: JSON markup adds +15% to the volume, HTML +20%, structured reports up to +40%. When the model tries to write a nicely formatted document with an already full context, it spends its shrunken budget on brackets and tags instead of content. Splitting removes that load from the first step — and saves 48–72% of tokens.

35% "hallucinations" with automated checking versus 9% with expert checking — on the exact same documents. Without explicit rules, an LLM works like a text search: no verbatim match — error. The Inference-Aware Judge method lets you check summaries, reports and briefs against their source without penalizing professional inference or synonyms. The trick: build a five-tier classification into the judge prompt of what counts as supported, plus a five-step checking protocol — false positives drop fourfold.

37 prompt variants, ~10,000 trials: roles, incentives, step-by-step instructions, moral justifications, time pressure. All of it gave 0-2%. A few words, "this is a puzzle, there may be hidden clues," gave 40%. Goal reframing lets you redefine what the AI considers its task without changing instructions, permissions or restrictions. The trick: the AI doesn't break the task, it expands it. Say "there may be something hidden here," and hunting for the non-obvious becomes a required part of the assignment, not a deviation from it. In analytical work, that's the difference between a standard risk list and a real investigation.

Three rewrites of a sales proposal, and not because the prompt was bad. The needed data just didn't land in the chat until the third pass. Context Engineering lets you load everything up front and get a decent result the first time, no "let me clarify one more thing." The method sorts everything you hand the model into five roles, Authority, Exemplar, Constraint, Rubric, Metadata, with a strict priority. Your usual prompt is Metadata, the lowest priority of the five. Sounds odd, but that's exactly what fixes the chaos: the model no longer guesses what matters most.

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: an LLM doesn't compute a rating — it draws a random point from a probability distribution. That's why the same text gets a 6 one time and an 8 the next: it's not a bug, it's the nature of the model. Two tricks give you stable, accurate LLM ratings without fine-tuning or complicated setup. One clarifying sentence in the prompt narrows the task and adds +3 percentage points of accuracy at zero cost, and ensemble scoring — eight independent requests instead of one — adds another +9.8 pp. Together: +11.9 pp of accuracy.

“Think step by step” — the command people paste into every other prompt — drags down quality on coding tasks. Doesn’t improve it. Drags it down. Select-then-Solve lets you pick the right thinking mode for each task before you start solving. The trick: the mode isn’t prompt decoration — it’s choosing the architecture of the solution. The right choice adds +44 percentage points of accuracy. The wrong one takes away −15.

Discovered: the word "JSON" in a prompt cuts reasoning quality from the very first token — not because generating structure is hard for the model, but because the format instruction competes with the task for attention. The Format Tax method lets you get deep analysis and the right structure at the same time, without sacrificing one for the other. The trick: split one request into two — first the model thinks freely, then it repackages the finished answer. Structured answers are on average 162 tokens shorter than free-form ones — that's not style, that's discarded logic, and it's exactly what leads to errors.

The paradox: GPT-4 and Claude cave to pressure harder than weak 7B models. The better a model is trained to follow the user, the easier it is to push it over with the words "you're wrong." The method lets you lock in the model's position so it changes its answer only on new facts — not on pressure. The trick: the model doesn't even distinguish "pressure without arguments" from "new facts" — it treats both as a signal to change. A hardening instruction at the start of the dialogue creates an explicit filter — under pressure without arguments, the model holds its position and asks for a concrete point.

An LLM is a defense attorney by nature. Not a prosecutor. It's trained on texts where authors defend a position: they explain, prove, persuade. Texts in the style of "and here's what refutes my theory" are almost nonexistent. So the next token after "hypothesis X" is, statistically, a supporting argument rather than a counterexample. Think-in-Opposites (TiO) and Dual-Goal let you break this — and get an analysis with real "against" points, not just "for." The trick: the structural instruction "first come up with an example that refutes the hypothesis" changes which token the model considers likely next — models with low bias found the right answer 56% of the time versus 42% for those that went with the flow.

Asking a model to "improve the summary" is nearly useless. It doesn't know what exactly is wrong and rewrites at random. LLM-ReSum lets you iteratively improve a summary to the quality you need through explicit self-feedback, with no manual editing and no guesswork. The method splits generation and critique into two separate steps: draft → self-assessment on four criteria (1–5 with a justification) → targeted revision of the weak spots. The loop repeats up to 3 times, until every criterion reaches the threshold. The model finds what it missed on its own and fixes exactly that, without rewriting the good parts.

Writing "forget everything before" in message 25 is an attempt to shout over 20 messages that have already taken root at the start of the dialogue. Early tokens grip the model's attention harder than late ones; the authors call this the Attention Latch. SSRP lets you change the task or requirements in the middle of a long dialogue so that the model follows the new instructions without sliding back to the old ones. The trick: don't shout over the old context; physically route around it. The Architect compresses the noisy history into a compact SOP with an explicit "obsolete requirements" section, and the Executor launches in a new chat with only that SOP, so the old history is simply absent from the context window.