One developer toggled off telemetry in Claude Code, expecting nothing more than "send less data to the server." What they didn't expect was that the carefully written AGENTS.md sitting in their project root — the file meant to feed project-level instructions into the model — was being completely ignored. A blog post on szypowi.cz dug into the code and found something awkward: the path that reads AGENTS.md was nested inside the telemetry-enabled branch.
Anthropic has already shipped a fix. The incident itself is small, but it surfaces an engineering-organization problem that's becoming harder to ignore.
The Incident: AGENTS.md Wasn't "Configuration" — It Was a Side Effect of the Telemetry Flag
The starting point was ordinary. Someone dropped an AGENTS.md into their Claude Code project, expecting the model to pick up project conventions, code style, commit habits — the usual project-level guidance. No errors, nothing strange in the logs. The model just behaved as if the file didn't exist.
Turn telemetry off, then back on. The file started working.
Szymon (the blog author) thought that was odd enough to warrant reading the source. What he found: the code path that loads AGENTS.md was indeed coupled to the telemetry switch. Telemetry off → the file-loading code never runs.
This isn't the kind of "edge case missed" or "false trigger" you typically see in a bug report. It's a design decision — or at least a deeply buried side effect — visible at the code-organization level.
Anthropic patched it after the feedback came in. But a patch isn't an explanation — there's no public statement on why the code was written that way originally, or which other features might be silenced when telemetry is disabled. More on that later. First, why did this thread pull 374 points and 211 comments on HN?
HN thread: https://news.ycombinator.com/item?id=49814947
Why This Bug Matters: Telemetry and Functionality Were Wired Together
Zoom out from "the file didn't get read" to "telemetry and core functionality run through the same code path."
Developers disable telemetry for the usual reason: privacy. They don't want code snippets, prompts, or uploaded files leaving the machine. That's a reasonable choice — in enterprise settings, often a required one. The cost: turning it off also disabled a basic, seemingly unrelated capability — loading project-level instructions.
The deeper problem: nothing in the product docs tells you this is happening.
Open the Claude Code settings panel and you'll see telemetry as a toggle. Most people read that as a "data collection switch." It does not say "also disables project-config file reading." This kind of hidden coupling is a trust killer — not because Anthropic acted in bad faith, but because developers have no way to know the full chain of consequences before flipping the switch.
There are almost certainly more couplings like this one. More on that below.
What AGENTS.md Is, and How It Compares to .cursorrules
Quick background on the file. AGENTS.md is a convention that took off around mid-2025: drop it in the project root, and any AI agent or AI coding tool that supports it will read it as project-level instructions. Format mirrors README.md, but the content is meant for the model, not humans.
A typical file looks like this:
# AGENTS.md
## Build & Test
- pnpm install
- pnpm test
## Style
- 2-space indent
- No `any` in TypeScript
- Prefer composition over inheritance
## Don't
- Don't modify files under `migrations/`
- Don't commit `.env`
Similar mechanisms exist in other tools, just under different filenames:
- Cursor:
.cursorrules, in the project root - Aider:
CONVENTIONS.md, loaded explicitly via the--readflag - Cline / Continue: injected via a custom system prompt
- Claude Code:
AGENTS.mdorCLAUDE.md(same file, both work)
The key difference is the loading path. Cursor and Cline handle this at the config-resolution layer — open a project, tool initializes, the project file gets read, and none of that has anything to do with telemetry or upload toggles. Aider is even more direct: you pass the file path explicitly, so there's nothing to couple it to.
Claude Code took a different path — reading behavior was hanging off an unrelated switch. That kind of organization isn't unusual in fast-moving products. The problem is that it landed on the core config-loading chain.
Community Reaction: What the 374-Point Thread Was Actually Arguing About
The HN thread drew three rough camps.
Camp one: Anthropic's internal code organization is the problem. The argument: reading AGENTS.md should be a 100% deterministic operation (no side effects, no randomness), and bolting it onto a mutable, user-controllable switch like telemetry is bad architecture. Most of the people in this camp came from large-engineering backgrounds and had seen the same anti-pattern cause worse production incidents.
Camp two: the natural flaws of open-source-adjacent / CLI tools. This camp argued that the visible parts of Claude Code's codebase reflect a familiar pattern in fast-moving products — features shipped faster than internal refactoring could keep up. One anonymous commenter put it bluntly: "This isn't a bug, it's a velocity tax." Move fast, bury things deep.
Camp three: a deeper question — what do AI tool toggles actually control? This was the most interesting thread. They framed the incident in a larger context: LLM-based tools generally expose a "telemetry / data collection" toggle, but users have no visibility into how many behavioral features are wired to it. A given toggle might mean "data collection," or it might mean "feature enable," or "model version selection," or even "prompt caching strategy." That invisibility is the actual problem.
The third camp resonates most. The first two argue about why this specific bug happened; the third asks how to systematically prevent this whole class of bug.
Practical Impact for Developers: Should You Turn Telemetry On or Off Right Now?
Short-term advice, if you're already using Claude Code: upgrade to the latest version. The fix is in, though neither szypowi.cz nor the HN thread pinpointed the exact release number. Check the Claude Code changelog or GitHub commits to confirm.
How to verify the fix landed: turn telemetry off, launch Claude Code, drop a test AGENTS.md in the project root with some unique instruction (something like print("AGENTS_MD_TEST_OK")), then ask Claude to follow that instruction. If it actually runs it, the loading path is independent of telemetry.
Whether to leave telemetry on or off itself: depends on your situation.
- On: you get product improvements, earlier access to new features, and your usage data feeds back to Anthropic.
- Off: you don't want code snippets or prompts uploaded, your employer has compliance constraints, or you want more predictable behavior.
My leaning: AI coding tools are increasingly "collaborators" rather than "tools," and in that world the default should be data collection off but core functionality on — and vendors like Anthropic need to make an explicit commitment that the side effects of every toggle must be exhaustively documented. Users shouldn't have to read the source to find out.
Places worth checking (exact names depend on the official docs):
- The telemetry-related config in
~/.claude/settings.json - Telemetry-related CLI flags
- The telemetry status line in startup logs
Editorial: The Deeper Issue
This isn't just "Anthropic fumbled again." It points at a concrete engineering question: should AI agent tools decouple their feature toggles from their data toggles?
Cursor, Aider, Cline, Claude Code — all of them ship fast. New features, new models, new permissions, every week. When a new feature gets bolted onto the existing "read config / initialize environment / load policy" chain, every decision about where it attaches, what state it depends on, and what side effects it carries directly shapes developer workflows. Claude Code's "config reads from the telemetry branch" is not an isolated incident — it's an early signal of a code-organization pattern common to this whole category of tools.
My read: over the next 12 to 18 months, incidents of this "hidden coupling" type will grow, not shrink. The reason is straightforward — agent-tool product shapes are still in violent flux, and the definition of "what's a core feature" is itself moving. What counts as core today may be experimental tomorrow; what's experimental today may become default behavior tomorrow. In that churn, the mapping between "which toggle controls which feature" turns into an unreadable mess.
This is a different kind of tool bug than the industry has dealt with before. Traditional tool bugs show up as functional misbehavior — wrong output, broken calculations. This one sits at the meta level: the very definition of "what counts as a bug" diverges between user and vendor. The user assumes AGENTS.md must be loaded. The code says otherwise.
Short-term, audits carry the load: user communities and third-party security researchers will keep digging through code, filing issues, and surfacing problems — that's the upside of quasi-open tools. Long-term, the industry needs real transparency. What I'd like to see: every toggle carries an explicit "scope of impact" declaration with side effects fully enumerated in the docs; config-loading chains kept architecturally separate from data-collection chains as a hard engineering requirement; and third-party audits becoming standard for agent tools, the way SOC 2 and GDPR compliance audits are now.
Will it get fully solved? I have doubts. LLM-based tools have always been less observable than traditional software — the model itself is a black box, and the products wrapping it are increasingly opaque too. Claude Code patched this one. A patch doesn't make the class of problem go away.