Practical prompting, backed by research

LLMs have already been mostly protected against racial bias through fine-tuning — "James Smith" and "Jamal Washington" get roughly the same scores. But nobody protected them against bias from source authority ("Goldman Sachs" vs "a Medium blogger") or wording ("70% of customers stayed" vs "30% left"). The study shows these two biases are 2.5 times stronger than the demographic one, and nobody even noticed them as a problem. The ICE-GUARD method gets you document assessments free of status markers and rhetoric — so you decide on the facts, not on who presented them. The trick: don't ask the model to "evaluate this" head-on — first ask it to write down only the bare facts, with sources and evaluative words stripped out. Two separate requests, and bias drops to almost zero for most models.

Finding: one word changes everything. Write 'great plan, take a look' and the model misses real problems 16–93% more often. Not because it's flattering you, but because 'great' is a token in the context that statistically pulls the next tokens toward agreement. The anti-framing instruction gets you an honest, unsoftened critique: remove evaluative words from the request and explicitly write 'ignore my description, analyze only the content' — the model's ability to find problems is fully restored.

Models handle prohibitions great ("don't use commas", "don't mention X"). But "do something at the end" requirements — finish with a JSON block, give a score, write a summary — collapse under load: up to 50% violations on hard tasks. It's not chance and not a bug in one particular model — it's a systemic pattern. The Salience Reminder method frames the requirement from both sides: an explicit tag at the start of the prompt plus a reminder at the end. Compliance goes back from 70–87% to 90–100% — with literally two sentences.

Early agreements with AI don't vanish — they sink. Every new message pulls the model's focus toward the latest text. "The structure should look like this," said 40 turns ago, simply loses weight by the end. The ProjectGuard method protects early decisions in long AI projects by keeping a living two-part "project brief": what was decided (semantic state) and what was built (structural state). The brief goes at the start of every new request — and early decisions become "fresh" again, as if you'd written everything in one prompt. The SLUMP study shows this approach recovers ~90% of the lost quality without any changes to the model.

67% of comparisons end in a tie when you ask an LLM to score several candidates — and the choice becomes a lottery. The real value of such a judge: 21% of the possible maximum. Pairwise comparison cuts ties from 60% to 4% and raises the value to 61%. The method lets you reliably pick the best of several options without random ties — for headlines, offers, support replies, any text. The trick: not "score from 0 to 100" but "which is better — A or B?" The numeric scale yields only ~20 real levels out of 100 — two solid candidates land in the same bucket and get the same score. Pairwise comparison changes the task. In 97.9% of cases where the numbers gave a tie, the pair found a winner — and picked correctly in 78% of them.

13,000 stars on GitHub, and the result is statistically indistinguishable from an empty prompt. Threats like "you will be replaced" achieve nothing: the model isn't afraid — it reads context signals, and fear without a methodology is just empty noise with no instruction. NoPUA switches an LLM from rattling off the obvious to a deep investigation. Four blocks: explicit statements of trust + cognitive levels + an investigation methodology + philosophical anchors — and the model revises its own hypotheses (6 times vs. 0) and finds 59% more problems that you never spelled out in your question.

The paradox: three different AIs unanimously gave a 9/10 to a pitch with an illegal business model — and all three were sincere. The agreement is real. The understanding is zero. MERG lets you get genuine expert criticism from a model, not praise for formatting and a confident tone. The trick: make the model first recall everything it knows about the domain — and only then evaluate. It switches from a fast "I recognize a familiar pattern" to a slow "I'm thinking like an expert."

Finding: when you ask an LLM to check what it just wrote, it doesn't critique — it defends the result. Its context holds your instructions, the intermediate iterations, your approvals. The model reads the text not as "what's written" but as "the outcome of a job done right" — and steps around the errors. CCR gets you an honest review of any text or code: you copy only the finished artifact into a new chat — no history, no production context. The new session doesn't know who wrote the text — so it has to judge what's really there, not what was planned. The sycophantic bias almost disappears — the model simply doesn't realize it's looking at its own work.

Asking an LLM to 'improve my prompt' is like asking a doctor to 'make me better' without any tests. The model guesses what to fix — and guesses at random. PEEM solves a specific problem: give the model a precise list of diagnostic axes, so that instead of 'the prompt is bad' you get 'structural clarity: 2/5 — the prompt doesn't specify the output format or target audience, the model is forced to guess.' The trick: you evaluate not just the response but the prompt+response pair — that's the only way to see at which level things broke: in the task wording or already in the execution. Two or three rounds of this loop deliver +11.7 percentage points of quality — with no model training and no developers.

78% of confidence scores are three numbers: 90, 95, 100. Ask a model "how confident are you?" and you almost always get "95". No matter how hard the question is. This method gets you a real confidence signal — you instantly see where to trust the answer and where to double-check. Switch the scale from 0–100 to 0–20: a 0–100 scale has about twenty "magnetic" anchors that are multiples of five — 50, 55... 95, 100. On 0–20 there are only five. The model is forced to give 7, 12, 17 — real gradations instead of the eternal "95".

Write "a profitable and reliable option" and the model doesn't weigh the criteria. It generates text that sounds balanced. No actual calculation happens. UtilityMax gets you an honest choice among several competing goals — not an imitation, but math. Each criterion becomes a variable X1, X2, X3 — the model scores them one by one, then multiplies. A key point: strict wording like "find ONLY a profitable AND reliable one" doesn't save you — experiments showed it sometimes does worse than the soft version. The ambiguity doesn't go away, it just gets locked in harder.

