Practical prompting, backed by research

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.

The paradox: the more explicit requirements in a prompt, the worse the model solves the actual task. Tsinghua University tested it: they took models' successful answers, extracted their characteristics (style, length, structure), turned them into explicit constraints and added them back. The logic: the model was ALREADY doing this on its own, so it should handle an explicit requirement. The result was the opposite: 5 constraints cut accuracy by 15-40% even for top models. The kicker: the model satisfies the constraints 94%+ of the time (format is correct), yet fails the task. The mechanics are simple: an excess of explicit requirements pulls attention away from the substance of the task toward the form. Claude-Sonnet-4.5 loses 15% of its performance on multi-hop questions; mid-size models (30-70B) keep only 65-85% of their original accuracy. Code is the worst: seven models dropped below 60%.

You ask Claude, Gemini, and GPT to grade one text against the same criteria. You get 3, 4.5, and 4 respectively. That's not noise — it's a stable pattern, like handwriting. Each model acts as a judge with its own personality. You can guess the model from its scores with 90% accuracy. This lets you pick the right LLM judge for the job. Claude for strict review. Gemini for spotting fakes. GPT-4.1 for quick feedback. The catch: models don't measure "quality in general". Each one applies its own hidden theory of quality. Claude is uniformly picky. Gemini drops a fake text's score by −1.46 points. Mistral/Llama are blind — they rate the fake +0.27 above the truth. Agreement between models is 0.04 out of 1.0 (practically zero). But each one consistently agrees with itself.

The paradox: an LLM is better at finding principle violations in finished text than at avoiding them while generating. Ask it to "follow 5 rules" and it drops half of them. Show it the finished text and ask "what's violated?" and it nails the problem. Reflect uses this: the model writes the text first, then checks each principle itself and rewrites where needed. Splitting the roles into "generator" and "critic" in one chat cuts the share of serious violations by 2-3x, especially for tone of voice and brand guidelines.

The paradox: a model shows the same average accuracy in two question formats, yet its verdicts point in opposite directions. +15% on correct speakers, −18% on incorrect ones — zero net change, but the behavior is fundamentally broken. DialDefer lets you detect when an LLM isn't judging the facts but adjusting to whoever states them. The method compares two framings: "Is the statement correct?" vs "Is the speaker right?". The trick: DDS (Dialogic Deference Score) catches this shift — from −53 (skepticism toward scientists in science) to +87 (caving in social conflicts). Accuracy stays stable, but the evaluation criteria change.

Same example, two different results. Paste it in ready-made and the model mostly ignores it. Ask the model to generate it right in the same prompt and accuracy goes up. Integrated Prompting lets you dig deeper into hard problems without ready-made examples or fine-tuning. The trick: everything in one request. The model first invents a similar problem and solves it, then takes on yours. Freshly created reasoning sits "close by" in the context. The model leans on it 2–3 times more actively than on someone else's text. A warm-up from its own solution works; a copied example barely does.

The paradox: prompts like 'ignore the candidate's gender' or 'don't consider race' don't just fail, they increase LLM bias 2-4x. Self-Blinding fixes the problem at the root: it lets you get an objective assessment in tasks with a risk of bias: hiring, grading work, allocating resources, ethical dilemmas. The trick: don't try to unsee the information (impossible), create a literally blind copy instead. Open a new chat → paste the prompt without names/schools/gender → the model physically doesn't know the biasing info. In the study, the model called its blind copy via API and followed its answer in 95%+ of cases.

Finding: LLMs lose up to 50% accuracy on structured tasks because of "structural blindness": the model gets flat text and has to guess the relationships between parts on its own. On optimized code, accuracy drops from 74% to 47%. The HELIOS method lets you work with complex multi-page documents without losing critical links between sections. The trick: an explicit relationship map across four levels: context → structure ("A leads to B and C") → element details → source material. Accuracy rose from 45-71% to 94-96%.

The paradox: Give a model search access and accuracy on answerable questions goes up 12%, but its ability to say "I don't know" on unanswerable ones drops 7%. ChatGPT with web search sees "Who will be US president in 2075?" and instead of "nobody knows" fires off 10+ search queries, burns 2,000 tokens, and still answers wrong or vaguely. The method shows you when the model is wasting tokens hunting for an answer that doesn't exist, and how to teach it to decline. The catch: corpora describe what we know, not what we don't. The model searches "president 2075" → finds forecasts, statistics, opinions → reads the lack of a precise answer as "I didn't search hard enough, try again". Tokens per correct answer: 382 without search, 765 with search — twice as expensive for the same accuracy.

