💬 NLP

Prompt Design at Scale: How Format, Instruction Count, and Context Length Shape Instruction Adherence and Hallucination in Large Language Models

This paper presents a controlled evaluation using the synthetic "Book of Veyra" corpus across five models, revealing that instruction adherence collapses when rule counts exceed 80 regardless of format, while long-context performance is characterized by sharp recall degradation and refusal rates rather than hallucinations, with no consistent advantage for markdown over plain text.

Original authors: Netanel Eliav

Published 2026-07-22

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Netanel Eliav

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a super-smart robot how to do a job. You have a few levers you can pull to make it work better. One lever is format: you can write your instructions as a neat list, a boring paragraph, a fancy table, or just plain text. Another lever is scale: how many instructions you give it at once, and how much background information (like a giant book) you ask it to remember while it works. For a long time, people argued about which writing style was best, assuming the robot would understand them perfectly no matter how many rules you added or how thick the book was. But in the world of Artificial Intelligence, specifically with Large Language Models (the kind of AI that writes stories and answers questions), there's a growing suspicion that these levers don't work in isolation. If you give the robot too many rules, or ask it to remember too much, the style of your writing might suddenly stop mattering, or worse, it might start breaking in weird ways. This paper asks a simple but tricky question: Does the way you format your instructions actually help, or does it just get lost in the noise when the task gets huge?

The researchers behind this study, Netanel Eliav from the Machine Human Intelligence Lab, decided to stop guessing and start testing. They built a giant, fake universe called the "Book of Veyra." Think of it as a massive, made-up encyclopedia containing 8,780 unique fictional things—like solar systems, guilds, and strange creatures—each with specific facts about them. Because the book was made by a computer program and not by reading the internet, the AI couldn't have memorized it beforehand; it had to actually read the pages provided to it to find the answers. They took this same book and wrote it out in four different ways: as a Markdown list (with bold headers and bullets), as plain text (just the words), as flowing prose (like a story), and as a table. Then, they put this book in front of five different AI models and ran two massive experiments.

