ChatGPT Project Instructions Ignored: Why and How to Fix It

You wrote detailed Project instructions and ChatGPT keeps ignoring them mid-conversation. It is almost always instruction weight, a conflict with your current message, the 1,500-char field limit, or Memory overriding the rule. Here is the fix.

Published: May 17, 2026 Updated: Jun 15, 2026 Author: AI Productivity Guide Team 🌐 查看中文版本

Fastest fix: put your 2-3 hardest rules in the first lines of the Project instructions field (open the project, click the three-dot menu top-right, then Project settings to edit), then restate those rules at the top of each message with a bracketed line like [Rules: reply in zh-CN, max 200 words, one paragraph]. Those two moves clear roughly 70% of “it won’t listen” cases. The rest is figuring out which layer of the weight stack overrode your rule.

Project instructions are a soft constraint. ChatGPT rewrites your instructions field into a short system message at the start of each chat (each field caps at 1,500 characters as of June 2026), and that system message sits below your current user message in priority and gets pushed toward the back of context as the conversation grows. So “it ignored my instruction” is usually predictable: a specific rule, in a specific layer, got outweighed. Put rules in the right place, write them positively, and restate them, and adherence goes from roughly 40% to 90%+.

Which bucket are you in?

Symptom	Most likely cause	Jump to
Breaks only on certain task types (e.g. “translate”)	Current message overrides the rule	Cause 1
Obeys early, drifts after ~20-30 turns	Long-context dilution	Cause 2
Rule is phrased as “don’t / never / avoid”	Negative instructions are weak	Cause 3
Verbose only after a tool runs	Tool output overrides style rules	Cause 4
Length / format never holds	Rule has no worked example	Cause 5
Field is long, key rule mid-paragraph	Rule buried past the high-attention zone	Cause 6
Behaves differently across your devices/chats	Memory is fighting the rule	Cause 7

Common causes, by hit rate

1. Your current message overrides the rule

The single most common failure. The instructions say “always reply in zh-CN,” but your message is “Translate this English text.” The model reads “translate” as “produce English,” and when a rule conflicts with the live request, the live request wins — it carries more attention weight than the rewritten system message.

How to spot it: ask in isolation, “reply in zh-CN with one sentence.” If it complies, the rule is executable; if only certain tasks break it, you have a task-level override, not a broken rule.

2. Long conversations dilute the instructions

Transformer attention is recency-weighted. By message 30, the instructions sitting at the very top of context get far less weight than your latest turn, so the early “reply in Chinese” rule loses out to “answer this question fully.” A dropped-in PDF or a Code Interpreter run makes it worse: large chunks of text get inserted above your latest message and crowd the instructions further back.

How to spot it: first few turns comply, mid-to-late turns drift. Open a fresh chat with the same prompt; if the first turns comply again, dilution is confirmed.

3. Negative rules are weaker than positive ones

“Don’t ask follow-up questions” is almost always ignored; “Give one final paragraph, no questions” holds far better. Models follow “do Y” more reliably than “don’t do X.”

How to spot it: if your instructions contain more “don’t / never / avoid” than “do / always / output,” this is your dominant cause.

4. Tool calls override style rules

When Web Search, Code Interpreter, or image generation runs, each tool has its own output conventions that temporarily override your “be brief” formatting rules.

How to spot it: plain-text replies comply; replies right after a tool runs are verbose or reformatted = tool override.

5. Format and length rules lack an example

“Reply in under 200 words” rarely works — the model does not reliably count tokens. A shown example (“Output exactly like this:” followed by a real ~180-word sample) works far better, because the model pattern-matches the shape instead of counting.

How to spot it: your format rules are described in words but have no worked example.

6. The key rule is buried, or the field is over 1,500 chars

Attention on the instructions is heaviest in the opening lines. A “always reply in Chinese” rule sitting in paragraph 4, line 7 gets drowned. Worse: the instructions field is capped at 1,500 characters, and if you stuff it, your detailed style guide gets compressed into terse phrasing the model then misreads.

How to spot it: your instructions run long and the most important rule is not in the first 2-3 lines. If you are near the 1,500-char ceiling, that is its own problem — trim hard guidance into the first lines and move the rest into a project file.

7. Memory is counteracting the rule

Note the priority order first: inside a project, your Project instructions override your global Custom Instructions. So Custom Instructions are rarely the culprit. Memory is the usual conflict source. ChatGPT has two memory layers as of June 2026: saved memories (an explicit, editable list) and reference chat history (implicit recall of past chats). If a saved memory says “user prefers brief English answers,” it can pull against your project’s “Chinese long-form” rule.

How to spot it: temporarily turn Memory off (Settings → Personalization → Memory; toggle off Reference saved memories and Reference chat history independently) and rerun. If adherence changes, Memory was interfering.

Before you start

Confirm this is a Project (not a Custom GPT or a plain chat) — the fixes below are project-specific.
Duplicate or branch the chat before retesting, so existing history does not pollute the next diagnostic run.
Note your plan. Projects are now available on every tier including Free (as of June 2026), but per-project file caps differ: Free 5, Plus and Go 25, Pro and Team 40. A near-full file set adds context that dilutes instructions.

Info to collect

Full instructions text (screenshot) plus character count (watch for the 1,500-char ceiling).
Full prompt text plus the reply screenshot showing the violation.
Which rule broke, and at which turn the drift started.
Current model (Instant / Thinking / Pro) and whether Custom Instructions and Memory are enabled.

Shortest fix path

Ordered by ROI. The first two solve roughly 70% of cases.

Step 1: Put critical rules in the first lines of the instructions

Open the project, click the three-dot menu in the top-right, choose Project settings, and lead the Instructions field with your 2-3 non-negotiable rules:

