Practical prompting, backed by research

Finding: an LLM doesn't just agree with a bad idea, it invents convincing reasons why it's good. This is called agreement bias: the model sees your text, takes it as a given and starts rationalizing. The SGV method lets you squeeze out honest, sharp criticism instead of the stock "not bad overall, but there's room for improvement." The trick: make the model describe what success looks like before it has seen your work. In the paper (AI judges checking agents' work on web, computer and robot tasks) this caught up to 25 percentage points more failures; using it on texts is our extrapolation. Then the "yardstick" is already set, and there's no way to bend it to fit your text.

The paradox: LLMs get hijacked through external text, and the same LLM can scan that text. PromptArmor lets you use any language model as a security guard for itself: no fine-tuning, no setup, no API keys. The trick: first ask the model to find hidden commands in the text, then give it the cleaned text for the main task, and the success rate of prompt injection attacks drops to <1% instead of the typical 70-80%.

The longer and more complex the document, the worse one big prompt works. The model tries to cover everything at once and starts making things up. The TTD-DR method (Test-Time Diffusion Deep Researcher) lets you build accurate, detailed reports iteratively, with no fine-tuning and no special tools. The key: start with a deliberately incomplete draft, not a request for the final text. The draft reveals the holes. You fill the holes with real data. The model stitches the data back in, and the draft gets more accurate. Three or four rounds like this turn a sketch into a polished document.

An LLM doesn't forget instructions at random; it systematically ignores the ones at the end of the prompt. It's not a bug and not a fluke. It's a stable pattern: the model's attention flows top to bottom and runs out. Controlling instruction order lets you build prompts where critical requirements always get met, even when there are lots of instructions. The trick: put the most important things first: the role, the main goal, the key format requirement. Anything at the bottom the model may skip: not mix up, but outright skip. Those are fundamentally different errors.

41% → 96% accuracy: the difference between "figure out what to do yourself" and "here's your plan." Routine lets you reliably execute complex multi-step tasks without skipped steps, freelancing or losing context halfway through. The trick: you move the planning outside the model. You lay out the task step by step right in the prompt and specify a concrete action for each step. The model no longer spends resources on "what do I do next?" and focuses purely on execution. From 41.1% to 96.3% on GPT-4o with one structured prompt.

The problem: an LLM agent takes 15 steps on a complex task and messes up on step 7, and you only find out once it has "finished" everything. All that work, wasted. Magentic-UI lets you insert yourself into the process at every meaningful step: first you ask for a plan and edit it, then the agent moves forward but stops at the right points and waits for your approval. The shift: you don't write one giant prompt hoping for a miracle; you take on the role of project manager, and the LLM becomes a contractor who reports back at key stages. The interaction stops being a lottery.

That complex prompt you spent an hour writing can lower a powerful model's accuracy — not raise it, actually lower it. That's the main finding from testing 23 prompting techniques on 12 different models. The relationship is direct: the stronger the model, the worse it tolerates multi-step instructions — it kicks into something like "overheating," where extra directions get in the way instead of guiding. The study gives a clear rule: choose your prompting strategy by model strength, not by task complexity. For top models (Claude 3.7 Sonnet, GPT-4 Turbo), a minimal, clean prompt. For budget ones (GPT-4.1-mini, Claude Haiku, Llama 3), two moves that significantly boost accuracy: Step-Back and Rephrase.

The fastest way to improve an LLM's answer is to ask the same LLM to tear it apart. This method turns any draft into a polished result with no new tools and no fine-tuning. The gist: split the task into three steps: first a draft, then critique from a specific role ('now you're a skeptical investor'), then a revision that addresses the comments. The trick: diverse critic roles matter more than how many critics you have. 'Critique this as a marketer, then as a lawyer' delivers sharper, more useful critique than three identical viewpoints. Repeat the loop 2-3 times: each iteration adds another layer of polish.

The paradox: the main problem with LLMs working on text isn't hallucination, it's silence. What the model found, it reports accurately. What it missed, it never admits. You'll never know what you lost. Customized prompting lets you pull a specific set of facts out of any text with minimal omissions instead of getting a creative retelling. The trick: role + focus list + output template turn the model from a reader into a checklist scanner. Instead of "extract what matters," three concrete layers of instruction, and extraction recall goes up by 15%.

An LLM writes weak text not because it doesn't understand language, but because you never explained what you consider a good result. The CRMAgent method lets you consistently get text better than the originals: for announcements, newsletters, product descriptions, posts, cover letters. The key: make the model first study good and bad examples and derive the principles of success, and only then write by those principles. Not "rewrite it nicely," but "figure out what nice means, then write from that analysis."

Two virtual agents arguing inside a single prompt deliver +7.95% accuracy while saving 58% of tokens vs 5-7 API calls. INoT gives you deep logic checking through an internal debate instead of expensive external iterations (as in CoT or IoT). Pseudocode sets a strict loop: argument → critique → rebuttal → adjustment. The LLM follows this structure like a program, writing from the perspective of two opponents. Consensus within 10 rounds instead of 7 calls to the model.

After every model upgrade, prompts start to misfire, and it's not a bug but a pattern: new LLMs follow instructions more precisely but are worse at filling the gaps you didn't spell out. The prompt migration method lets you write requests that hold their quality through any version change. The essence: turn the prompt from a request into a spec with explicit sections: role, instructions, format, data. Each part goes in its own XML tag, so the model sees a clear map and stops guessing which parts are commands and which are context. This removes the main cause of post-upgrade failures: confusion between data and instructions.