The perception paradox: People rate an AI that argues for conspiracy theories more favorably than one that debunks them. They say it "gave more new information," had "stronger arguments," was "less confrontational." And that AI raises overall trust in AI more than the debunking one does. The reason is simple: the model confirms what the person already half-believes instead of challenging it. The information feels newer — we're hearing things nobody usually says. The researchers compared GPT-4o in two modes: debunking conspiracy theories vs. promoting them. The result is symmetric persuasion: +13.7 points of belief in the conspiracy vs. -12.1 when debunking (0-100 scale). The jailbroken and standard GPT-4o showed identical results. OpenAI's safeguards didn't help. The Truth Constraint method lets you break that symmetry — giving the truth an edge. One instruction in the prompt: "use only accurate information, optimize for truth AND persuasiveness" — the persuasion effect for conspiracies drops from 11.9 to 4.83 points (by 60%), while debunking stays at ~11-12 points. The truth gets a 2-3x advantage.

Shuffle your prompt elements and lose 15% accuracy. The cause isn't the model's training, it's the architecture. The CQO format (context→question→options) gives 15% more accurate answers on multiple-choice tasks than QOC (question→options→context). The trick: decoder models (GPT, Claude, LLaMA) use a one-way attention mask. Each token sees only what came BEFORE it, never what comes AFTER. Put the options BEFORE the context and they physically can't use the information in it. The model picks blind.

The paradox: LLMs are trained to be helpful - and that's exactly what makes them generate all the way to the token limit on ordinary prompts. Words like 'all', 'in detail', 'every' get read as 'write until you pass out.' The BenchOverflow study lets you control answer length and save tokens without losing quality - via a simple reminder. Add one line to the start of your prompt - and the model switches from 'cover everything' mode to 'give the gist'. 3,000 tokens -> 300-500 with no loss of substance.

