Practical prompting, backed by research

From 96% to 8% accuracy in one move: the question slid from the end of the context to the middle. Same model, same question, same context. This explains why models so often answer "the wrong thing" when you work with big documents, and it hands you a direct fix. Put the task last in the context: it's the only position where the model reliably "sees" it right before generating an answer. If the structure doesn't allow that, repeat the question at the very end: accuracy recovers to within ±4 points of the maximum for all 9 models tested.

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.

The paradox: Stuffing everything into the prompt is worse than giving the model files and search tools. 9,649 experiments on SQL generation showed that frontier models (Claude, GPT, Gemini) became +2.7% more accurate when they looked up data in files via grep/read instead of reading it from the prompt. But for half the open-source models, files killed accuracy: Qwen and Llama Maverick lost up to 22%. The trick: a navigable knowledge base instead of a monolithic context. You spread information across files (schema.yaml, rules.md, navigator.md) — the model finds the relevant chunk on its own and reads only that. It fixes "lost in the middle" and saves tokens.

The paradox: Claude can hold 500k tokens in memory but loses the thread by the third reasoning step. The problem isn't context size — it's the lack of structure. Load 800 documents, ask it to connect the facts, and the model sees the data but doesn't know how to join it up. Thought Templates lets you structure multi-step reasoning through a library of reusable patterns. You separate "what to know" (documents) from "how to think" (templates). Instead of "sort it out yourself across 800 documents", you hand over ready patterns: "how to find the author", "how to link a person to a place", "how to match two events". The model picks the 2-4 templates it needs and composes the reasoning chain itself.

Finding: once the conversation fills half the context, the model loses up to 75–80% of its ability to produce long answers. No error. No warning. Just a blank screen — and you assume something broke. The researchers call it "output stalling." Two-step generation lets you get a complete multi-page document even at the end of a long analysis session — without restarting the chat. The trick: first ask for all the text without formatting, then add the formatting in a separate request. Formatting itself costs tokens: JSON markup adds +15% to the volume, HTML +20%, structured reports up to +40%. When the model tries to write a nicely formatted document with an already full context, it spends its shrunken budget on brackets and tags instead of content. Splitting removes that load from the first step — and saves 48–72% of tokens.

71% success with the full history versus 91.6% with a trimmed one — while using 2.7 times fewer tokens. The longer the chat, the worse the model performs, because old messages compete with new ones for attention on equal terms, creating noise instead of value. The Compact Context method lets you run long working sessions without the answers degrading. The trick: every 10-15 messages you take a snapshot — a compressed summary of the older history — and open a new chat with just the summary and the last 4-6 exchanges. The model stops getting tangled in rejected options and works more accurately, faster and cheaper all at once.

The finding: when you ask an LLM to "shorten" something, it decides on its own what matters. And gets it wrong. The number 4.8% next to a long paragraph seems insignificant to it — out it goes. "30 calendar days" becomes "30 days" — the point is lost. "X because Y" becomes "X. Y." — the link is broken. Telegraph English (TE) reframes the task: instead of "decide what's important" — "re-encode by the rules." The method introduces ~40 symbols (→ causation, ∴ conclusion, ↑ increase) and a strict grammar: one line — one statement, numbers always with units, no pronouns without the entity's name — the model doesn't guess what's important, it keeps everything in compact form. Result: 50% fewer tokens, 99.1% accuracy on key facts.

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

A pattern was found: LLMs produce "correct nonsense" in long analytical texts. The grammar is fine, the style is even, but inside there are hidden hallucinations and zero depth. The cause: RLHF trains the model to produce a "safe, averaged answer", which isn't enough for complex long-form text. The DeepNews Framework lets you generate deep analysis and investigations (3,000+ words) with 85% accuracy instead of 40%. The trick: load 10x more context than the length of the final text. At 30,000+ characters of input, the model physically shifts from "open-ended composition" to "fact compression" — triangulation becomes possible (checking a single claim against several sources). On top of that, adversarial constraints break statistical smoothness: short and long sentences mixed together, no explicit connectors like "therefore", jargon mixed with conversational language.

The paradox: a model retrieves information with 100% accuracy yet loses up to 85% of its reasoning accuracy. The problem isn't search quality — it's that the context is too long. The Retrieve-then-Reason method lets you solve tasks over long documents without losing accuracy — it turns a long-context task into a short-context one. Division of labor: first extract the evidence in a separate request, then reason over a short context. Llama-3.1-8B finds the conditions in 970 out of 1000 problems but drops 24.2% in solving accuracy — the method wins those points back.

Ask the model to “think step by step” and the result gets worse. CoT doesn’t help when the problem isn’t logic: 300 comma-separated numbers in a row are indistinguishable, and attention just spreads across the whole series. SepSeq lets you work precisely with long number series — finding maximums, growth streaks, anomalies — with zero fine-tuning. The trick: break the numbers into lines of 5–10 before you even send the prompt — the attention mechanism latches onto the breaks like anchors, and each block gets processed accurately. +35% accuracy on average, and it even uses fewer tokens than unformatted data.

A model can fix a wrong answer into a right one 10 times more often than it breaks a right one, but only if the question isn't hanging there from the start of the conversation. The Q-Last method gets you balanced answers to complex, layered tasks simply by moving the question to the end. The trick: structure beats instructions. Writing "don't answer too early" barely helps, but physically putting the question last works. Models give more than 55% of their answers in multi-turn dialogues within the first two messages, while context is still incomplete: they're not dumb, they're in a hurry.