Why AI stops following my instructions in a long chat
The short answer
Your instruction is one small block inside a much larger request. With a vendor system prompt in front of it and a thousand tokens of conversation behind it, a one-line rule is about 0.2% of what the model reads. Measured performance on long inputs also falls as that request grows, so the same rule holds worse at turn forty than at turn two.
one rule in a growing request
Anthropic's published Claude Opus 5 system prompt, dated 24 July 2026, is 4,224 tokens. Add 1,000 tokens of conversation and the default standing instruction — 12 tokens, one line — is 0.2% of the 5,243 tokens that reach the model before it writes anything. Push the conversation to 50,000 tokens and the same line is 0.02%.
What’s actually happening
Every turn, the app assembles a fresh request and sends the whole thing. Your standing instruction is one block inside it, and usually one of the smallest.
Start with what arrives before you type anything. Anthropic publishes the system prompts its chat apps put in front of every conversation, dated by model. The Claude Opus 5 prompt published on 24 July 2026 measures 4,224 tokens — text you did not write, do not see, and cannot edit. That number is not a guess: it is the published text, counted with the same tokenizer the demo above runs on yours.
Now add the conversation. At a thousand tokens of history — a short chat, maybe six exchanges — the request is 5,243 tokens and your one-line rule is twelve of them. Two tenths of one percent. Push the conversation to fifty thousand tokens and the same line is two hundredths of a percent. Nothing about the rule changed; everything around it grew.
That is a fact about the request, not an explanation of the behaviour. The demo above measures composition and stops there — it does not show why a model did or did not follow a rule, and we are not going to pretend a bar chart proves causation.
For the causal half, the evidence comes from benchmarks. LIFBench tested twenty models on instruction following across six length intervals and reports that:
the performance of most models declines significantly as input length increases, particularly beyond 16k or 32k tokens
The same benchmark adds that “most models demonstrate poorer stability in long-context scenarios, with the lowest stability observed at the longest input lengths”.
A separate result rules out the obvious excuse. In Context Length Alone Hurts LLM Performance Despite Perfect Retrieval, the authors found that:
even when models can perfectly retrieve all relevant information, their performance still degrades substantially (13.9%–85%) as input length increases but remains well within their claimed context lengths
So this is not only about the instruction being hard to find. Length by itself costs accuracy.
Put those together and the shape of your Tuesday afternoon makes sense. The rule you set at the start was never large, and the request it lives in has been growing all day.
What to do about it
Put the rule in the message that needs it. Not as a reminder, as part of the ask: “Rewrite this section in British English, no bullet points.” One extra clause beats a rule set an hour ago.
Keep rules short and checkable. “Answer in British English” either happened or it did not. “Write in our house style” cannot be checked by you or followed reliably by anything else.
Move standing rules out of the transcript. If your app has a settings field for custom or project instructions, a rule there is re-sent with every request instead of ageing out of the conversation. It does not become large, but it stops disappearing.
Split long work into fresh chats. One conversation per task, opening with the rules that task needs, avoids the slow dilution entirely — and avoids the quality loss that comes with length on its own.
Know how big your own text is. Token counter measures an instruction in the same unit the model is billed and limited in, which is the only way to see how small a standing rule really is next to everything shipped with it.
Common questions
- 1 Does the model decide to ignore me?
- Nothing here shows intent, and neither do we. What the demo shows is composition: how small your instruction is inside the request. Whether the model then follows it is a separate question, and the honest answer comes from measurement rather than from the picture — the benchmark cited below found that instruction following degrades as inputs get longer.
- 2 Why does repeating the instruction work?
- Because a fresh copy sits at the end of the request rather than far behind it, and because you have just spent tokens on the one thing you care about instead of on everything else. It is a blunt fix, and it is the one that reliably works.
- 3 Are custom instructions better than typing the rule in the chat?
- They are re-sent rather than typed again, which removes the risk of the rule ageing out of a long conversation. They do not change the proportions: the rule is still a small block inside a large request, competing with everything else in it.