Critical rules (always follow, never override):
1. Always reply in zh-CN regardless of the user's input language.
2. Maximum 200 words per response.
3. Output format: one paragraph, no headers, no bullet lists.

[More detailed context, examples, and edge cases below...]

The opening lines carry the most weight, so pack every hard rule there. Keep the whole field well under the 1,500-character limit; if it overflows, the rest belongs in a project file, not the instructions.

Step 2: Restate critical rules at the top of every message

The most effective patch for a hard constraint:

[Project rules: reply in zh-CN, max 200 words, one paragraph]

Now answer: <your actual question>

Make the bracketed restate a habit. Each restate effectively promotes the rule to current-message weight — the highest-priority layer — taking adherence from roughly 60% to 95%+. To avoid retyping, set up a text expander (macOS Espanso or aText, Windows AutoHotkey).

Step 3: Rewrite every negative as a positive

Go rule by rule:

Bad -> Good:
Don't ask follow-ups  -> Give one final paragraph, no questions
Don't be too long     -> Output at most 200 words
Don't use bullets     -> Output continuous prose
Don't use jargon      -> Use analogies and everyday words

After rewriting, re-read each line. If “don’t” still appears, rewrite again.

Step 4: Pair every format / length rule with an example

Output format example (always follow this exact structure):

---
[One ~200-word paragraph answer here]

References:
- Source 1: one-line description
- Source 2: one-line description
---

A worked example outperforms a written rule by a wide margin, because the model copies a shape instead of interpreting a constraint.

Step 5: Re-state every 8-10 turns in long chats

Reminder: per the project rules, reply in zh-CN, at most 200 words,
no bullet lists. Now:

<your actual question>

Keep a mental timer — past 10 turns, proactively restate before the instructions get diluted out of attention.

Step 6: Switch to a Thinking or Pro model for structured rules

If a rule must hold reliably, switch the model picker from GPT-5.5 Instant to GPT-5.5 Thinking (or Pro for the hardest cases). Reasoning models track multi-rule instructions far more reliably than the default Instant model. Note that Pro mode disables Memory and Apps while it reasons, which conveniently removes the Cause 7 conflict for that run. The model picker is available on Go, Plus, Pro, and Business.

Step 7: Resolve Memory conflicts

Because Project instructions already override global Custom Instructions, focus on Memory:

Open Settings → Personalization → Memory and delete saved memories that conflict with this project.
Or toggle Memory off for the test (turn off Reference saved memories and Reference chat history independently).
Cleanest of all: when you create the project, enable project-only memory. Then global saved memories are not referenced inside the project at all, so there is nothing to conflict with.

Step 8: For public, fixed-version use, build a Custom GPT

Projects now generally follow instructions better than Custom GPTs and have more features (Memory, Deep Research, agent mode, higher file caps), so do not switch on adherence grounds alone. The real reason to build a Custom GPT is when you need a shareable, fixed-version URL — a published assistant where every new chat starts identically from the same instructions, for customer-facing or compliance use. For private work, stay in Projects.

How to confirm it’s fixed

Open a fresh chat, run the Step 2 restate template across 10 different questions. Adherence above 90% = genuinely fixed, not luck.
Have a colleague duplicate the (shared) project and run the same prompt. Matching adherence = it is the configuration, not just your session.
Push a chat to 20 turns and check adherence every 5 turns. Holding = it resists dilution.

If it’s still broken

Cut to the minimum: keep only one critical rule (e.g. “reply in zh-CN”) and retest, to see whether your rules were fighting each other.
Switch model: move from GPT-5.5 Instant to Thinking or Pro — reasoning models honor structured instructions more reliably.
For the highest-constraint needs, drive the model through the API instead, where the system message priority is explicit and your file context is fully in your control.
Package the project’s settings, instructions text, prompt, and violation screenshot, and file a ticket at help.openai.com.

Prevention

Mental model: the first lines of the instructions field are hard constraints; everything after is soft guidance. Keep the field under 1,500 characters.
Pair every rule with an example of the desired output — never text-only.
Rewrite every negative as a positive; after writing, search the field for “don’t / never” and clean up what is left.
For projects you reuse, run a 10-question “adherence regression test” before relying on them, and re-run it periodically.
For sensitive work, turn on project-only memory at creation so global Memory can never bleed in.

FAQ

Are Project instructions different from Custom Instructions? Yes. Custom Instructions (Settings → Personalization) apply globally to every chat. Project instructions live inside one project and, within that project, override the global Custom Instructions. Use Custom Instructions for stable, always-true preferences and Project instructions for the rules of one body of work.

Why does ChatGPT follow my rules at first but forget them later? Recency weighting. Your instructions sit at the top of context, and as the chat grows your messages and the model’s replies pile up after them, so by message 30 the instructions get far less attention. Restate the key rules every 8-10 turns, or start a fresh chat in the same project.

Is there a length limit on the instructions field? Yes — about 1,500 characters per field as of June 2026. Overstuffing forces compression that the model misreads, so keep hard rules in the opening lines and push detailed context into a project file instead.

Will switching models help instruction following? Often. GPT-5.5 Instant (the default) is the weakest at multi-rule adherence; GPT-5.5 Thinking and Pro track structured instructions more reliably. Pro also disables Memory and Apps mid-reasoning, which removes one source of conflict.

Should I use a Custom GPT instead for guaranteed adherence? Not for adherence alone — Projects now follow instructions as well or better and have more features. Build a Custom GPT only when you need a shareable, fixed-version assistant (a public URL where every chat starts identically).

Tags: #ChatGPT #ChatGPT files #Troubleshooting #Debug #Projects #Instructions