Why AI Forgets Your Instructions
You told the AI exactly what to do. It did something else. This isn't a prompting failure — it's how language models are designed to work, and understanding it changes how you use them.
At some point, anyone who has used an AI writing tool has said some version of the same thing: "I literally told it not to do that."
You said keep it under 300 words. It gave you 600. You said don't use passive voice. It used passive voice. You said the character's name is Marcus. It started calling him Michael in paragraph four.
This isn't user error. It's not a prompting skill you haven't learned yet. It's a structural characteristic of how these models work — one that nobody explains clearly, and that has a specific name: instruction decay.
Memory is not memory
When you type instructions into an AI tool, you're not saving them anywhere. You're putting them in the context window — the text the model is considering right now, in this request. The model reads the context window, generates a response, and forgets everything. Every new request is the first time it has ever heard from you.
This surprises people. It feels like the model should remember. The chat interface looks like a conversation. But there's no persistent state. No internal record of what you said in session one that carries to session two. When you start a new chat, you start from zero.
Why instructions fade even within a session
The more surprising problem is that instructions can drift even within a single session, on a single long generation.
Context windows have limits. When you prompt a model with five paragraphs of instructions and then ask it to write three pages, those three pages take up more space in the context window than your instructions did. As the generation grows, the model's attention is distributed across everything in the window — and recent, verbose content carries more weight than earlier, concise instructions.
Your rule "don't use passive voice" is fifty characters. The prose the model just generated is several thousand. By page two, the model is predicting what comes next largely from what it just wrote — and what it just wrote didn't have a passive voice prohibition baked into it. The instruction has diluted.
This is not carelessness. It's the math of attention mechanisms: more recent, more voluminous content pulls more weight. Your instructions lose the competition.
The prompting instinct
The natural response is to try harder. Write longer instructions. Add emphasis. Use bold or all-caps on the important rules. Put them at the end of the prompt instead of the beginning. Repeat the most important ones multiple times.
Some of this helps at the margins. None of it solves the structural problem. Longer prompts cost more per generation. Emphasis in text doesn't change how the model weights tokens — the model doesn't treat "DO NOT USE PASSIVE VOICE" differently than "do not use passive voice." Repetition helps briefly and then dilutes faster because you've added more text for the instructions to compete against.
Prompting is a workaround. It delays the problem; it doesn't eliminate it.
What enforcement actually requires
Rules that reliably hold across a long generation and across sessions require two things that prompt engineering cannot provide.
First, the rules need to be injected at the system level, before every generation, automatically. Not pasted by you into a prompt — stored in the tool and included without your intervention. This means you can't forget. It means the rules are always fresh, always present, always weighted at the start of the context rather than buried under prior output.
Second, the output needs to be checked against the rules before it reaches you. Not by you — by the tool. If the generation violates a constraint you've set, the tool catches it and tells you which rule was broken and where. You decide what to do. The violation doesn't ship while you're focused on something else.
This is the difference between writing rules and enforcing rules. Prompting writes rules. Systems enforce them.
The upshot
The problem isn't that AI is bad at following instructions. It's that the architecture of most AI tools treats your instructions as context — text that competes with everything else in the window — rather than as constraints that govern what can and cannot be generated.
Until that changes at the tool level, "I literally told it not to do that" will keep happening. Not because you're prompting wrong. Because you're using a tool that wasn't designed to enforce what you said.