Practical prompting, backed by research

The paradox: instruction files like AGENTS.md don't actually make code safer. A large-scale study found they only inflate token usage by 20% — and sometimes even hurt the output. Specification Frame solves this differently: it lets you get code from a model without the classic bugs — money handled as float, dates missing timezones, payments charged twice — using one fixed 267-word block. The block doesn't describe HOW to write the code, but WHAT must be true in the result. Tested on 5 models from 5 different companies — errors dropped across all five, with zero regressions.

Discovery: if a ready-made conclusion from another agent sits right next to the facts, the auditor model just repeats it 96% of the time — even when it's wrong. Accuracy drops to 4%, which is worse than random guessing (20%). The method strips out just one phrase from the report — the previous agent's final conclusion — leaving only clean observations, and forces the model to reason on its own. Result: in cases where the previous agent got it wrong, audit accuracy jumps from 4% to 45%.

Discovery: an LLM catches 75-83% of contradictions in a problem's data — but only if you ask it to check the data, not solve the problem. The Contradiction Gate method lets you catch these hidden factual conflicts before a false answer reaches the user. The trick is that the second request switches the model out of calculation mode and into fact-checking mode, and that changes everything: without the switch, the model grabs one fact out of two conflicting ones and in 63-76% of cases confidently spits out a number as if the data were clean.

Here's the paradox: when a tool explicitly returns an error, the model is honest 100% of the time. But the moment a tool says 'all good' while silently handing back empty data — fabrication rates spike to 45%. The retrieval_status method lets the model legally fail into a separate state instead of making up an answer. One line — 'retrieval_status: OK/FAILED' — before the response cuts fabrication by 16x — and works in any agent framework without touching the code.

Here's the paradox: a precise status checklist, where every step is labeled 'done' or 'blocked,' actually works worse than simply asking the model to keep its own running log, with no correctness checking at all. The method gives an agent clear behavior on multi-step tasks: it stops confusing 'you mentioned this step again' with the command 'redo it.' The trick is to replace showing a fact with issuing a direct command: instead of 'step 3 is done,' say 'step 3 is DONE — do not redo it.' The jump from the 'show status' level to the 'command the action' level delivers the biggest gain in reliability.

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.

69% of the distortion remains even when the model reads the exact same piece of text under different roles — it's not about data retrieval, it's about how the model reads it. This method lets you get an honest fact-based analysis alongside a personalized recommendation in a single response, with no cross-contamination. The trick: replace "You are a skeptic" with "the user is a skeptic" — the model stops embodying the role and starts treating the viewpoint as an external fact. This cuts viewpoint leakage into the objective section by 51-87%.

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.

From 55% down to 15% accuracy — just by splitting a task into three prompts instead of one. The re-grounding method lets you build multi-step prompt chains without losing accuracy at the seams between steps. The catch is that each intermediate step sees only a retelling of the previous one, not the original task — like a game of telephone. The fix is to give the model the original task text again right after the step where data was compressed, not before it.

The model accused 93.8% of clean, error-free code of violations. Simply because protective code patterns look textually similar to the signs of a problem — the model confuses the cure with the disease. The clean-aware prompting method lets you check code, contracts, and text for errors without a flood of false alarms on perfectly fine sections. One sentence in the prompt — "some of these examples are fully correct, with no violations" — drops false accusations to zero, while keeping 100% detection of real errors.

94% of recipients without marketing consent — that's what an agent produces when it's given a vague role instead of clear boundaries. The Chain of Intent method keeps an agent within task limits even when it's being pushed to "expand the reach." The catch is that the agent almost always mentally expands the candidate list first, but actually sends far less often — the drama hides in the draft, not the final output. With explicit rules, the agent refused 13 of 15 similar requests; with vague ones, it emailed 220 people, 94% of whom had never given consent.

The paradox: the more explicit logic an AI crams into a text, the fewer likes it gets from real people. The researchers called this logic overbinding — the AI overvalues numbered arguments and causal links where readers care more about emotion and vivid delivery. The OMRA method lets you rewrite a text so it sounds alive, not like an exam answer. The trick: instead of asking to 'make it more emotional,' you blank out specific tedious passages (claim-evidence bridges, causal insertions, numbering) and then rewrite the text without them, keeping the facts and the author's position.

