Why the LLM ignores your instructions, and what fixes it

The symptom: the prompt grows, rules start to drop

A system prompt starts with five rules and works. Over weeks it grows to forty: tone, bans, formats, closing phrases. Then the model begins skipping some of them, usually without saying so. A closing JSON block goes missing, a banned word reappears, the answer runs long, or the model answers a different question than the one you asked.

The failures are not random. In a study of instruction load, overloaded models mostly omitted instructions rather than executing them wrongly, and the omissions came from the end of the list. In a Microsoft study of format requirements, "do something at the end" requirements failed up to 50% of the time on hard tasks, while bans like "don't use commas" held up almost perfectly.

Why it happens

Four mechanisms recur across the papers.

• Arithmetic of many rules. If each rule is followed 98% of the time, the chance of following all 80 at once is close to zero. The breaking-point study saw near-full compliance at 10-40 rules and perfect compliance falling to zero at 80, for all five models and in every format.
• Constraints compete with the task. The constraint-paradox study added constraints taken from the model's own successful answers; 5 of them cut task success by 15-40% while the constraints themselves were met 94%+ of the time. Attention moved from substance to form.
• Distance between the rule and the moment of use. The model weighs nearby text most. A requirement stated at the top fades by the end of a long answer, which is why terminal requirements fail (salience study) and why a task buried mid-context gets lost (task-position study).
• Helpfulness reflexes override limits. The U-curve study found medium-length prompts (~27 words) worst for length limits: enough context to trigger a detailed answer, not enough to signal that the limit matters. 97% of experiments showed the U shape.

Fixes ranked by measured effect

1. Put the task last, or repeat it at the end. In the task-position study, moving a question from the end to the middle of a long context dropped some models from 96% to 8%; 76% of mid-position errors were answers copied from neighboring examples. Repeating the task at the end brought all 9 models back to within ±4 points of the best position at 8K tokens.
2. Delete constraints the model would meet anyway. Each unnecessary length, keyword or style rule costs task accuracy: Claude-Sonnet-4.5 lost 15% on multi-hop questions and 30-70B models kept only 65-85% of their accuracy (constraint paradox). For agents, a minimal prompt beat a heavily instructed one by 32% on search tasks; "use tools" alone carried 70% of the benefit.
3. Tag the requirement at the start and remind at the end. The salience reminder brought compliance from 70–87% back to 90–100%. With five stacked requirements, o4-mini fell from 99% to 47.5%, so a specific reminder beats "follow everything".
4. Write bans, not directives. In an ablation of 18 real agent rules on Claude Opus, all helpful rules were prohibitions and all harmful ones were prescriptions; removing "don't touch unrelated code" cost 20 points. Merely having structured rules gave +7–14%.
5. Keep a small critical tier. Split rules into a short critical set and send the rest separately (breaking-point study).
6. Go short or go full, avoid the middle. Removing "comprehensive" and "helpful" from the system prompt improved length compliance by 598% (71 of 72 tests) in the U-curve study.
7. Extract the rules before answering. Asked only to extract requirements from a long spec, models recovered 94.4% of hidden rules (spec contract); listing constraints first keeps them next to the answer (constraint-first reasoning).
8. State rules as facts. Rewriting 3 of 11 commands into declarative form ("Emoji: disabled") improved all 11 (declarative register).
9. Make manner rules countable. An agent forbidden to praise still praised in half of 17,930 turns, while it kept a length limit (checkable vs manner rules).

A combined prompt stack

1. Top: role and goal, then a short critical tier written as bans or Parameter: state lines with numbers where possible (guardrails, declarative, checkable).
2. Middle: documents and examples. If a document carries its own rules, run an extraction pass first and paste the numbered list here (spec contract).
3. End: the task itself, then a specific reminder: Make sure to follow ALL the format requirements stated above, naming the terminal ones (task last, salience reminder).
4. After generation: a separate check against the list, met / not met, then targeted fixes (Re5 draft-check-fix). For mixed inputs, classify first and send only the matching rules (classification-guided prompting).

What does not work, and where the papers disagree

• Reordering as a cure for overload. The constraint paradox tried constraint-first, task-first and "solve first, then format": every variant still dropped. Order helps salience; it does not remove interference.
• Top versus bottom. The primacy study says put the most important instruction first; the tail gets skipped. The task-position study and the salience study say the question and terminal requirements belong at the end. VeriCode found middle instructions followed 5-10% worse than first or last ones, with primacy in a single prompt and recency when rules arrive turn by turn. Read together: rules at the top, task at the bottom, critical rule repeated at the bottom.
• How many rules is too many. The guardrails study saw no drop up to 50 rules in agent task success, the breaking-point study saw full compliance collapse at 80, and the constraint paradox saw 5 constraints hurt accuracy. They measure different things: task success, all-rules compliance, and accuracy under extra constraints.
• Bans are not universal. Bans held for concrete actions, but "don't flatter" failed because nothing can be counted (manner rules).
• "Think step by step" for constraints. It broke constraint adherence on all three models in SR to QR; RID also warns that free reasoning can rationalize blind rule-following.
• Telling the model to ignore old rules. Terms still in context keep pulling the output; rewrite the state document instead (the Pan principle, from 391 sessions).

IMPORTANT FORMAT REQUIREMENT: {format_requirement}

{main_task}

{additional_instructions_if_needed}

Make sure to follow ALL the format requirements stated above.

{context_part_1}

{intermediate_instruction}

{context_part_2}

────────────────────────────────────────

Reminder, your task is: {question_or_instruction}

You are a {role}.

Prohibitions (what not to do):
— Don't {unwanted action 1}
— Don't {unwanted action 2}
— Don't {unwanted action 3}
— Don't {unwanted action 4}
— Don't {unwanted action 5}

{optional: 1-2 lines of context about the project or task}