ChatGPT · instruction following
Why does ChatGPT keep ignoring my instructions?
A practical way to tell whether ChatGPT ignored a clear instruction, missed an implicit constraint, followed a conflicting instruction, or lost the task in too much context.
Short answer
What is probably happening
ChatGPT can appear to ignore instructions for four different reasons: the requirement was implied rather than stated, two instructions conflicted, the important rule was buried in a long context, or the model simply failed to follow a clear rule. Those are different diagnoses. The useful question is not “How do I make the prompt longer?” but “Was the failed requirement actually present, unambiguous, and compatible with the rest of the request?”
Possible causes
The same symptom can have different verdicts
Start with the exact instruction and the exact output. Do not debug from memory. A rule that feels obvious to you may never have been visible to the model; a rule that is visible and specific may still have been violated.
The rule was implicit
You asked for a direction—cleaner, better, more professional—but did not name what had to stay unchanged or what counted as success.
The request contained a conflict
One part asked for completeness while another demanded extreme brevity, or one message protected the structure while a later message invited a redesign.
The important rule was buried
A critical constraint appeared once inside a long conversation, far from the final task. The model may have prioritized the most recent or dominant direction.
The model ignored a clear boundary
The instruction named the exact element, the prohibited change, and the required output format, yet the output crossed that boundary anyway.
How to distinguish them
Check the evidence in this order
- 01
Underline the exact sentence that covers the failed requirement. If there is none, the instruction is incomplete.
- 02
Check whether another sentence grants broad freedom that conflicts with the rule you care about.
- 03
Move the three most important constraints into the final message and make them testable.
- 04
Retry once without changing the target. If the same explicit rule is violated again, treat it as a model or workflow problem.
WWW-style diagnosis
Example caseoops, that’s on us.
- Wanted
- A small change to one part of a working file.
- Asked
- Change only parseDate(). Do not touch any other function. Return a minimal diff.
- Result
- A full replacement file with unrelated helpers removed.
- Why
- This is not a vague-request case. The scope, protected content, and output format were explicit. The model crossed the exact boundary it was given.
What to do next
Fix the diagnosed cause
Reduce the instruction to a contract
State the outcome, preservation constraints, allowed changes, prohibited changes, and output format. More context is useful only when it resolves a decision.
Ask for a preflight
Before generation, have the model list what it will change and what it will preserve. Correct the plan before paying the cost of a full output.
Inspect the failure, not the apology
A model saying “you’re right” does not establish the cause. Compare the retry against the same explicit requirements.
When the instruction needs repair
A boundary-first template
Goal: [the result you want]. Preserve: [things that must not change]. You may change only: [allowed scope]. Do not: [specific prohibited changes]. Success means: [observable checks]. Before answering, restate the preservation constraints in one line; then return [required format].
This template is relevant only when the evidence points to missing or conflicting boundaries. It cannot excuse a model that violated a clear instruction.
Questions
What people usually ask next
Does putting instructions in all caps make ChatGPT follow them?+
Not reliably. Position, specificity, consistency, and a checkable output contract matter more than capitalization.
Should I repeat the same instruction many times?+
Repeat a critical rule once in a compact final checklist if needed. Repetition cannot repair a contradiction and may make the request harder to parse.
When is it definitely the model’s fault?+
When a reasonable, explicit, compatible instruction directly covers the failed behavior and the output still violates it.