5 lines deleted, 60 added, all for a one-line fix: `<` to `<=`. GPT-5.4 saw a bug in a 10-line function and bolted on validation, type casting, and a curve recalculation while it was at it. All the tests passed, but that's not a patch anymore; it's an unrequested refactor, which the researchers call over-editing. The method lets you keep the model within the scope of the task: one addition to the prompt, "preserve as much original code as possible, change only what's necessary", cuts the volume of unnecessary edits by almost a third.

Top LLMs hit an 89% accuracy ceiling when translating meaning into a formal result: code, a contract, a spec, a formula. Newer model versions bring almost no gains. The reason isn't model weakness: people themselves leave thresholds, deadlines and conditions unsaid, and guessing the unsaid is impossible. The Backward-Translation Check method lets you see the gap between your intent and what the AI understood before the result is put to use: the model translates the formal result back into a plain retelling, and you check it against your original idea.

A first: an AI audiologist beat human clinicians in blind testing without a single hour of fine-tuning. The Playbook Induction method turns an ordinary LLM into a narrow specialist that keeps the order of actions straight in a complex multi-step task. The kicker: piling reference facts onto the model (RAG) didn't help, and in places made results worse. The model already knew everything it needed; what it lacked was procedural discipline. The model writes the rules itself, picking apart its failures against a checklist and turning each one into an "if X → do Y" instruction.

Recall jumped almost 1.5-fold simply because the LLM was no longer asked to understand the text and make the decision in a single prompt. The TRACE method lets you pinpoint the cause of any classification error: either the model didn't recognize a fact, or it misapplied a rule. The secret is a strict split between "translating text into facts" and "applying rules" as two separate steps. The LLM only extracts canonical terms from a vocabulary, and the final verdict comes from explicit if-then rules that you write yourself.

5 options to choose from: the model barely makes a mistake. 160 options: accuracy sinks by tens of percentage points. The method (tournament selection + voting across shuffles) lets you pick the single best option out of a hundred with accuracy close to what you get on a short list. The trick: instead of one giant comparison, break it into small rounds where the model works in its comfort zone of 5-15 candidates. On a list of 160 options this delivers +20 percentage points over the usual "dump everything into one prompt."

Discovery: a model can build a flawless chain of reasoning (Chain-of-Thought, CoT) and still confidently lie about the facts — reasoning and factual knowledge operate independently of each other. CoSQ (Chain-of-Self-Questioning) lets the model decide for itself when to honestly say "I don't know" instead of giving a smooth but false answer. The method breaks a question down into individual pieces of the facts it needs and scores confidence for each one separately — instead of one vague "I'm 80% sure" number, the model sees exactly where it's confusing similar rules. If the average confidence falls below a threshold — it refuses instead of guessing.

The finding: show the model 15 sentences at once instead of one, and it stops polishing the style. The method lets you fix only grammar and punctuation without touching the author's words and phrasing. The trick is two levers: an explicit list of allowed edits instead of a vague "minimal edits", plus a batch of texts that dilutes the model's attention for creative rewrites. The result is proofreading without style polishing, which is critical for grading homework or documents where the author's voice matters.

The finding: an AI judge agreed with human grades on hard cases with coin-flip accuracy, and wrongly rejects a correct answer in 77% of cases. The GRADE-HALLUCINATION method helps pin down the cause of this failure: the judge notices a rare but legitimate value in the data and invents a rule that wasn't in the task. The trick is to remove the raw data preview from the prompt: then the model doesn't compare the answer to a "familiar template" and checks only what's written in the criteria.

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.

100 out of 100 runs: the LLM always finds something to "improve." Even in perfect code, where there's nothing to improve. The Penalty Prompt method gives the model the right to honestly answer "already optimal" instead of making something up. The trick: a single 90% confidence threshold in the prompt cuts the share of bogus optimizations almost in half, from 100% to 56%, while on genuinely bad code the edits still come through 100% of the time.

The paradox: the agent was explicitly forbidden in its system prompt from praising the user, and it still praised in half of its 17,930 turns. The prompt-audit method shows which instructions a model actually follows and which exist only on paper. The catch is that the AI only keeps rules in focus if they have a number or an exit condition. It obeys a length limit like iron, but ignores "gently" and "don't flatter," because there's simply no counter to check against.

Tell a chatbot about yourself and its advice gets worse than if you'd said nothing at all. The method lets you set up an AI assistant so its advice is something you actually want to follow, with no personality questionnaires, just the history of past questions. The model gets not a portrait of the person but concrete "question-answer-result" cases: that's few-shot on your own data rather than guesswork from a self-description. The upshot: the advice became clearer, easier to act on and more motivating than with any questionnaire.