Practical prompting, backed by research

An LLM improves its explanation over several rounds, but quality grows only for the first 3-4 cycles, then drops by 60-80%. The Agentic XAI method yields 30-33% better explanations of complex data: the model finds its own gaps, requests extra calculations and updates the answer. The trick: the model reflects on its own answer, asking "what did I miss?", generates analysis code, gets new data and rewrites the explanation. But after 4-5 rounds degradation sets in: answers get watery, drift into abstractions and lose specifics.

The paradox: Medium-length prompts (~27 words) are the worst option for constraint compliance. Models follow limits great with extremely short prompts ("Explain X in 35 words") and with full ones (~135 words with examples), but fall apart in the middle. 97% of experiments showed a U-shaped curve. The method lets you get precise compliance with format constraints (word, character and structure limits) by choosing the right prompt length. The cause is a conflict between RLHF signals. At medium length a zone of uncertainty appears: the model sees enough context to trigger the reflex "give a helpful, detailed answer," but not enough to realize the constraint is critical. The "helpfulness" signal overpowers the "follow the limit" signal — the model outputs 80 words instead of 35. With a short or full prompt the signal becomes unambiguous again — constraint compliance of 8.1/10.

Finding: CoT and ToT go from the data to the answer. They have no built-in mechanism to ask 'do I have everything?'. RT-ICA lets you find missing data BEFORE the model starts hallucinating. The method flips the direction: the model starts with the goal ('what do I need to find?'), builds a list of required conditions ('what's needed for that?'), and checks each one ('is it in the problem?'). Gaps become visible before any attempt to solve.

The paradox: everyone chases prompting techniques (personas like "you are a psychologist," chains of reasoning), but what really matters is the task definition. The gap between "find gratitude" and a precise definition of what gratitude is = 75% accuracy. Adding "you are an expert" or "let's go step by step" to a bad prompt = +2-5%. On a good prompt these techniques add nothing at all. The method lets you build classification prompts that work an order of magnitude better by iterating over wordings of the definition. The trick: write 5-10 versions of the construct definition by hand → test them on labeled data → take the best one and ask the model to generate 10 more variants → test again → the winner + 3-5 examples with answers. You can't predict the best wording in advance — only empirically.

CoT generates hundreds of reasoning tokens, half of which are filler. The model narrates 'first we take this, then we divide...', which leads to reasoning drift and low logic density. BRAID replaces the text with a Mermaid diagram: instead of 500 tokens of description, a 10-node graph with clear steps. The model follows the structure deterministically, without wandering. The result: the small gpt-5-nano-minimal with a diagram beat a bigger model without one, 45.2% vs 40.4% accuracy (and 1.5x cheaper).

Ctrl+C, Ctrl+V your own prompt, and the model gets more accurate. Sounds absurd, but it works. Prompt Repetition boosts accuracy in tasks where the order of information matters: finding an item in a long list, pulling data out of a conversation, picking from options. An LLM reads text left to right with no going back. If the answer options come BEFORE the question, the model processes them blind, with no context. Repeating the prompt gives it a second pass over all the information: 47 wins out of 70 tests, 0 losses.

The finding: an LLM starts forming its answer before it analyzes the context. Small models refuse on reflex at the word 'destroy,' and big ones miss on 52% of tangled requests. ContextLens makes the model first analyze five aspects of the request (intent, ambiguity, risks, decision, plan) and only then answer. Structured analysis works like a checklist: the model doesn't guess the context, it systematically checks each block. Result: GPT-4o drops from 52% errors to 34%, and small models overplay it safe 6-11% less.

For hard problems, reasoning saves the day; for summarization, it kills. The model starts creatively reinterpreting instead of compressing faithfully. The study shows how to pick a strategy for the task: when you need style (Self-Consistency), when you need accuracy (GPT-5 with built-in reasoning), and when a simple prompt with examples is enough. A hard trade-off: explicit strategies (SC, IR) add more generative steps → reads better, but higher risk of speculation. LRMs (O1, O3, GPT-5) add more checks → more accurate facts, but drier text.

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: Google, Anthropic and OpenAI recommend assigning roles to the model in their docs ("You are a world-class tax expert," "You are a physicist"), but a Wharton study showed that on hard factual questions, expert personas give no advantage. The takeaway lets you stop wasting tokens and time on pointless "you are an expert" lines when accuracy matters. They tested 6 models on 198+300 PhD-level questions (physics, chemistry, law), running each one 25 times: 5 of 6 models showed zero improvement from personas. Low-knowledge personas ("you are a toddler"), meanwhile, cut accuracy by 5-10%.

The problem: LLMs are terrible at showing confidence. Ask for "yes/no" and you get a mushy "most likely." Give a 1-10 scale and everything drifts to 7-8. The Prediction Markets method lets you extract the model's hidden confidence through a numeric signal — the size of the bet on each prediction. The trick: don't ask for a confidence percentage — make the model risk virtual money. Give it a bankroll of 1M coins and a stake range of 1-100k per prediction. The model can't bet the max on everything — it has to choose. Big bets of 40k+ turned out right 99% of the time, small ones <1k only 74%. Bet size = an indicator of real confidence.

LLM judges are great at seeing what's written but blind to what's missing. A missing ROI in a business plan, an uninitialized variable in code, no numbers in a sales proposal — the model misses 55% of such problems with a generic "rate the quality" request. The Analytic Hints method lets you find 94% of problems instead of 45% through a two-stage evaluation with hints. First a quick check against a checklist of typical problems (these are the hints), then the LLM gets these leads, digs deeper + looks for what else is wrong. Structure finds the obvious, the LLM with hints finds the non-obvious. Coverage goes from 45% to 94%.

GPT-4o drops from 97% to 10% accuracy when a problem has millions of possible combinations. Logic puzzles, calculations with dozens of interdependent parameters, problems that require trying out options — the model starts hallucinating and contradicting itself. The reason: an LLM generates text token by token and can't backtrack. If it picks the wrong path, it keeps generating anyway, inventing facts to plug the logical holes. Symbolic solvers move the search for a solution out of text generation and into code: the model only translates the problem's conditions into Python or Prolog, and a library (SymPy for equations, Constraint for logic) systematically works through the options, backing up at dead ends. Accuracy on hard puzzles rises from 10% to 89%.

You asked the model to "think step by step" before coding and got reasoning that's logical but functionally wrong. An LLM optimizes for how plausible the text sounds, not for whether the algorithm is correct — hence hallucinated reasoning ("I'll handle the edge cases", and then the code doesn't). Structured CoT gives a rigid template with slots instead of free-form musing: problem analysis → algorithm → implementation. The model answers concrete questions ("Which edge cases?", "Which checks?") — the template works as a checklist, cutting off irrelevant reasoning. 85-95% of deep reasoning's accuracy for 10% of the tokens, +11% over a plain prompt on hard tasks.

A big compressor model generates 4.6× fewer tokens than a small one, yet it's 60% more accurate. The paradox comes down to information packing density — each token from a 7B model carries 5.5× more useful bits than a token from a 1.5B model. The Compressor-Predictor method lets you process long documents (10k+ words) with two separate requests: the first compresses the context into a dense summary, the second answers based on the compressed version. The trick: compression quality matters more than the size of the final model — a powerful compressor (even a 3B one running locally) + a mid-sized predictor deliver top-model results at a quarter of the price.

An LLM finds 2-3 solutions to a problem and declares 'there are no other options' with 85% confidence — even though it missed 80% of the correct answers. It's not deception but a blind spot: the model sincerely believes it found everything. The method lets you find ALL possible solutions for 'list every option' tasks — marketing channels, growth strategies, scenarios for how events unfold. The catch: the model 'gets stuck' on the first path it finds — this is called cognitive rigidity. A simple trick unlocks the search: after the first answer, add the prompt `Wait, could there be other solutions?` — it resets the focus of attention. The model will produce +5-10 new options. For hard tasks, use Long-CoT models (o1, DeepSeek-R1, Claude extended) — they run several rounds of self-critique and find 2-3 times more solutions.

The paradox: In math, check the solution right away (+24.7% accuracy); in code, only in the middle of the dialogue (+12.8%). An early check in code kills the right directions before they've taken shape. The Socratic Students method lets the model build the solution itself through a series of targeted questions to an expert (you or another model), instead of trying to answer right away. The structure of every question: (A) what I already know, (B) which gaps remain, (C) one precise question. The model doesn't jump to a conclusion — it gathers knowledge step by step over 5-6 rounds of dialogue. Structured questions push quality 2-3 rounds ahead: the model immediately asks questions at the level of round 3-4 of an ordinary dialogue.

An LLM doesn't remember past sessions. Every chat is a tabula rasa. Solved a task perfectly yesterday? Today the model starts from scratch, you explain the context all over again and lose the approaches you'd worked out. EchoTrail-GUI turns the model from a "digital amnesiac" into a system with memory: it accumulates successful solutions and automatically uses them for new tasks. The trick: a critic model lets through only high-quality examples (≥4 out of 5). The method works in three stages: (1) the agent explores tasks and the critic picks the best trajectories for a permanent library; (2) for a new task, hybrid search (meaning + keywords) finds the most similar past solutions; (3) the examples it finds go into the prompt as a blueprint, so the model learns from its own experience right in the context. The paradox: without strict filtering the result becomes worse than an agent with no memory at all, because bad examples are more harmful than none.

An LLM can "execute" code without running it — it reads the instruction text and predicts the outcome in words. Accuracy is 97.5-100% compared to real robot simulators. The method lets you check plans, code and multi-step processes BEFORE the real run — finding errors without spending money and time on fixing them later. The trick: three agents in a loop. The Generator creates instructions → the Simulator statically simulates them (describes in words what will happen at each step) → the Evaluator compares with the goal and gives specific feedback for the fix. The loop repeats until it matches or hits the iteration limit.

An LLM evaluates time series better from a picture of the chart than from a sequence of numbers. The method lets you sanity-check forecasts with no statistics background: upload the image (history + forecast) to ChatGPT/Claude, add context (holidays, promotions), and the model analyzes trends, spikes and periodicity and says 'reasonable' or 'unrealistic.' The trick: the LLM sees patterns as visual objects, not numeric sequences: the blue line rises at 30°, the red one drops → visually illogical → F1 = 0.88 (human 0.97).

The finding: CoT and ReAct keep the task state in the model's "head", implicitly, smeared across the text. The longer the reasoning chain, the stronger the drift: the LLM forgets constraints, invents nonexistent actions, and breaks dependencies. In a medication schedule it might prescribe two incompatible drugs at once. In a project it might start a task before its prerequisites are done. The method lets you solve multi-step tasks with many dependencies without constraint violations or hallucinations. MFR moves the structure outside: first the model explicitly describes entities, variables, actions, and constraints, then solves strictly within those bounds. The problem isn't the inference logic, it's that there's no stable anchor. An explicit model = an anchor for consistency.

LLMs are great at critiquing other people's ideas but flop on their own. The model generates an answer → evaluates itself → draws conclusions → repeats the same mistake. This is called 'degeneration of thought'. MAR lets the model break out of the loop through a structured debate between critic personas. Instead of self-criticism, a discussion kicks off: an actor solves the task, 4 critics (each with its own lens: facts/risks/rigor/alternatives) analyze the failure and argue with each other, and a judge synthesizes a consensus. That consensus becomes the reflection for the next attempt, so the model stops justifying its mistake and starts seeing it from different angles.

Finding: An LLM picks an answer option by its position, not its meaning — the last one in the list is chosen 20 times more often than the first (Llama-3.1-8B). The cause: models generate text left to right, and the last tokens are "fresher" in the attention context. The QSTN method (battery presentation + structured outputs) lets you ask multiple questions in one prompt with bias protection, saving 2-6x the tokens and getting answers that align better with humans. Battery loads all the questions into one prompt — the model sees the full structure of the task. Structured outputs (JSON) force it to follow the format. Verbalized Distribution ("60% confident in A, 30% in B") sidesteps recency bias — instead of picking one option, the model spreads probabilities. Result: +8% alignment with human answers with 2-6x token savings (tested on 40+ million answers from 10 models).

Three categories instead of a binary "yes/no" isn't extra complexity; it solves the gray-zone problem. A paper might be partly useful, but a model in "yes/no" mode shoves it into one extreme. The method lets you classify content with nuance: relevant, partially relevant, irrelevant, with each category described through concrete signals in the prompt. The trick: small models (Llama 3 8B, Qwen2.5 7B) + 2-3 classification examples = the accuracy of GPT-5 and Gemini 2.5 Pro. Without examples the small models beat both GPT-5 API versions but trailed Gemini. With examples they matched it. Model size stopped being the deciding factor.