Your Coding Agent Should Show Which Rules It Loaded

Key takeaways

• A claimed link between Claude Code’s telemetry settings and AGENTS.md loading remains unverified, as does the reported fix.
• Usage reporting and project instruction loading serve separate purposes.
• An assistant breaking a rule does not prove it failed to load that rule.
• Visible instruction-loading records would help developers diagnose unexpected behavior.

Turning off usage reporting should be a boring decision. You expect less data to leave your machine, with your project’s working rules still intact. A claim about Claude Code suggests those expectations may have collided—and highlights how hard it can be to tell what a coding assistant actually loaded.

A privacy setting should have a predictable scope

The allegation is specific: disabling telemetry in Claude Code prevented AGENTS.md from loading, and the problem was subsequently fixed. The conditions that supposedly triggered it and the version that supposedly resolved it remain unclear. Both the bug and the reported fix should be treated as unverified.

Even so, the underlying distinction matters.

Telemetry collects and transmits operational information, such as usage data or errors. What it includes depends on the product and its settings. Users generally disable it to reduce information sent outside their environment.

AGENTS.md serves a different purpose. It can hold instructions for an AI coding tool: run tests after making changes, preserve the existing code style, or follow other project conventions.

The filename alone guarantees nothing. A tool must support it or have some configured way to read it. That might mean loading the file directly, following a reference from another instruction file, or using an integration.

Where that loading is configured, disabling usage reporting should not silently disable it. If the alleged behavior occurred, the setting changed more than the user reasonably expected.

Skipped tests are a symptom, not a diagnosis

Suppose your project instructions say to run tests after every change. The assistant edits the code and declares the job finished without running them.

Did it miss the instruction file? Possibly. But it might have loaded the file, encountered a conflicting instruction, or lost track of the requirement during the task.

Instruction loading and instruction compliance are separate questions. The same visible failure can come from either.

That distinction changes how you investigate. First, establish how the tool is supposed to receive the project’s instructions. Then check whether it actually received them. Only after that can you sensibly examine why it failed to follow them.

The telemetry claim needs the same discipline. An assistant ignoring a rule while telemetry is disabled does not establish causation. A meaningful comparison would keep the project and execution conditions the same, change only the telemetry setting, and check whether file loading itself changes.

Otherwise, you risk adjusting a privacy preference to solve an instruction-following problem it never caused.

A credible fix needs an observable result

“Fixed” is useful only when it tells users something concrete. Which conditions caused the failure? Which version corrected it? What behavior should users now be able to observe?

For instruction-loading problems, the necessary visibility is straightforward. A tool should show which instruction files it loaded in the current session. If a file failed to load, it should explain why. If several instruction sources apply, users should be able to inspect their order and precedence.

Asking the assistant whether it read the rules is a weak substitute. A loading record produced by the tool provides clearer evidence than the assistant’s own assurance.

Successful loading still does not guarantee perfect compliance. It does, however, narrow the investigation: a missing file and an ignored instruction require different fixes.

Whatever becomes of this particular allegation, coding assistants deserve scrutiny beyond the quality of their generated code. Developers should also be able to inspect how their settings took effect. A tool that accepts your project’s rules should give you a clear way to check whether those rules made it into the session.