ChatGPT Not Following Instructions? Why, and How to Fix It

You tell ChatGPT to skip the bullet points, and three replies later the bullet points are back. You paste a rule at the top of the chat, and it quietly ignores it. This is the single most common ChatGPT complaint that isn't about wrong answers, and the frustrating part is that the tool isn't broken. It's doing exactly what it was trained to do, which is often not what you told it to do.

The fix depends on which of three separate problems you have, and most guides blur them together. This one splits them, explains why each happens in plain English, and gives you a copy-paste prompt for each. It's a troubleshooting guide for when instructions get ignored, not a general lesson in writing a clearer prompt or a walkthrough of the Custom Instructions feature.

Which of the three is happening to you?

ChatGPT ignoring instructions is almost always one of three distinct failures, and naming yours first saves you from applying the wrong fix. Match your symptom to the row.

If it's more than one, start at the top. A one-off ignored prompt is the easiest to fix, and long-chat drift is the most common by far.

Why ChatGPT stops following instructions

ChatGPT stops following an instruction because your rule loses a competition inside the model's context, not because it decided to disobey. Two forces drive it. First, the model is tuned to be helpful and complete, so when your rule ("keep it short") fights that pull ("answer thoroughly"), the helpful instinct often wins. Second, and more importantly, there's an ordering rule.

OpenAI's Model Spec, the public document that defines how its models resolve conflicting instructions, sets out a five-level hierarchy: platform and developer rules outrank you, and you outrank the model's soft defaults. Within your own level, though, one line matters most: later messages override earlier contradictory ones. That's the whole game. The rule you set in message one is genuinely outranked by your message twenty, and by the model's own recent replies. In a long chat, older turns also get summarized or pushed out of the working context, so your original instruction may not even be in front of the model any more. As one OpenAI forum user put it after their rule kept failing, the instruction didn't get defied, it faded. That single mechanism explains most of what follows, and it's why the best fix is so simple: put the rule where it's recent.

Fix 1: when a single prompt gets ignored

A one-off ignored instruction is usually caused by too many rules, rules that conflict, or rules phrased as "don't." Fixing the prompt fixes the behavior, no restart needed.

Cut your rules to the few that matter, and number them. Adherence falls as you pile on constraints, and it falls faster when two of them quietly contradict, like asking for something exhaustive and also two sentences long. If order of importance matters, say so: tell it which rule wins when two clash. And put the execution rules at the end of the prompt, not buried in the middle, because recent text carries more weight.

The bigger lever is phrasing. Negative instructions are followed less reliably than positive ones, because "don't use jargon" makes the model represent jargon and then suppress it, which is harder than aiming at a clear target. OpenAI's own prompt-engineering guidance says it plainly: tell the model what to do instead of what not to do. Here's the difference in practice.

A pile of "don'ts," which tends to leak:

Don't be wordy, don't use bullet points, don't use jargon, and don't be too formal.

The same intent as positive targets, which lands far more often:

Write in three short, plain-English paragraphs with a friendly, conversational tone. Keep it under 120 words.

When you need to keep a rule you can only think of as a "don't," ask ChatGPT to convert it for you first:

Rewrite this instruction so it only says what to do, with no 'don't', 'never', or 'avoid': '[paste your negative instruction]'. Give me the positive version, then follow it.

Fix 2: when it drifts in a long chat

Mid-chat drift is when ChatGPT obeys a rule at first and then abandons it after several exchanges, and it's the direct result of that later-overrides-earlier ordering. Your instruction is still technically in the conversation, but its influence has been diluted by everything since, including the model's own replies in the wrong format.

The most reliable fix is to move the rule to where it's recent. Restate it in the turn where it actually matters rather than trusting the version from twenty messages ago. This prompt re-pins your rules and makes the model acknowledge them before it answers:

Before you answer, re-apply these rules for the rest of this chat, in priority order: 1) [most important rule], 2) [second rule], 3) [third rule]. If two rules conflict, the lower number wins. Confirm you have applied them, then answer my next message.

A specific kind of drift is worth its own fix: the model adding things you didn't ask for, or expanding past the length you set. Lock the task and the format together, and give it a one-line example to copy:

Task: [one task only]. Output format, follow exactly: three short paragraphs, plain sentences, no bullet points, no headings, under 120 words. Match this target style: '[one line in the exact voice you want]'. If you can't meet a constraint, say so instead of breaking it.

