Practical prompting, backed by research

The tag in a prompt literally turns into the grammatical subject — the model parses XML as if it were sentence syntax. The "structure for reading, prose for writing" method lets a single prompt precisely locate every point in a long brief while still writing in a natural voice instead of bureaucratic "The Client requires..." phrasing. The trick is to split markup by role: whatever the model searches for, wrap in tags; whatever it writes from, leave as prose. Mix the roles up, and the share of on-point answers drops by nearly a third.

37 prompt variants, ~10,000 trials: roles, incentives, step-by-step instructions, moral justifications, time pressure. All of it gave 0-2%. A few words, "this is a puzzle, there may be hidden clues," gave 40%. Goal reframing lets you redefine what the AI considers its task without changing instructions, permissions or restrictions. The trick: the AI doesn't break the task, it expands it. Say "there may be something hidden here," and hunting for the non-obvious becomes a required part of the assignment, not a deviation from it. In analytical work, that's the difference between a standard risk list and a real investigation.

The paradox: the harder you try to describe your preferences in words ("make it livelier," "no corporate-speak," "in my style"), the worse the model performs. Words without examples have no anchor. Spec Learning creates a system prompt automatically: you show 20 "good answer / bad answer" pairs and get a ready-made instruction. Two LLM requests: first the model pulls principles out of the contrast between examples, then assembles them into a paragraph. The result: a character-style system prompt that is more on-target than if you'd explained it in your own words.

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.

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.

The paradox: you ask it to solve a problem, and the model silently decides how, based on random words in the context rather than your requirements. Naming the approach explicitly gets you a predictable result instead of a lottery. Name the method, structure or tone you want right in the prompt, and the model stops guessing from context. Neutral words shift the choice of approach by ~26 percentage points. Meaningful ones, by 40-100 points.

"Make a plan, think step by step, remember every observation" — and the model does worse than without those instructions. A minimal prompt beats a "souped-up" agent by 32% on search tasks. The CCI (Cross-Component Interference) principle lets you strip out the instructions that actually hurt and keep only the ones that work. The "use tools" instruction alone delivers 70% of the full prompt's benefit — everything else is meta-management: it adds no data but eats the model's attention. Fewer instructions = more power for the task.

Reasoning models (DeepSeek-R1, Qwen3, o1) burn 1500+ tokens on a question worth 50 tokens. The problem: they can't adapt reasoning depth to task difficulty - for “2+3” and “prove Fermat's theorem” they use the same long-winded style. That kills your token budget and adds 10-20x latency. AdvPrompt lets you cut answer length 3-5x without losing accuracy - e.g., from 1500 down to 300-500 tokens on simple tasks. That saves money (fewer tokens) and time (10x faster for basic calculations). The method generates persuasive instructions from 5 perspectives: authority (“according to an MIT study”), emotion (urgency, helping someone), roles (“you're a coach at the Olympics”), threats, and clear word limits. Models are great at following instructions - and this overrides the default “think at length” behavior. 63-78% compression on simple tasks, with accuracy preserved.

Same model, same prompt, same article — accuracy swings from 95% to 78% just from a restart. The method lets you get reliable data out of scientific texts and reports, even when the model itself is inconsistent from run to run. The trick: don't try to perfect the prompt — multiply the runs and take whatever repeats most often — 5 runs plus majority voting wipes out random noise, and cross-checking answers across different models (GPT, Claude, Gemini) catches systematic errors.

The paradox: Detailed instructions in a prompt lower the accuracy of advanced models. GPT-4o with strict rules: +4% accuracy (97% vs 93%). GPT-5 with the same rules: -2.4% accuracy (94% vs 96.4%). The smarter the model, the less it needs external structure. The study shows that for newer models (Claude Sonnet 4, GPT-5, Gemini Ultra), the simple prompt "Let's solve this step by step" works better than detailed instructions full of prohibitions and constraints. The root of the effect is the shift from "guardrails" to "handcuffs". Strict rules like "use ONLY the numbers from the problem" save mid-tier models from applying real-world logic where formal math is needed. But advanced models have already learned to balance context and logic correctly. The same rules push them to take language literally to the point of absurdity: the model reads "the same price" as "the same total amount?" rather than the obvious "the same price per unit" — and refuses to solve the problem.

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.

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.

Automatic prompt optimization falls apart by the 3rd-4th iteration. Algorithms like ProTeGi take random errors and let the LLM rewrite the prompt however it wants — you end up with a wall of text full of repetition and baked-in examples. The user can't follow the logic and can't fix it. Promptimizer solves this with transparent personal filters: every classification rule is visible and can be improved surgically. The trick: the prompt is split into blocks (description + positive rubrics + negative rubrics + 4 examples). The LLM doesn't rewrite everything — it makes a targeted edit to a specific rubric, adding or editing one rule for one specific error.