LLMs don't stumble on complex tasks. They stumble on tasks with extra conditions, the ones that have nothing to do with your specific case. The WARPP method lets you strip out irrelevant rule branches in advance, before the model starts working rather than after it gets confused. The trick: before the main task, a separate "personalizer agent" studies the context and throws everything extra out of the instruction, so the main agent gets a simplified task and handles it more accurately and reliably. The key point: you can play that agent yourself, no code required.

Asking an LLM to "rate this text" is like asking a random passerby to rate your work. You'll get an opinion. Not much use. The study showed: add a codebook with criteria and examples to the prompt, and the LLM evaluates at the level of an experienced expert. The method lets you use an LLM as a consistent reviewer for any text: résumés, business emails, pitches, posts. The trick: the model doesn't guess your standards, it follows them if you've written them down. Add a rubric before the task, and the model stops guessing and starts following patterns. The result: ratings become predictable and comparable to expert ones.

An evaluator model is biased by default: it more often picks whichever option comes last in the prompt. That's positional bias, and it quietly breaks any attempt to get an objective judgment. Pairwise comparison lets you use an LLM as a reliable judge when picking the best code, text or idea, with no scales and no random noise. The trick: instead of 'rate it from 1 to 10', use 'pick the better of the two in one prompt', plus a bias check: swap the options and run it again. If the model changed its pick, the first answer was biased, not analytical.

Complex XML prompts burn 6 times more tokens (348 vs. 54) yet deliver the same result. The paradox: the simpler the structure, the more horsepower the model puts into content instead of parsing instructions. 5C Prompt Contract strikes the balance: control like DSL languages, creativity like a free-form prompt, with several times fewer tokens. The trick: instead of XML tags and multi-level templates, 5 simple blocks in one prompt. Character (role), Cause (goal), Constraint (boundaries), Contingency (fallback plan if something is unclear), Calibration (output format). The model grasps the structure instantly, no extra words — token savings AND rich output (777 output tokens vs. 833 for a free-form prompt).

The model ignores your requirements not because it's bad, but because it's trying to write and track 10 rules at the same time. That's too much for one step. Re5 gets you an answer that meets every constraint, even from a weak model. Three stages: draft → self-check against a checklist ("met / not met" for each point) → targeted fixes. Splitting the roles into Doer → Checker → Editor gives you a reliable result where a single-prompt approach inevitably drops some of the conditions.

The finding: it's not just WHICH examples you give the model, it's WHERE they sit in the prompt. The method gets you stable, accurate answers from example-based prompts just by changing the structure of the request, without touching the content. Examples first, question last: the model first "tunes in" to the format and logic you want, then tackles the task. Examples placed after the question throw the model off, and answers become unpredictable and less accurate.

The paradox: detailed examples ("here's how to do it right, now do the same") lose to simple forced reasoning out loud. Step-by-step decomposition classifies texts more accurately and reliably, without a single example in the prompt. Forbid the model from answering right away: make it first pull facts out of the text, then match them against the criteria, then explain its logic, and only then answer. The model stops guessing and starts analyzing, and classification reliability jumps several-fold.

Finding: by default an LLM looks for the “average” answer, the one most people would be fine with. That's exactly why its advice comes out vague: it fits everyone and no one. ALIGN lets you give the model a specific worldview, from a cautious lawyer to a thrill-seeking venture capitalist, with no fine-tuning and no extra setup. Add a paragraph with a role and core values at the start of the prompt and the model stops hunting for a “universal” answer. Instead it looks for the best answer within your system of priorities.

The "I'll translate it into English so the model understands better" strategy isn't a life hack, it's a source of errors. This was proven on Dutch medical documents: every time the text was run through translation before analysis, accuracy dropped, consistently and significantly. The method lets you work with documents in any language without intermediate steps. Translation loses information before the model even starts thinking: professional vocabulary, nuances, and idioms vanish at the input. Modern large language models (LLMs) are trained on huge multilingual datasets; they understand your language directly, and that's always more accurate than going through a middleman.

Finding: an LLM agent doesn't check reality; it generates the most likely continuation. Does the context hint that the previous step succeeded? The model will grab onto that, even if the opposite is written right next to it. MIRAGE-Bench lets you pin down the exact type of failure: the model distorted the instruction, ignored the action history, or invented data about the current situation. Agent hallucinations aren't random noise but three specific breakdowns, and you can close off each one with a separate rule right in the prompt.

Try to do two things at once and you do neither well. An LLM asked in one request to both run an analysis and output strict JSON stumbles on both: either the syntax breaks or the conclusions come out half-baked. Two-stage prompting gets you both solid reasoning and error-free structure, in a single prompt. The trick: first let the model talk it through in plain text with no formatting, then ask it to structure the thoughts it already has. The model switches from "think" to "fill in the template," and you get 4x fewer errors.

The more a model "thinks", the worse the summary. Reasoning models (specially trained for step-by-step reasoning) lose to plain GPT-4o at dialogue summarization: more fluff, more factual errors, a weaker grasp of the gist. The "Direct Request" method gets you accurate, short digests with no retelling and no extra words. Strip every "think step by step" out of the prompt and ask for the result right away: this activates synthesis mode instead of retelling mode. It works in any chatbot with no setup at all.