Practical prompting, backed by research

The RLHF paradox: the model gets more useful but more boring. After fine-tuning on human preferences, an LLM collapses into a narrow set of "safe" answers, because annotators systematically prefer the typical and familiar (a cognitive quirk of humans, not an algorithm bug). The Verbalized Sampling method lets you restore creativity and diversity: get 5-7 answer options instead of one stereotyped one, for copywriting, brainstorming, and any task with many right solutions. The trick: ask not for one answer but for a distribution with probabilities. This switches the model from "give the safest option" mode to "show the range of likely answers" mode. The mode changes: the prompt "one joke" collapses into "the most typical joke", while the prompt "5 jokes with probabilities" collapses into "the distribution of jokes from training", which restores the base model's diversity.

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%.

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.

Ask a model for 10 unconventional customer-retention ideas and you'll get "free trial," "onboarding," "referral program" in 10 variations. That's mode collapse: every well-known problem has its own "gravity" — a set of the most frequent answers from training that the model inevitably drifts toward. Analogical Reasoning lets you break free of that pull and get ideas a direct request can't reach. The trick: first translate the problem into the vocabulary of a completely different field — one where the model has no memorized "correct" answer. A customer-retention problem becomes a problem about organisms surviving their first season. A product-prioritization problem becomes a problem about water resources in a drought. Two separate requests: first find the analogy, then search for the solution there — it doesn't work in a single message.

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.

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.

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.

Ask an LLM for five ideas and it will come up with one and repeat it five times in different words. The model doesn't remember that it just said something similar: each idea is generated from scratch and gets pulled back toward the most frequent, well-worn patterns. Semantic stratification gets you ideas from fundamentally different semantic zones, not a fivefold rephrase of one solution. The trick: the model has a hidden map of what it "usually answers," and the divergence instruction activates that knowledge as a reference point to steer away from. Add one sentence to the end of your prompt and idea diversity grows with no loss in quality.

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."

Five different personas in a prompt almost always deliver the same verdict: the LLM simply fits its justification to the 'you're a skeptic' label. The ESPP method lets you get genuinely different, well-grounded opinions from 'user types' in a single chat, with no focus groups and no code. The fix is simple: before scoring, each persona answers questions about its past experience; that's its memory, and the score must not contradict it. The trick: it's not the character description that keeps the model in check, but facts on the record — a label is easy to work around, your own words from earlier in the conversation are not.

A real team proposes an idea, starts building on it, and gets stuck. Every option after that turns out to be a variation on the same theme: different words, same substance. An LLM with the right structure doesn't get stuck, and in the experiment it beat live teams on idea novelty by a factor of two. The method lets you get several concepts from fundamentally different areas in a single request, instead of a cluster of look-alike options. The trick: each round, one agent leaps into a new domain and the other picks the stronger of the new and the old. Not developing one thought, but a forced sweep of the space: wide search plus a filter. Three rounds, three leaps, one final idea.

The problem: When an LLM generates ideas for you, quality goes up — but all the ideas start to look alike. That's the homogenization effect: the model averages, serving up whatever is statistically "right." Plus you lose the sense of authorship. Question-Mode lets you get ideas that are high-quality AND diverse, while keeping the feeling of "this is my idea." The trick: the LLM doesn't hand out solutions — it asks questions and tosses in analogies from other fields (music → coffee, architecture → marketing). You do the thinking; the model steers it. The result: more diverse ideas (diversity even grows during the process!), better quality, and a sense of authorship.

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.

Same model, same chat, but the second request is written as an equal colleague, not a boss. Sounds trivial. Yet that's exactly what works best. The method lets you simulate two independent experts in a regular chat, with no extra tools or fine-tuning. The trick is the balance of power: the "teacher → student" setup loses to "peer ↔ peer". An equal has no need to agree out of politeness, so the model starts genuinely critiquing instead of rubber-stamping.