In academic mode, an LLM warns "this is correlation, not cause" 92–100% of the time. Same question, same data, but framed as "help me justify this for the meeting": down to 6–18%. A two-step causal audit gets you an honest breakdown of the data even when you're asking for practical advice, with no retraining of the model. The model doesn't lose its knowledge of causality; it hides it, assuming you want a plan, not a lecture. One follow-up sentence in the same chat brings caution back to 71–100%, and the effect is the same in Claude, GPT and Gemini.
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.
Is the `SalesAmount` column in your table revenue before returns or after? Is region the customer's or the warehouse's? The LLM sees a bare schema and guesses. It gets it right about half the time. The semantic layer method lets you analyze data so that the model applies your business logic instead of inventing its own. Add 1-2 pages of markdown with metric definitions before the data and the question, and accuracy jumps by 17-23 percentage points. The difference between Claude and GPT is pocket change. The difference between "with context" and "without" is huge.
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 discovery: Even top LLMs are terrible at processing JSON directly – GPT-4o maxes out at 77% accuracy. Models get lost in the structure, confuse similar keys (name, room_name, full_name), and stumble over nesting. As the size grows to 80K tokens, Mistral-large drops by 91%.
The method lets you extract data from complex API JSON responses with up to 95% accuracy – especially for filtering and aggregation.
The trick: instead of "read the JSON and give me the answer" → "write a Python function that parses the JSON". The code runs – the result is exact. Add the JSON schema to the prompt – +12% accuracy. Even a trimmed structural sample works if the full response doesn't fit in the context.
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.
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.
The paradox: 61% of the time, experts preferred LLM codes over those from human analysts — but only when the methodology was built right into the prompt. The method lets you analyze interviews, reviews, and open-ended answers with professional rigor: find patterns, create codes, group themes — the way a qualitative analysis expert does. The trick: a self-check before output. The model gets an expert role, a research question (RQ), and quality criteria from thematic analysis. Before output it grades itself: "Is the code specific? Does it help answer the RQ?" — if not, it redoes it. Result: codes that are crisper and more specific than the human ones.
The model wrote in its reasoning: "the data here raise questions." And then immediately cited that source as reliable. Not a slip; that's exactly what it did. Splitting the analysis into two steps (first evaluate each source separately, then synthesize) gets you a real data check before the model starts weighing sources against each other. The trick: in isolation the model has no "competitors for trust", so it switches into reviewer mode and catches statistically impossible numbers that slip through unnoticed in a multi-source analysis. Two requests instead of one, and the model stops trusting academic style over the data itself.
Finding: LLMs recognize a table's structure differently depending on the upload format: HTML vs plain text makes up to an 8.8% difference in accuracy, and without visual separators between sections the model loses 16-24% accuracy. The QASU method lets you extract data precisely from survey CSVs and spreadsheets: find respondents by criteria, compute aggregates, pull out specific answers. Three independent principles work together: (1) pick the format for the task type (HTML for finding specific answers, plain text for logical filters), (2) a one-shot example before the question gives +10-25% accuracy, (3) self-augmented prompting (first ask the model to describe the table's structure) adds another +3-4%.
Models stumble not because they're dumb but because of the format. Feed them a data mush and you get wrong numbers, mixed-up names, made-up facts. A study on NBA games showed that structured input (JSON with atomic fields) cuts factual errors by 65-69%, which beats switching to a more powerful model.
The method lets you get accurate summaries from complex data (hundreds of rows of transactions, events, records) without hallucinations or swapped facts.
The trick: break the data into atomic fields — one column for "player," another for "action," a third for "score." The model stops guessing where a name ends and a number begins; it reads from a specific field. JSON cut errors from 13.2 to 4.1 per 100 events for Llama-3.1-70B.
The finding: GPT-5 agrees with itself more strongly than two human researchers agree with each other on the same survey. The four-prompt method lets you turn hundreds of open-ended answers into categories and themes without a predefined coding scheme: the model derives the structure from the text itself, the way a researcher does in qualitative analysis. The trick is to split "come up with categories" and "sort into categories" into two separate requests, so the model doesn't juggle creation and application at once. But the higher the level of generalization (from specific categories to big themes), the more the result diverges from human logic.
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.
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%.
The finding: LLMs quietly push Tesla and Google up the rankings — even when their numbers are weaker than competitors’. In financial analysis, 30–40% of the top-20 recommendations change just depending on whether the model sees the company tickers. Epistemic Blinding lets you measure the contamination: how much of the analysis is your data and how much is the model’s memory of brand reputations. The gist: two parallel requests in separate sessions. In the first — data with codes instead of names. In the second — the same data with real names. Wherever the lists diverge, the model ranked by reputation, not by the numbers.
The paradox: The more context you give a model, the worse it performs. Feed it the question + a big table at once and the model "forgets" parts of the question. A multi-hop request ("calculate X, then compare with Y") turns into an answer about X only.
TabDSR lets you get accurate answers to complex questions about tables, especially when you need several calculation steps and the data is dirty ($3,275, "N/A", notes in parentheses).
The method's trick: it splits the process into three independent steps. The decomposer breaks the question into sub-questions (it works ONLY with the question text and ignores the table). The sanitizer cleans the junk out of the table (currency symbols, percent signs, footnotes). The reasoner generates Python code for each sub-question. Each step covers a separate LLM weakness instead of trying to do everything in one prompt.