When your agent ignores instructions.
You wrote the rules file. The agent read it — its own output says so. Then it did something else. This is reported on agent after agent, and the vendors themselves say why: instructions are advisory. Four responses, compared.
The same report, on every tracker
This failure is not one vendor’s bug, and the evidence is public. All fetched and verified 2026-08-17:
Cline #7414 — “Clinerules are completely ignored.” The triage response links four more issues with the same symptom and calls it “a known and frequently reported issue.” Aider #2384 — the user watches the conventions file load in Aider’s own output, “but it doesn’t follow it.” Codex #6502 — “Codex repeatedly ignores instructions from AGENTS.md”: TDD mandated, tests failing, and the agent proposes committing anyway, through repeated corrections. Kilo Code #13016 — an agent edits files in a mode that forbids editing.
The honest negatives, since a fair map shows them: Continue’s tracker is a genuine near-zero — its rules issues are loader bugs, not read-then-disobey reports. And Devin and Amp publish no issue tracker at all, so there is no public record either way.
What the vendors themselves say
Cline’s official-repo triage response on #7414 (an automated response, not a named engineer, quoted verbatim): “This is not a Cline bug in the traditional sense — it’s an inherent limitation of current LLMs… The rules are being sent to the model, but models are not deterministic instruction-followers.” And later: “ultimately the model decides what to do.”
Anthropic’s Claude Code best-practices docs say the same thing from the vendor’s side, verbatim: “Bloated CLAUDE.md files cause Claude to ignore your actual instructions!”, and the line that names the whole axis: “Unlike CLAUDE.md instructions which are advisory, hooks are deterministic and guarantee the action happens.”
A Kilo Code contributor on #13016: “Ask mode is a suggestion to the models, not a ‘restriction’. Utilize permissions or sandboxes to ‘restrict’ agents. Free models or small models often ignore these suggestions, smarter models respect it.” That last sentence is the fair qualifier — a better model follows the suggestion more often. It is still a suggestion. When even the mode switch is advice, the distinction that matters is not which agent you run — it is advisory versus enforced.
Four responses, compared
| Response | What it is | What holds |
|---|---|---|
| Stronger wording | “IMPORTANT”, “YOU MUST”, repetition — the vendors recommend trying it | Better odds, same advisory channel. The reports above are mostly from users who already wrote forcefully. |
| Shorter rules files | Prune until every line earns its place | Real improvement — long files bury rules. Still advice the model weighs, especially late in a session. |
| Modes & permissions | Read-only modes, tool allowlists, sandboxes | Binds tools, when enforced rather than suggested. Says nothing about order, review, or completion. |
| Runtime process gates | Hooks and protocol steps that block, deterministically | The step happens or the tool call fails. Costs setup; binds the agent, not the operator. |
Where the engine sits
team.management takes the fourth response and applies it to the whole working process. It runs as a Claude Code plugin today, and can bring other providers in as independent reviewers during review steps. Your process becomes a protocol — discuss, then implement, then review — and the engine enforces the current step: in discussion mode, implementation tools are blocked at the hook level, not requested nicely in a rules file. The agent does not weigh the rule; the tool call fails. The task protocol shows the whole sequence.
Said plainly, because this page is about instructions that overpromise: a gate binds the agent, not the person running it — you can change your own config at any time, and enforcement inside the run is not portable proof of anything. What it ends is the quiet drift, where the rules file said one thing and the session did another.
FAQ
Why does my coding agent ignore CLAUDE.md / AGENTS.md rules?
Because instruction files are context, not constraints. The rules are loaded into the prompt and the model weighs them against everything else there — and in long sessions they lose. Cline’s own issue triage puts it plainly: the rules are being sent to the model, but models are not deterministic instruction-followers. Anthropic’s Claude Code docs say the same from the other side: CLAUDE.md instructions are advisory, and bloated files cause the agent to ignore them.
Does writing IMPORTANT or YOU MUST in the rules file help?
Sometimes, and the vendors themselves recommend trying it — Anthropic’s docs suggest adding emphasis like “IMPORTANT” or “YOU MUST” to improve adherence. But it improves the odds inside the same advisory channel; it does not change the channel. The failure reports quoted on this page mostly come from users who had already written their rules as forcefully as they could.
What actually stops an agent from skipping steps?
Something outside the model’s discretion. Deterministic hooks that run on every action, mode gates that block tools rather than suggest restraint, and protocol engines that refuse to advance until a step’s checks pass. Anthropic’s docs draw the line themselves: instructions are advisory, hooks are deterministic. The trade-off is setup effort — and the honest limit is that any gate binds the agent, not the person who owns the config.
Facts and figures on this page are as of August 2026, verified against the sources linked inline. If you’re reading this much later — check the sources.
Related comparisons
The other way agents go off-script, the full map, and the setups these reports come from.