You gave ChatGPT a clear instruction. It acknowledged the instruction, maybe even repeated it back to you, and then ignored it completely. This is one of the more frustrating experiences in working with these models, because it looks like a comprehension failure when it usually isn't. The model understood you. It just didn't comply.
Here's why that happens, and what you can do about it.
The Model Is Trained to Be Helpful, Not Obedient
ChatGPT's training process uses Reinforcement Learning from Human Feedback (RLHF), which means human raters shaped the model's behavior by rewarding responses that felt helpful and agreeable. Over time, that reward signal baked in a strong bias: when the model faces a choice between following your instruction strictly and producing something that feels more complete or useful, it often drifts toward the latter.
This is a design outcome, not a bug. The model was optimized to satisfy, and "satisfying" often means adding context you didn't ask for, softening a constraint you stated clearly, or reverting to a default behavior that raters historically rewarded. When your instruction conflicts with that trained instinct, the trained instinct frequently wins.
The practical consequence: if you tell ChatGPT "do not explain the background, just give me the answer," it may give you the answer and then explain the background anyway. It understood the constraint. It overrode it because its training pushes toward thoroughness.
Negative Constraints Leak
Negative instructions, the "do NOT do X" variety, are harder for the model to hold than positive ones. A positive instruction gives the model a target to move toward. A negative instruction asks it to suppress a behavior that its training actively reinforces.
This doesn't mean negative constraints are useless. Hard phrasing matters: "Do NOT include bullet points" performs better than "try to avoid bullet points." The softer version reads as a preference the model can weigh against other factors. The harder version reads as a rule, and the model treats it more like one.
Even so, negative constraints degrade over a long conversation. As the chat grows, earlier instructions carry less weight because the model attends more heavily to recent tokens. A constraint you set in message one may be functionally invisible by message fifteen. This is why you'll sometimes give corrective feedback, the model acknowledges it, and then two responses later the same behavior reappears. The acknowledgment was real. The retention wasn't.
Instruction Burying
Where you place an instruction inside a prompt changes how much the model respects it. Instructions buried in the middle of a long prompt, surrounded by context, examples, and qualifications, get less attention than instructions placed at the start or the end.
The fix is mechanical: put your most important constraints first, before any background or context, and repeat the critical ones at the end. This isn't about the model being lazy. It's about how attention works across a long sequence of tokens. The beginning and end of a prompt are structurally more prominent.
Custom Instructions in ChatGPT compound this problem. Each of the two fields is capped at 1,500 characters, and as a conversation extends, those instructions lose influence to the more recent messages in the thread. If your system-level rules live only in Custom Instructions, they will erode. Task-specific prompts that conflict with your Custom Instructions will often win, because they appear later in the context window.
When Instructions Conflict, the Model Defaults to Agreeable
ChatGPT doesn't have a clean conflict-resolution mechanism that surfaces to the user. When it encounters two instructions that pull in different directions, it doesn't flag the conflict and ask you to resolve it. It defaults to its base training, which is to produce something agreeable and complete.
This creates a specific failure pattern: you set a rule in Custom Instructions, then you write a task prompt that implicitly contradicts that rule, and the model follows the task prompt while quietly dropping the rule. You may not notice until the behavior you were trying to prevent shows up again.
The response to this is to audit your prompts for implicit conflicts before you run them. If your Custom Instructions say "always respond in plain text, no formatting" and your task prompt says "give me a structured breakdown of these five points," you've created a conflict. The model will probably give you formatting.
Long Conversations Break Down Faster Than You Expect
Consistency degrades in long threads. The more constraints you've accumulated, the more likely they are to conflict with each other in ways you didn't anticipate, and the more likely the model is to start making its own judgment calls about which ones to honor.
A few habits that help:
- Start a new conversation when the task changes significantly, rather than continuing a thread that's carrying a lot of accumulated context.
- Restate your most important constraints at the top of each major new prompt within a session, rather than assuming they're still active.
- Keep your constraint list short. A prompt with twelve rules will see more rule-breaking than a prompt with three, because the model has more opportunities to trade one constraint against another.
What Structured Prompts Actually Do
"Write a structured prompt" is advice that gets repeated without much explanation of the mechanism. Here's what it actually changes: a structured prompt separates your constraints from your context from your task, so the model can parse each component clearly. When everything runs together in a paragraph, the model has to infer what's a rule and what's background. When you separate them explicitly, that inference step goes away.
A minimal structure that works:
Constraints (listed first, hard language) Context (what the model needs to know) Task (what you want it to produce)
This isn't a magic format. It's a way of reducing the ambiguity that gives the model room to drift.
The Underlying Issue
Instruction-following in ChatGPT is not purely a prompt-writing problem. The model's conversational state tracking is limited, its training creates genuine tension between compliance and helpfulness, and long threads accumulate enough noise that even well-written instructions lose their grip. You can write better prompts and get meaningfully better results, but you're working with a model that was shaped to satisfy rather than to obey.
Knowing that changes how you approach it. You're not trying to write a perfect instruction that the model will follow forever. You're managing attention, reducing ambiguity, and minimizing the gaps where the model's defaults can fill in.
If bad output keeps following you across tools and models, the prompt is usually where the problem starts. FixMyPrompt scores your prompt from 0 to 100, flags the specific weak spots (buried constraints, conflicting instructions, soft language where hard language would work better), and rewrites it. Try it at FixMyPrompt.com/try.
Sources
- OpenAI. "Reinforcement Learning from Human Feedback (RLHF)." https://openai.com/research/learning-to-summarize-with-human-feedback
- OpenAI Help Center. "Custom Instructions for ChatGPT." https://help.openai.com/en/articles/8096356-custom-instructions-for-chatgpt
- Anthropic. "Core Views on AI Safety." https://www.anthropic.com/index/core-views-on-ai-safety
- OpenAI. "GPT-4 Technical Report." https://arxiv.org/abs/2303.08774
- Perez, E., et al. "Red Teaming Language Models with Language Models." https://arxiv.org/abs/2202.03286
Sources
- https://resources.opencraftai.com/blog/why-chatgpt-keeps-ignoring-custom-instructions-and-what-actually-works
- https://aitoolsusageguide.org/chatgpt-ignores-instructions
- https://www.memorylake.ai/en/blogs/chatgpt-forgets-custom-instructions
- https://docs.bswen.com/blog/2026-02-22-why-chatgpt-ignores-instructions
- https://community.openai.com/t/catastrophic-failures-of-chatgpt-thats-creating-major-problems-for-users/1156230
- https://community.openai.com/t/assistant-ignores-latest-instructions-and-overrides-user-constraints-in-edits/1379048