You opened a Project, clicked Project instructions (the gear / pencil near the project name), pasted a new ruleset (“reply in English only,” “never propose Python”), hit save — and ChatGPT still answers in Chinese with Python code.
Fastest fix (works ~70% of the time): open a brand-new chat inside the same Project and re-test. Existing chat threads freeze their context at the moment they started, so an instruction edit never retroactively applies to a conversation already in progress. If a fresh chat obeys the rule, you’re done for new work.
If a fresh chat also ignores the rule, the new rule is losing to a higher-priority layer. Project Instructions are not magic; as of June 2026 they sit in a stack with global Custom Instructions, Saved Memories, the project’s own memory / referenced chats, the current chat’s running context, and Project Files. When one of those contradicts your new rule, the rule can lose silently — and the instructions field also has a soft character cap that truncates the back half without warning.
How the instruction stack resolves (June 2026)
ChatGPT’s documented layering is: a Project’s instructions apply only inside that project, and they override your global Custom Instructions there. That’s the intended behavior — so “Custom Instructions are beating my Project rule” is not the design, and when it happens it’s usually because the Project rule was truncated, never saved, or contradicted by Memory rather than by Custom Instructions. The layers that genuinely fight a fresh, well-saved rule are, in order of hit rate:
| Layer | Scope | Can it override a new Project rule? |
|---|---|---|
| Existing chat’s running context | One open conversation | Yes — chats freeze context; edits don’t apply retroactively |
| Saved Memories | Account-wide | Yes — a stored “always use Python” fact silently re-injects the old behavior |
| Project memory / referenced project chats | One project | Yes — past chats in the project pull in the old pattern |
| Project Files | One project | Yes — a Python-heavy corpus out-votes a one-line text rule |
| Silent truncation | The instructions field | Yes — anything past the cap is invisible to the model |
| Global Custom Instructions | Account-wide | Rarely — Project rules are supposed to win; treat a conflict as a symptom of one of the above |
Common causes
Ordered by hit rate, highest first.
1. Existing chat threads still carry pre-update behavior
The most common cause by far. The model in the chat you’re testing in keeps mirroring whatever it did before you edited the instructions, because that chat’s running context is “winning” against the freshly saved rule. Edits apply to new chats only.
How to spot it: open a NEW chat in the same Project, run the same prompt. If the new rule is now followed, the old chat’s history was the override.
2. A Saved Memory contradicts the new rule
This is the cause most people miss in 2026. ChatGPT’s Saved Memories (Settings → Personalization → Memory → “Manage memories”) are account-wide facts the model chose to remember, e.g. “User prefers Python for scripting” or “User writes in Chinese.” These re-inject the old behavior even after you change Project instructions, because Memory is applied alongside the project.
How to spot it: open Settings → Personalization → Memory → Manage memories and read the list. If a stored fact restates the thing you’re trying to forbid, that’s your override.
3. Project memory / referenced project chats pull in the old pattern
For Plus and Pro accounts, a Project can reference previous chats within that project to stay “focused.” Helpful for continuity, but it also means the project’s own history can keep reasserting the pre-update behavior — separate from the single chat you happen to have open.
How to spot it: start a new chat in the project and immediately ask Ignore all prior conversations in this project. Follow only the current Project instructions. State rule 1 verbatim. If behavior snaps to the new rule, project memory was the drag.
4. Instructions silently truncated at the char limit
The Project instructions field accepts up to several thousand characters as of June 2026 (OpenAI does not publish an exact number, and it’s deweighted as the chat grows long). If you pasted a very large block, the back half can be dropped or ignored without warning, so any rule past the cut-off is effectively invisible.
How to spot it: ask in the Project Repeat your Project instructions verbatim, including any line about Python. If it cannot quote the line, it was truncated or deweighted — shorten the instructions.
5. The new rule contradicts the Project Files
If a file in Project Files is full of Python, the model treats that as strong context evidence and may keep producing Python despite a one-line rule against it. A large corpus out-votes a short instruction.
How to spot it: remove the Python-heavy file temporarily and rerun. Rule sticks = the file was out-voting it.
6. You edited the wrong Project
You have five Projects with similar names. You edited “Q2 Campaign” but you’re chatting in “Q2 Campaign (copy)” — the instructions update never landed where you’re testing.
How to spot it: in the chat, click the Project name in the header / sidebar and confirm it matches the one you just edited.
7. The save did not commit (network blip, modal closed early)
Save can silently fail if you closed the editor too fast or hit save while offline. The instructions field reopens with the old content.
How to spot it: reopen Project instructions. If the new text isn’t there, the save never happened.
Before you start
- Confirm the save by reopening the Project instructions editor and eyeballing the actual stored text.
- Note your Project name precisely; if duplicates exist, rename one to disambiguate.
- Decide whether your rule is a hard constraint (model must obey) or a soft preference — wording matters.
Info to collect
- Full instructions text (screenshot the editor after save).
- Custom Instructions text (Settings → Personalization → Custom Instructions).
- Saved Memories list (Settings → Personalization → Memory → Manage memories).
- List of files in Project Files.
- The exact prompt + reply where the rule was ignored.
- Whether it fails in a new chat or only in the existing chat.
- Subscription tier + workspace (Personal / Team / Enterprise).
Shortest fix path
Ordered by ROI. Steps 1 and 2 fix the majority.
Step 1: Open a fresh chat in the same Project
Existing chats keep their pre-update context. The fastest sanity check:
Project → New chat → first prompt:
"State the first rule from this Project's instructions verbatim,
then answer: <your test question>"If the new rule shows up, you’re done for fresh work. Old chats stay affected — start them over.
Step 2: Clear any Saved Memory that fights the rule
Settings → Personalization → Memory → Manage memories
→ Find any entry that restates the old behavior
(e.g. "prefers Python", "writes in Chinese")
→ Delete that entry (trash icon)
→ Start a NEW chat in the Project and re-testIf you don’t need Memory at all for this work, you can toggle Reference saved memories off here, or set the Project to project-only memory when you create a new one (existing projects stay on the default setting). This is the step most 2026 guides skip.
Step 3: Rewrite instructions as short hard constraints, not stories
Most “ignored instructions” are actually “vague instructions.” Convert:
Bad (paragraph form):
"This project is about our enterprise SaaS dashboard. The team
historically prefers TypeScript and we sometimes use Python for
scripts but generally try to standardize on TypeScript when
possible because of long-term maintenance."
Good (hard constraint form):
Constraints (always follow):
- Output language: English only
- Tech stack: TypeScript only. Never propose Python.
- Tone: concise, no apologies
- Always cite specific file names when referencing Project FilesBullets, imperatives, and “always / never” are obeyed more reliably than narrative — and they cost fewer characters, which keeps you under the cap.
Step 4: Verify the instructions weren’t truncated or de-weighted
In a Project chat, ask:
"Print your Project instructions verbatim from the first line
to the last. Do not summarize."Compare the output to what you saved. Anything missing = truncated or deweighted. Remove background prose and keep only rules so the whole ruleset fits and stays high-weight.
Step 5: Reduce Project Files that fight the rule
If you said “TypeScript only” but the Files panel has eight Python files, the corpus out-votes the rule. Either:
- Remove the Python files, or
- Add to instructions:
Files in this Project may contain Python for historical reasons. Never suggest Python in replies.
Step 6: Re-save instructions explicitly
If you suspect the save didn’t commit:
Project → Project instructions
→ Select all → cut → paste back → Save
→ Close editor → wait ~5s → reopen editor
→ Confirm the text is present
→ Then test in a new chatStep 7: For repeated ignores, add an enforcement preamble
Some rules need extra weight. Prepend to the instructions:
ENFORCEMENT: Before every reply, internally check whether any
rule below would be violated. If yes, revise the reply before
sending. Rules:
- <rule 1>
- <rule 2>A self-check preamble materially improves rule adherence, especially on the GPT-5.5 “Thinking” mode.
How to confirm the fix
- New chat in the Project → first prompt asks for the new rule verbatim → exact quote back.
- Run three prompts that previously violated the rule — all three now comply.
- Have a teammate open the Project in their own account and rerun — same compliance = the rule lives in the Project, not just in your local Memory or chat state.
Common pitfalls
- Editing instructions while leaving an old chat open and expecting it to retroactively comply — chats freeze their context.
- Forgetting that a Saved Memory (“prefers Python”) quietly overrides a new Project rule.
- Using soft language (“prefer,” “generally”) and expecting hard enforcement.
- Pasting several thousand characters and missing the silent truncation / de-weighting.
- Saving from the duplicate Project (“Q2 Campaign (copy)”) instead of the live one.
- Stacking 15 rules and burying the most important one at the bottom — order matters; put critical rules first.
FAQ
Q: Do Project instructions override my global Custom Instructions? A: Yes. As of June 2026 OpenAI’s documented behavior is that a Project’s instructions apply only inside that project and take precedence over global Custom Instructions there. So if a Project rule is being ignored, suspect a Saved Memory, project memory, truncation, or a failed save before you blame Custom Instructions.
Q: What is the actual character limit for Project instructions? A: OpenAI doesn’t publish a hard number; the field accepts several thousand characters, but the model de-weights long instructions as the chat grows and may drop the tail of an oversized block. The reliable test is to ask the model to quote its instructions back and compare to what you saved.
Q: Why does ChatGPT keep doing the old thing even in a brand-new chat? A: A new chat clears the chat context, but Saved Memories and (on Plus/Pro) project memory still apply. Check Settings → Personalization → Memory → Manage memories and delete any entry that restates the old behavior.
Q: Will deleting and recreating the Project preserve files? A: No. Files are bound to the Project. Download them first, then recreate.
Q: How quickly does an instruction change take effect? A: Immediately for new chats. Existing chats keep prior behavior until you start a new chat or explicitly tell the model to discard the old context.
Q: Can I version-control my instructions?
A: Not built-in. Keep a local instructions.md per Project and paste-and-replace when iterating.
Related reading
- ChatGPT Project context bleeds from old chats
- ChatGPT project instructions ignored
- ChatGPT project files not referenced
- ChatGPT Projects
- ChatGPT Projects advanced workflow
Tags: #ChatGPT #Troubleshooting #chatgpt-projects #project-instructions