First, they tested Instruction Following. They gave the AI a list of rules to follow while writing a short essay. They started with 10 rules and kept adding more, up to 160 rules at once. They wanted to see if the AI could still follow all the rules perfectly as the list got longer, and if writing those rules in a fancy list format helped more than writing them in a paragraph. The result was a hard crash. No matter how the rules were written, once the list hit about 80 rules, the AI's ability to follow every single one perfectly dropped to zero. It didn't matter if the rules were in a table or a list; the AI just gave up on getting everything right. Surprisingly, where you put the rules mattered more than how they looked. Putting the rules in the "system prompt" (the robot's hidden brain instructions) versus the "user turn" (the chat message) changed the results significantly, but in different ways for different robots. For some models, putting rules in the chat helped; for others, it hurt. There was no universal "best" place to put them.

Second, they tested Memory and Honesty with the Book of Veyra. They fed the AI chunks of the book ranging from 2,000 words to a massive 512,000 words. They asked the AI to recall specific facts, check if the AI would lie to agree with a false statement (sycophancy), or make up facts that weren't there (hallucination). The results were fascinating. Up to about 64,000 to 128,000 words, the AI remembered everything perfectly, regardless of the format. But once they crossed that threshold, things got messy. The accuracy didn't just slowly fade; it crashed, and how it crashed depended entirely on the format and the specific AI model. For one model, plain text was terrible at 128k words, while lists and tables worked great. For another, the opposite was true. There was no single "best" format.

Here is the biggest surprise: The AI didn't start making up lies or agreeing with false statements more often as the book got longer. In fact, the rate of making up facts was zero, and agreeing with lies stayed very low. Instead, the AI started doing something else entirely: refusing to answer. As the book got closer to the model's memory limit, the AI would just say, "I don't know" or "I can't answer that," sometimes refusing to answer up to 90% of the time. It wasn't getting confused and lying; it was getting overwhelmed and shutting down.

The paper also looked at the cost. Some formats, like tables, take up more "tokens" (the currency AI uses to measure text length) than plain text. When the researchers adjusted the scores to see which format gave the best accuracy per token spent, the winners changed again. Sometimes a format that looked slightly less accurate was actually the better deal because it was cheaper to read.

The main takeaway is that you can't just pick a "best" format like Markdown or a Table and assume it will always work. The paper proves that format is useless if you don't also consider the scale. If you have too many instructions (around 80 or more), the format doesn't matter because the AI hits a wall. If you have a huge context (over 128k words), the format matters a lot, but the "best" one changes depending on which AI model you are using. The authors conclude that the failure mode we should worry about isn't the AI lying; it's the AI giving up and refusing to answer when the task gets too big. They released all their tools and the fake "Book of Veyra" so anyone can test these limits themselves, because the rules of the game seem to change for every new robot you meet.

Technical Summary: Prompt Design at Scale

Problem Statement

Practitioners designing Large Language Model (LLM) systems currently make three critical decisions with little controlled evidence: how to format instructions and context (markdown, plain text, prose, or tabular), how many simultaneous instructions a system can handle before compliance degrades, and how much context a model can retain before recall and honesty fail. Existing literature typically studies these factors in isolation—either varying format while holding scale constant, or varying scale (instruction count or context length) while holding format fixed. This paper argues that format cannot be evaluated in isolation from scale; a format that performs well at low scale may fail catastrophically at high scale, and vice versa.

Methodology

The authors conducted two controlled experiments using a single, contamination-free synthetic corpus, the "Book of Veyra," generated deterministically from a fixed seed without LLM involvement. The corpus contains 8,780 uniquely named fictional entities with interlocking attributes, ensuring no pre-training leakage.

The Corpus and Renderings:
The underlying facts were rendered in four distinct formats, holding content byte-identical across all versions:

Markdown: Headers and bold key-value bullets.
Plain Text: Identical content with all markup stripped.
Prose: Flowing narrative sentences.
Table: Markdown key-value tables.

Experiment 1: Instruction-Following Decay

Design: Models were tasked with writing essays while adhering to $N$ simultaneous, programmatically verifiable rules (where $N \in \{10, 20, 40, 80, 120, 160\}$ ).
Variables: The rule block was rendered in all four formats and placed in either the system prompt or the user turn.
Models: Five models across two capability tiers and three families: Claude Sonnet 5, Claude Haiku, Gemini Flash, Qwen 27B, and Qwen 35B.
Metric: Perfect-response rate (all rules satisfied).

Experiment 2: Hallucination Across the Context Ladder

Design: The Book of Veyra was sliced into a context ladder ranging from 2k to 512k tokens.
Probes: At each rung, three probe types were tested:
1. Recall: Retrieving specific, unguessable facts.
2. False-Premise: Testing agreement with stated falsehoods (sycophancy).
3. Absent-Fact: Testing fabrication of facts never stated.
Metrics: Recall accuracy, sycophancy rate, fabrication rate, and refusal rate.

Key Contributions

Joint Decay-and-Placement Analysis: The paper crosses instruction-count decay curves against both format and prompt placement (system vs. user turn), finding that placement effects rival or exceed format effects in magnitude, though the direction is model-specific.
Four-Format, Long-Context Factorial: It measures recall, sycophancy, and fabrication jointly across a 2k–512k token ladder in four formats on a single corpus, a combination not previously explored.
Structure-vs-Syntax Decomposition: By holding content identical across list-structured markdown, tables, unstructured plain text, and prose, the study isolates whether "structure" generally helps or if "tabular structure" is the specific active ingredient.
Token-Overhead-Adjusted Accuracy: The authors demonstrate that format accuracy advantages do not always survive when adjusted for the token cost overhead (22%–37% higher for structured formats).
VeyraBench: The release of the full benchmark harness, corpus generator, and raw results for byte-identical reproduction.

Key Results

Instruction Following (Experiment 1)

The Decay Floor: Perfect-response rates collapse to zero by $N=80$ for every model, format, and placement. This "floor effect" is independent of format.
No Universal Format Winner: No model consistently favored markdown. One model (Qwen 35B) reliably favored plain text over markdown at high instruction counts.
Placement Matters: Moving the rule block from the system prompt to the user turn significantly altered adherence (up to 8.7 percentage points) for four of five models. The effect direction was model-specific (helping some, hurting others).
Model-Specific Collapse: Gemini Flash exhibited a sharp, model-specific collapse in performance for prose and table formats at $N \ge 40$ , linked to a "hidden-reasoning-leakage" failure mode where the model output internal verification text instead of the essay.

Long-Context Hallucination (Experiment 2)

Recall Accuracy: Recall remained near ceiling (0.98–1.00) up to 64k–128k tokens, then degraded sharply. The degradation was format-dependent and tracked proximity to the model's effective context ceiling rather than absolute token count.
No Universal Ranking: Neither "structure helps" nor "tables help" hypotheses held. Prose was the best performer in several high-stress cells, while plain text was the worst in others. The ranking of formats flipped between models and context lengths.
Null Results for Fabrication and Sycophancy:
- Fabrication: 0/5,760 absent-fact probes resulted in fabrication.
- Sycophancy: Agreement with false premises remained negligible ( $\le 8.3\%$ ) throughout.
The Rise of Refusal: The primary failure mode near context ceilings was not hallucination but outright refusal to answer. Refusal rates climbed sharply (up to 89.6% for Claude Haiku at its ceiling) as context length increased, a distinct failure mode from sycophancy or fabrication.
Cost-Adjusted Accuracy: In cases where raw accuracy differed significantly, the token overhead of structured formats (e.g., tables costing 1.367× plain text) often reversed the ranking, making plain text or prose the more efficient choice.

Significance and Claims

The paper claims that the prevailing assumption that format can be optimized in isolation is a mistake. The headline finding is that neither a format's effect nor its sign can be predicted without accounting for scale.

Scale Dependency: A format's performance is inextricably linked to instruction count and context length. A "best practice" for 10 instructions may be a failure mode for 100.
Refusal over Hallucination: As models approach their context limits, the dominant failure mode shifts from generating false information (hallucination/sycophancy) to refusing to answer. Systems monitoring only for wrong answers may miss this critical degradation.
Model Specificity: There is no universal "best" format or placement. Effects are highly model-specific; a configuration that works for one model may degrade another.
Practical Implication: Practitioners should not default to markdown or any specific format without empirical testing on their specific model and scale. Furthermore, when instruction counts exceed ~40, the solution is likely architectural (splitting tasks) rather than prompt-engineering (reformatting).

The authors conclude that claims about optimal prompt formats must specify the scale (instruction count or context length) at which they were measured to be meaningful. The paper provides the VeyraBench to enable the community to re-measure these thresholds as models evolve.