If restating twice doesn't hold, the context is too polluted to save. Start a fresh chat and paste in only what matters: the task, the rules, and the last good output. Keeping one chat to one focused task is the habit that prevents this in the first place.

Fix 3: when Custom Instructions or Memory get ignored

When a rule you set once fails across every new chat, the culprit is Custom Instructions or Memory, not the individual prompt. These are the two places ChatGPT stores standing rules, and both can be quietly overridden or can fight each other.

Custom Instructions apply to new chats only, and existing chats won't pick up an edit, so open a fresh chat after changing them. They're injected as background context, which means a strong, specific per-chat prompt usually beats them, and a long thread dilutes them like anything else. Keep them short and concrete, and reserve them for durable rules you always want, not one-off preferences. If you rely on them heavily, our guide to how to set persistent rules with Custom Instructions covers writing them well.

Memory is the sneakier one. A fact ChatGPT saved weeks ago, a preference from a different project, can silently override what you're asking for now, because Memory is injected into new chats automatically. When a rule keeps failing in brand-new chats for no obvious reason, check Settings, then Personalization, then Memory, and delete the stale entry. For a one-off task you don't want Memory to touch or record, use a Temporary Chat. To see what's being applied before you go digging, ask directly:

List every standing rule you are applying to me right now from memory or custom instructions that could affect this task. For each, say whether it conflicts with this instruction: '[your current rule]'. Then follow my current rule and ignore any conflicting saved one for this chat.

The "it apologizes then does it again" loop

The apology loop is when ChatGPT says sorry, agrees it broke your rule, and then breaks it again in the very next reply. It happens because the apology is just generated text, not a change to the model's rules. The faulty pattern, including its own wrong answer, is still the strongest thing in the recent context, so it reproduces it, and a vague "no, don't do that" gives it nothing concrete to aim at.

Break the loop by refusing to accept another apology and forcing a concrete reset instead. This prompt makes the model diagnose the specific breach and hold before retrying, which stops the reflexive repeat:

Don't rewrite anything yet. First, restate in your own words the exact constraint I gave you and how your last answer broke it. Then wait for me to confirm before you try again.

If it still fails after two or three tries, stop. The chat is contaminated by its own repeated mistake. Open a fresh one, paste the rule and the last correct example, and carry on there.

What changed in GPT-5, and what still breaks

ChatGPT's current model, GPT-5.6 as of August 2026, follows instructions more reliably than the GPT-4 generation that most complaint threads were written about. OpenAI's GPT-5 System Card formalized the system-over-developer-over-user hierarchy, and the GPT-5 series was tuned to hold formatting and tone across a whole conversation and to stop once a task is done rather than padding the answer with extras. In practice, the "obeyed for three replies then drifted" pattern is less severe than it was in 2024 and early 2025.

It isn't solved, though. Drift still shows up in very long or messy chats, negative instructions are still weaker than positive ones, and a conflicting Memory entry will still override you regardless of the model version. Treat the newer model as raising the floor, not removing the need for the fixes above.

Custom GPTs, Projects, and the API

One case looks like an instruction-following bug but isn't: being unable to override a behavior inside a Custom GPT, a Project, or an API app. Per the Model Spec hierarchy, a Custom GPT's builder instructions and any platform rules sit above you as an end user, so you can't just tell it to drop them. This is also why prompt-injection attempts like "ignore all previous instructions" fail against a well-built app: your message is a lower authority level than the developer's rules, by design. If a Custom GPT won't behave the way you want, the rule you're fighting is baked in above your level, and the fix is a different GPT or your own prompt, not a cleverer override.

What this guide does not cover

This is a fix-it guide for when ChatGPT ignores, forgets, or overrides instructions, not a general prompting tutorial and not a feature walkthrough. For building good prompts from scratch, see writing a clearer prompt; for the Custom Instructions feature itself, the Custom Instructions guide goes deeper. If your problem is that the answer is factually wrong rather than off-format, that's a different issue we cover in when the answer is wrong, not just off-format. Model behavior shifts with each update, so the specifics here are current to August 2026 and the model named is GPT-5.6; confirm anything version-specific against OpenAI's own pages.

Sources

1. OpenAI Model Spec (instruction hierarchy; later messages override earlier)
2. OpenAI Help Center: best practices for prompt engineering (tell it what to do, not what not to do)
3. OpenAI: Memory and new controls for ChatGPT
4. OpenAI: GPT-5 System Card (system-over-user instruction hierarchy)