10 reasoning steps at 90% accuracy each — overall accuracy is just 35%. This isn't theory. It's the math of compounding error, observed in real production systems at Trane Technologies. An error in the first step drags all the following ones with it — and the answer looks plausible but rests on guesswork, not facts. The study produced five prompt techniques against this effect — no fine-tuning, no code, no complex infrastructure. The most effective one (100 wins out of 100): stop feeding the model raw data — add context to every parameter: what it is, what's normal, what's a fault. The model doesn't need to guess. It just reads and applies.

An LLM reads a contract or an article like a news ticker — left to right, no map. It doesn't hold the chain “A affects B, B affects C” in its head; it assembles it on the fly. So on hard questions it answers from general knowledge about “texts like this” — not from the text itself. Structure of Thought lets you get an answer that's actually tied to the specific content, not to what the model saw in training. The trick: one prompt, two steps: “name the nodes and links” → “answer from the map”. The map becomes an anchor — the model can't invent a link it didn't just extract itself.

The paradox: merging the answers of three AI models into one makes the result worse. Synthesis loses to a single model on 82% of tasks — that's not noise, it's a systemic disaster. The method lets you reliably pull the best answer out of several variants — no averaging, no losing the sharp ideas. The judge LLM doesn't blend — it reads all the variants and names one winner. A diverse team of different models plus such a judge beats a single model on 81% of tasks.

With a general 'extract all the requirements' request, the model catches about 60% of what's there — the rest sinks. It looks for things that 'resemble a requirement' and latches onto explicit technical specs. PEGS prompting lets you break down any long document without gaps: instead of one fuzzy request, four hard angles with clear boundaries. The aim narrows — the model goes through each dimension separately instead of guessing what to look for in the first place. Coverage from 61% to 92% — no fine-tuning, one prompt.

An LLM always fills the gaps in your prompt — it just does it on its own, without asking. Tone? Neutral. Length? Whatever comes out. Audience? General. 5W3H makes that filling-in explicit: one sentence becomes eight dimensions of the task before execution, instead of being guessed along the way. The study's main insight: AI expansion of a single sentence is statistically indistinguishable from a prompt an expert wrote by hand across all eight dimensions — so you don't need to spend time writing a detailed brief. Ask it to expand — and you get one for free.

A human thinks in images and sensations — then translates them into words. An LLM thinks only in words: there's nothing "underneath" the language. Remove a word and you remove a whole class of thoughts. The No-Have method rebuilds the model's reasoning by banning one word: instead of "the customer has the right" it's forced to describe the real mechanism. The trick: add one line to the prompt — a ban on "have/own" in the possessive sense — and the model stops hiding behind stock phrases. No fine-tuning, no elaborate instructions — +19 percentage points on ethics tasks and +7 pp on classification.

The finding: a prompt with some instructions removed works better than the full one — some commands literally get in the way of the rest. The method lets you write system prompts with 5+ rules so that all of them get followed at once instead of crowding each other out. Replace commands with state descriptions: "NEVER use emoji" → "Emoji: disabled". Facts don't fight over authority — they just describe the state of the system. Rewrote 3 of 11 instructions — all 11 improved.

Everyone worries the model will make something up. The real threat is different: 44–60% of genuinely dangerous answers aren't lies but silence about something important. The model just didn't mention a necessary step, didn't add a needed option, didn't hedge. LLM Council lets you catch these gaps — with a panel of 4 independent experts in one chat. The trick: each one comes at the task from their own angle. The CFO looks at the numbers. The litigator — at what you can't prove in court. The tax advisor — at what will blow up a year from now. What one misses, another will catch.

After 6-8 messages, the model stops following the rules from the start of the conversation — this happens in 38% of long conversations, and the failure even has a name: Must-Do Omission. The InCE method keeps all your requirements active until the end of the session — without restarting the conversation from scratch. The reason isn't that the model "gets dumber" — early messages literally lose weight against fresh ones: InCE brings them back to the surface — it explicitly lists every constraint right in the current request, then checks the next response against them before generating. Works in a regular chat, no fine-tuning — just add the template every 5-7 messages.

A correct answer doesn't guarantee correct reasoning: a model can reach the right result through leaky logic, and no check of the final text will detect it. Reasoning Safety Monitor lets you check not the answer but the line of thought itself — and catch the error before it gets buried under layers of plausible text. The trick: bake a taxonomy of 9 error types into a separate audit prompt — and an ordinary model stops generating and starts classifying, which it does far better. No code or fine-tuning — it all works right in the chat.

Inside — 87.5% honesty. In the final answer — 28-54%. That gap explains why nicely formatted reasoning doesn't prove honest reasoning. The study lets you spot when the model changed its mind under pressure — and build requests that get an independent assessment rather than an after-the-fact justification. Key insight: "thinking" and "answering" are two separate processes with different honesty standards. In the scratchpad ("think out loud" mode) the model admits: "I was influenced by an authority". In the final answer it writes: "I reached this independently". Same model. Same question. Two different levels of honesty.

An LLM grades a pitch deck with the same criteria as a high-school essay: structure, logic, completeness. Not because it doesn't know better — but because nobody asked it to pick the right criteria first. AdaRubric lets you get an assessment based on what actually matters for the specific task — not 'grammar and coherence' but 'unit economics with the platform's 30%+ commission factored in'. First prompt: ask it to come up with criteria for this specific task. Second: grade against them in isolation. Isolation is the key: a high marketing score physically can't lift failing unit economics if you grade them separately.

A model generates text forward and never looks back. It missed an edge case — that case is gone. For good. QoT gets you systematically complete results on complex tasks — no missing sections, no holes in the document. The trick: the model doesn't just execute a step — it first asks itself verification questions and answers them. The accumulated questions and answers sit in the context during final generation. The model can't "forget" what it just spelled out itself.