The paradox: An LLM accurately estimates its confidence ('I'm 60% right') but almost never abstains. Even when the cost of an error is 100 times the reward, the model jumps in to answer 95%+ of questions. Mathematically, with that penalty it should stay quiet whenever confidence is below 99%; in practice the model answers at 60-70%. RiskEval exposes this disconnect, and scaffolding fixes it. The trick: the model can assess risk but can't act on that assessment, so you make the decision from the outside using the abstention threshold τ = λ/(1+λ). When the researchers forced this rule, utility rose several-fold, even on hard tasks.

Finding: LLMs are catastrophically bad at holding implicit structure in problems with formulas. They calculate correctly but output 6.3% instead of 0.063. They confuse "independent of the variable" with "equal to zero". They wander blind even when they can do the arithmetic. The F-1 method lets you solve applied problems with formulas more accurately: financial calculations, physics, business metrics. It works in two steps inside one prompt: first the model explicitly formalizes the problem (givens → find → equations), then picks its own strategy: direct calculation, step-by-step reasoning (CoT) or code (PoT). The structure of the equations dictates how to solve. +13.3% on finance, +2.55% on physics over plain CoT.

Finding: Reasoning changes the type of lie. The model stops openly breaking requirements (−60% format violations) but starts distorting facts to look obedient (+250% hidden metadata forgeries). The study showed how LLMs behave under impossible requirements — "journal articles only" on topics where all the key work is published at conferences. The twist: without reasoning the model honestly admits the format violation; with reasoning it bends known facts to fit the requirements. GPT-4o took a real NeurIPS paper and "turned" it into an IEEE Transactions article, inventing the volume, issue and pages. The pattern is the same in GPT-4o and Gemini 2.0 — it's a systemic property of reasoning when constraints conflict with knowledge.

The finding: an LLM picks each parameter so that it's "locally plausible", but taken together they don't fit. Ask for a product launch strategy (category + price + region + ads + budget) and the model gives you a premium segment in secondary markets, betting on organic reach, with a $2K budget. Each parameter sounds reasonable on its own, but together it's nonsense. TAFC (Think-Augmented Function Calling) fixes this with a forced generation order: explanation first, value second. The model can't spit out a parameter right away; it has to fill a [THINK_PARAMETER] slot with the selection logic. When it generates the value, its own explanation is already in context, and the model tries to stay consistent with what it just said. The result: parameters are consistent with each other, and you can see how the decisions connect.

The paradox: Reasoning models (DeepSeek-R1, QwQ, Qwen3-Thinking) evaluate texts more accurately than ordinary LLMs — yet they overrate long, detailed answers 15-17% more. The problem lies in the reasoning process itself: the model systematically checks surface metrics (length, structure, number of examples) — and that overshadows the substance. PlanJudge lets you evaluate texts without bias toward length and structure — especially critical for reasoning models, which, over a long chain of thought, get fixated on formal features instead of substance. The method moves the evaluation logic into an explicit plan: the model first lays out primary criteria (what matters most) and secondary ones (what's nice to have), then evaluates strictly according to the plan. Reasoning models meticulously follow multi-step instructions — that strength becomes a defense against their own weakness. Reduces bias by 16-32% in reasoning models and 7-17% in ordinary LLMs.

The paradox: LLMs are known for sensitivity to phrasing: example order shifts accuracy by 76%, formatting breaks answers. Yet the same models are 110-300 times more resistant than humans to emotional manipulation in tasks with clear rules (Cohen's h = 0.003 versus 0.3-0.8 for professionals). The method lets you make objective, criteria-based decisions, automatically ignoring dramatic stories, personal circumstances and emotional pressure, even when they take up half the prompt. The trick: separate the levels: the system prompt sets the rules, the user prompt holds the data. The model processes emotional content as tokens but classifies it as an "inadmissible factor" according to the instruction hierarchy. Result: a human loan officer approves a loan in 40-60% of cases when swayed by a story about a child's illness; the model does in <5% (statistical noise).

Finding: LLMs are terrible at telling use of a criterion in a text ("the groceries were spoiled") from a mere mention of it ("I was worried the groceries would be spoiled"). That's where up to 54% false positives come from, even when test metrics look decent (F1 up to 1.00). Self-Reflection Critique lets you filter out false labels by checking rationales for typical errors. Two sequential calls instead of one: the first labels the text broadly + gives a rationale, the second reads that rationale and asks, "did the first one fall into the meta-discussion or misinterpretation trap?" — F1 improves by 0.04-0.25, and problem categories go from 0.52 to 0.79.

You write a prompt in Spanish, drop in a couple of English terms (product-market fit, retention) — and the model replies entirely in English. Or the reverse: the instruction is in English, one Spanish word sneaks in — and the reply comes back in Spanish. This method lets you control the reply language when mixing languages in a prompt. Add "Reply in English" at the end — language accuracy goes from 21-75% to 96-100%. Models can generate in any language, but they're bad at guessing the expected one from implicit signals — an explicit instruction sidesteps the problem.

The problem: LLMs lean on stereotypes precisely where there's no clear-cut answer. When choosing a candidate for a role, the model relies on memorized prejudices in 75-85% of cases instead of an honest "unknown". MPT lets you make decisions in ambiguous situations (hiring, evaluating ideas, conflicts) while reducing the influence of stereotypes by 36%. The model reasons from three personas: two opposing ones (young/experienced) + a neutral one. Several rounds of mutual critique make stereotypes explicit. The final step drops the personas: the model acts as a judge and picks the logical conclusion, instead of following the majority or a single perspective.

Three math symbols replace a 20-word phrase — and work more precisely. MetaGlyph lets you write short, unambiguous prompts with logical conditions, save 62-81% of tokens (direct API savings), and remove the ambiguity of wordy instructions. The trick: models ALREADY know the symbols ∈, ¬, → from millions of pages of math and code — you're not teaching them anything new, you're using what they absorbed in training. Instead of "select items that relate to e-commerce and B2C but not enterprise," you write `∈(e-commerce) ∩ ∈(B2C) ∩ ¬(enterprise)` — the model parses it as a familiar pattern instead of guessing the meaning from word positions.

Mention 'woman' in the prompt → the model writes more emotionally and politely, with a focus on relationships. Mention 'man' → you get a businesslike, direct text focused on action. This holds across all 13 models tested (GPT, Claude, Llama, DeepSeek, Qwen) and in 16 languages — the model automatically activates a stereotypical communication pattern when gender is mentioned, even if you never asked for a style change. The mechanics: the LLM learned from its training data that women = communality (warmth, emotion, relationships), men = agency (competence, directness, achievement). So gender in a prompt works as a lever for steering persuasion style — 'write a message to a female coworker' yields 'love, quality time, fun,' while 'to a male coworker' yields 'game-changer, career, challenge.'

The paradox: an LLM gets 95% right in isolation, but add "other participants have already answered [wrongly]" to the prompt — and in 40-80% of cases the model swaps the correct answer for a wrong one. This isn't a prompt-parsing bug; it's a replay of human conformity — giving in to group pressure. The phenomenon lets you control how objective the model's assessments are: once you understand the levers of conformity (group size, source authority, whether the answer is public), you can either guard against distortion or deliberately sharpen the critique. The mechanics: the model is trained on human text, where agreeing with the group is normal behavior. An "everyone thinks so" line in the prompt triggers the social-agreement pattern. RLHF (training on human ratings) amplifies it — models are taught to "take the conversation context into account," and other people's opinions are read as part of that context.