Until recently, the CLAUDE.md of one of my own projects had a line that said "Next up: 1. Connect Sanity". That job had been done for weeks. The site was already publishing from Sanity. And yet every time I opened a session, the AI agent I code with read that line first, before anything I typed, and took it as a fair description of where the project stood.

It was a small lie, and I've since deleted it. Google just put a price on lies like it.

On 6 November 2026, two Google engineers published a post called Agent Distraction. They measured what happens when a coding agent bumps into an old note in the code, a TODO pointing at a bug that was closed years ago, and decides to go deal with it. The answer: a session with an unasked-for detour takes 70% more steps, burns 77% more tokens and makes you wait more than twice as long.

Google tested its own agents, but the mechanism is the same in any agent, Claude Code included, and it's the most practical thing I've read about AI agents this month, because the fix isn't a smarter model. It's keeping the files your agent reads true. That's the part of AI automation nobody puts on a slide, and it's most of the job when I set up AI automation and agents for a team.

Google measured what stale notes cost a coding agent

Agent distraction is Google's name for a coding agent acting on stale or irrelevant notes it finds in the files it reads, instead of on what you asked. Google measured it on its own internal agents, across thousands of engineers and hundreds of millions of agent steps, and found the detours are rare, unprompted and expensive.

Top of Google's Agent Distraction post, dated 6 November 2026, by Sam Saccone and Madhuri Garikapati
Source: Sam Saccone and Madhuri Garikapati, Google Developers Blog

The post comes from Sam Saccone (Senior Staff Software Engineer) and Madhuri Garikapati (Senior Staff Data Scientist), and it's short. The headline numbers:

  • 13% of file-reading sessions ran into an inline TODO(bug/...) or FIXME(bug/...) reference.
  • Agents ignored those notes 94% of the time. In the other 6%, they went after the bug.
  • 83% of those actions were unprompted. Nobody asked.
  • Each unprompted detour cost 70% more steps, 77% more tokens and 105% more wait time per session.

I want to be clear about what this is. Google released a study of its own agents and a cleanup job for its own codebase. It didn't build anything for Claude. The finding still travels well, because every coding agent on the market works the same way at this layer.

What I like about it is the framing. Google's line is that what's easy for humans to skim past in code, agents see as a call to action. That's the whole article in one sentence (they could have stopped there).

How a coding agent loads context, and why old files steer it

A coding agent reads before it writes. In Claude Code, the CLAUDE.md file loads the moment a session opens, then the agent opens specs, plans, memory and the files near your task to work out a plan. All of it lands in the same context window, and the agent has no built-in sense of which parts went stale.

Diagram: CLAUDE.md, specs, memory notes and stale items like an old TODO and a done Next up line all flow into one context window, so a coding agent weighs stale and current notes the same (simplified)
Source: growthvibes.ai

The loop goes like this. You ask for a change. The agent searches the repo, opens the files that look related, reads your project instructions, maybe a spec or two, and builds a plan from everything it found. If you want the longer version of that loop, I broke down how an agent loop works in a separate guide.

The problem is in the word everything. A person opening a five-year-old file sees // TODO(bug/48213): fix flaky test and their eyes slide right past it. Context tells them it's furniture. An agent has no such instinct. It sees an open instruction, in a file it was told to read, with a ticket number that looks official. Of course it's interested.

Google's point is that this used to be harmless. Obsolete specs and long-resolved bugs used to sit in forgotten corners where nobody looked. Now an agent looks everywhere, every session. The forgotten corners got a reader.

I've seen the human version of this plenty. At one of the SaaS companies I worked with, a new hire spent most of their first week implementing a feature from a product doc that had been quietly killed two quarters earlier. Nobody had marked the doc as dead because everyone "knew". The new hire didn't know. Neither does your agent. An agent is a new hire who starts every single morning.

And it gets worse as agents get more capable. Google says it directly: as agents get more tools and skills, the room for side quests grows with them. More reach means more ways to wander. A better model doesn't fix that, it just wanders faster.

How Google measured it with TODO(bug/...) comments

Google needed a signal it could check automatically across millions of sessions, so it used TODO(bug/...) comments. Each one points at a bug ticket, and the ticket records whether the bug is fixed, obsolete or still open. Compare the ticket status with the user's prompt and you can sort real work from wasted detours at scale.

This is the clever bit, and it's why I trust the numbers more than most "AI agents cost X" claims floating around.

Watching agents by hand doesn't scale. Nobody is going to read millions of session traces (I can barely read my own). So Google picked a proxy that carries its own ground truth:

  • A TODO in the code names a bug ID.
  • The bug tracker says whether that bug is closed (fixed, obsolete, duplicate) or open.
  • The session log says whether the user's prompt asked about that bug at all.

Three facts, all machine-readable. If the agent touched a bug the user never mentioned, it's a detour. If the bug was already closed, it's a detour to nowhere. No human labelling, no vibes, just a join between three tables.

The academic in me has one caveat: TODO comments are a proxy. They're the easiest kind of stale note to measure, not the only kind. Stale CLAUDE.md lines, old plans and memory notes don't come with a ticket that says "closed", so nobody can measure them this cleanly. The real cost of distraction is probably higher than what a TODO-only study can see, not lower. I'd hedge that, but I'd bet on it.

The numbers: how often it happens and what it costs

Agent distraction is uncommon per session but costly when it hits. 13% of sessions saw a TODO bug reference, agents acted on 6% of those encounters, and 83% of those actions were unprompted. When an unprompted detour happened, the session took 70% more steps, 77% more tokens and 105% more wait time.

Every number has its own denominator, which is where most summaries go wrong. Here they are with what each one is a percentage of:

Finding (Google, 6 Nov 2026)NumberPercentage of what
Sessions exposed to a TODO(bug/...) reference13%all file-reading sessions
Encounters the agent ignored94%encounters with a bug reference
Encounters the agent acted on6%encounters with a bug reference
Actions nobody asked for83%those actions
Detours to closed tickets41%unprompted detours (32% fixed, 9% obsolete)
Detours to duplicate or restricted tickets2%unprompted detours
Detours to still-open bugs57%unprompted detours
Open-bug detours that edited code39%open-bug detours (61% lookup only)
Extra steps / tokens / wait time+70% / +77% / +105%per session, vs sessions without a detour
Google's Figure 1: 13% of file-reading sessions read a TODO bug comment; agents ignored 94% and acted on 6%; 83% of those actions were unprompted; of the detours, 57% hit open bugs, 32% already-fixed bugs, 9% obsolete or won't-fix and 2% duplicate or other
Source: Sam Saccone and Madhuri Garikapati, Google Developers Blog

The split of the unprompted detours is the interesting part. Over two-fifths chased closed tickets: 32% already fixed, 9% obsolete or won't-fix, plus 2% duplicates or restricted tickets. Pure waste, the agent investigating a crime that was solved in 2023.

The other 57% went after bugs that were still open. The agent either looked them up (61%) or edited code (39%) for an issue the developer never asked it to touch. That's scope creep with a commit history.

Bar chart: an unprompted bug detour adds 70% more steps, 77% more tokens and 105% more wait time per coding agent session
Source: growthvibes.ai, data from Google Developers Blog

Now the cost view, because this is where it stops being trivia. Google ran a multi-way fixed-effects regression controlling for developer, codebase complexity, task type, model tier, number of files read, prompt length and the step where the bug reference showed up. All results significant at p<0.0001. That's not "we noticed sessions felt slow". That's the detour itself costing you, with the obvious excuses already ruled out.

Do the arithmetic on your own bill. If a normal session costs you a dollar in tokens, a distracted one costs about $1.77. If you wait four minutes for a task, a distracted one takes over eight (an example calculation, not Google's data). And the agent still finishes the job, so you never get a signal that anything went wrong. The cost hides inside "that took a while".

Two examples from the study: the Obsolete Detour and the Eager Agent

Google published two real trajectories. In the Obsolete Detour, an agent working on an unrelated bug found a TODO for a bug fixed in 2023 and went digging into it. In the Eager Agent, an agent "fixed" code nobody asked about until a human pushed back. Google calls both trivial to minor, and both still cost time, tokens and a human.

The Obsolete Detour

Google's Obsolete Detour trajectory: an agent reads SurfaceControlTest.java, finds a TODO for a bug fixed in 2023 and starts investigating it
Source: Sam Saccone and Madhuri Garikapati, Google Developers Blog

The agent is investigating something else and opens SurfaceControlTest.java. There it finds a // TODO(bug/XXX). The bug behind it was fixed in 2023, but the comment never got deleted, so over the next steps the agent goes off to research a problem that stopped existing years ago.

It's the coding equivalent of a colleague forwarding you a 2023 email thread and asking for your thoughts. Nothing breaks. You just lose the afternoon.

The Eager Agent

Step 112 of Google's Eager Agent trajectory: the agent notes a TODO about eligibility checks that are not wired up, then runs code search and internal docs searches for the bug
Source: Sam Saccone and Madhuri Garikapati, Google Developers Blog

This one is more instructive. The agent is investigating a bug, finds a TODO along the way, and decides, unprompted, to fix it. It runs several code searches and internal knowledge searches, then changes the ModelDownloaderV1 code. Later the human challenges the change, and the model admits it was an incorrect increase in scope. The best part is in the admission itself: ModelDownloaderV1 is legacy code that never runs in production, because V2 is fully rolled out. The agent did real work, on dead code, for a bug nobody mentioned.

The model replying "You are completely right" and explaining why modifying ModelDownloaderV1 was the wrong approach: it is legacy code that never runs in production
Source: Sam Saccone and Madhuri Garikapati, Google Developers Blog

Here's the skeptic's question: if the fix was correct, who cares? You do, for three reasons. You might plan to build that part differently. You might want that code left alone for now. And either way, you now have to review work you never asked for before you can ship the work you did ask for.

I've written before that you should judge an agent by how cheaply you can check its output, and this is the reason. A correct but uninvited change still costs review time. An agent that stays in its lane is cheaper to trust than a smarter one that doesn't.

Other things that distract an agent

TODO comments are just the stale notes Google could measure. Stale or bloated CLAUDE.md files, conflicting rules, memory notes that never expire, and long sessions do the same thing to any coding agent. The research behind some of these is solid, and some of the numbers going around aren't sourced at all.

A stale CLAUDE.md

CLAUDE.md is the worst place for a stale line, because it loads every session and the agent treats it as the truth about your project. Anthropic's Claude Code memory docs (checked 18 November 2026) say the project-root CLAUDE.md is re-read from disk after /compact, so a wrong line doesn't fade, it comes back every session.

Here's what the "Next up" section of that website repo looked like before I cleaned it up:

## Next up
1. Connect Sanity (README, "Going live" step 1) and add a Sanity
   webhook to a Cloudflare deploy hook so publishing rebuilds the site.   <- done
2. Replace placeholder content: founder photo, career timeline, ...
3. Search Console: submit the sitemap.

Item 1 had been done for weeks. The site ran on Sanity and every publish triggered a rebuild. But every session still started by telling the agent that connecting Sanity was the next job, a stale instruction loaded and paid for in tokens every single time. It never went off to "connect" anything that I noticed (small mercies). But it was exactly the kind of line that turns into a side quest the day you ask for something Sanity-adjacent, like "fix the publish flow", because the agent has a plan item telling it the integration isn't built yet. So I took it out.

The docs agree with Google, for what it's worth: they tell you to review CLAUDE.md files periodically and remove outdated or conflicting instructions. Nobody does, because a CLAUDE.md doesn't throw errors. It just quietly lies.

A bloated or conflicting CLAUDE.md

This one has real research behind it. An ETH Zurich team (Gloaguen, Mündler, Müller, Raychev and Vechev) tested context files like AGENTS.md and found they don't generally improve task success, while raising inference cost by over 20% on average. First version February 2026, revised 29 September 2026.

Here's the contradiction worth knowing. A common reading is that the 20% is only a problem with files the agent writes for you. The paper says the cost increase holds for both LLM-generated and developer-committed files. Where who wrote it matters is quality: developer-written files beat LLM-generated ones by about 7% on average. So I side with the paper: the problem isn't who wrote the file, it's how much of it the agent has to carry. Human-written helps, short helps more.

Two more details from the paper that I'd act on. Repository overviews weren't helpful (the agent can read your folder tree, it doesn't need a tour). And context files did help for non-standard practices, the weird stuff a model can't guess. That's the test I'd use for every line: would a smart stranger get this wrong without being told? If not, cut it.

The benchmark is modest, to be fair: 138 instances across 12 repos, plus SWE-bench for the generated files. It's a strong signal, not the final word. Anthropic's own guidance points the same way: aim for under 200 lines per CLAUDE.md, and move rules that only apply to part of the codebase into path-scoped rules.

Then there's conflict. Add enough rules over enough months and two of them will disagree ("always use the helper" in one place, "write paths by hand for redirects" in another). The agent won't ask which one you meant. It'll pick one. You find out which in the diff.

Memory notes that never expire

Claude Code can write notes to itself. Correct it once and it may save a memory so the next session remembers. Per the docs, the memory index loads every session, the first 200 lines or 25KB. Nothing in that system knows when a note stopped being true.

My own memory folder has about a dozen entries, most with a date in the title, and at least one of them already carries a correction in brackets because I changed my mind after writing it. That's fine while it's a dozen. At a few hundred, it's a second brain nobody audits.

And a "second brain" setup has it worse than a code project. In a repo, an old plan can be checked against the code. A folder of notes has nothing to check against, so the agent can't tell which ones to ignore.

Long sessions and compaction

Even with clean files, a long session fills up with its own history, failed attempts included. Chroma's Context Rot research tested 18 LLMs and found performance gets less reliable as input grows, unevenly, even on simple tasks. Long context is a cost by itself, before a single stale line enters it.

One honest caveat: Chroma measured input length, not stale content. It doesn't prove old notes hurt. It proves more stuff hurts, and stale notes are a very efficient way to add more stuff.

This problem doesn't stop at code, by the way. In the InfoQ comments on the study (10 November 2026), one reader pointed out that outdated pages and conflicting information on websites probably confuse AI answer engines the same way. I think that's right, and it's the same reason I keep telling clients that in SEO and AEO the boring cleanup work is the work. An old pricing page an AI assistant keeps citing is a stale TODO with your logo on it. Ahrefs has noted that AI assistants cite newer content than organic search does, which says the machines already prefer fresh notes when they can tell the difference. Agents in a repo can't.

Spec drift: when the plan stops matching what you asked for

Spec drift is when your requirements change mid-build but the written plan doesn't. The agent then has two sources of truth, your latest message and an older spec file, and it may quietly follow the spec. Plans can go stale in an afternoon, no long session required.

Here's a typical case. Say the login spec says users can sign in with email or Google. Partway through the first tickets, the requirement changes to email only. The agent is told. The spec isn't updated. Now the project has a ticket saying one thing and a conversation saying another.

before

The login ticket, never updated

  • Sign in with email or Google
  • No status line
  • Chat says "email only", file says otherwise
  • Next session reads the file, not the chat

after

The ticket that stays true

  • Status: in progress
  • Sign in with email only
  • Decision logged: Google sign-in dropped
  • Rule 4 makes the agent flag the conflict before building

Nothing about that is exotic. Every change of plan starts as a sentence in a chat, and chats don't update files. If you don't write the change back into the plan at that moment, you've planted next month's stale TODO yourself.

A piece in Logistics Viewpoints (11 November 2026) put a rule on this that I liked: frozen decisions stay frozen. Once you decide "email only", that decision should live somewhere the agent reads, marked as decided, so it can't get reopened by an old document. It's written for supply chain teams, and it still applies cleanly to a specs folder.

The historian's take here is a little humbling. Developers have left stale TODOs for as long as there have been TODOs. They were cheap for decades because humans read them selectively. Agents removed the selectivity, and an old habit got a new bill.

How Google fixed it in its own codebase

Google built cleanup agents that scanned its codebases for TODOs pointing at fixed or obsolete bugs, then dug through bug, file and code history before proposing a deletion. Only TODOs confirmed obsolete went to a human for review. Over six months it removed thousands, with over 95% acceptance from reviewers.

The detail most summaries skip: finding TODOs with closed tickets wasn't enough. A TODO can be "load-bearing", meaning the bug is closed but the note still explains something real. So the agents went further, through the history of the bug, the file and the codebase, sometimes years of it. Only when the agent could confirm that the TODO and the intent behind it were obsolete did it send a change for review.

Two things make that 95% believable. The agent proposes, a human approves. And the agent is conservative by design: no proof, no deletion. That's the pattern I'd copy, and it matches how I rank agent work in general. Read-only reports first, drafts a person approves second, anything that changes things on its own last.

Google's closing point is the one to stick on the wall: "agent friendly codebases" need more than healthy code in the hot path. Cleanup work that used to sit at the bottom of the backlog as low value needs re-evaluating now that agents read everything.

How to set it up in your own project

You can copy Google's approach in any project with six changes: status tags on tickets, a rule that the code is the source of truth, a rule to leave unrequested work alone, a check of new requests against existing plans, a fresh session per task, and a report-only sweep skill with a human approving every removal.

Rules 1 to 5 are a few lines of CLAUDE.md and a habit. Rule 6 is a skill. None of them need a smarter model, which is the point. This is the kind of thing I build into every AI agent setup, whether it's for a coding project or for marketing automation where an agent publishes on its own. If you'd rather have someone set it up with you, that's what my AI automation and agents work is.

1. Add a status tag to every ticket

Every spec or ticket file gets one line at the top: Status: completed, in progress or not started. Without it, a feature that's in the plan but missing from the code is ambiguous. Was it never started, half built or dropped? The agent can't tell, so it guesses, and a guess is how side quests start.

The tag also tells the agent which source to trust. For a ticket marked in progress, the plan is ahead of the code on purpose, so the agent should follow the plan. For one marked completed, the code wins.

2. Make the code the source of truth

Add a rule to CLAUDE.md: when a plan, note or memory disagrees with the code, trust the code and tell me. The second half matters as much as the first. You want the disagreement surfaced, not silently resolved in either direction.

3. Tell it to leave alone what you didn't ask about

One line: don't fix, refactor or "improve" anything outside the task, and list it instead. This is the direct answer to the Eager Agent. A note at the end of the session saying "I noticed bug 48213 looks open" costs you nothing. An unrequested edit costs you a review.

I'll be straight that this is advice, not a measured result. There's no published test of how much this one line helps. It's still the cheapest line you'll ever add to a config file.

4. Check every new request against existing plans

When you ask for something that isn't in the specs folder, the agent should compare it with the existing plans before building and flag any overlap or conflict. This is the rule that would have caught the login drift: "email only" conflicts with a ticket that says email or Google, so the agent asks, you update the ticket, and the plan stays true.

5. Start a fresh session for every task

A long session keeps every failed attempt in context. Start a new session per task, including the moment you finish planning and are about to build. Planning sessions are full of rejected options, and you don't want the builder reading the brainstorm. Write the plan to a file, close the session, open a fresh one, point it at the file.

Here are rules 1 to 5 as a block you can paste into CLAUDE.md and adjust:

## Working rules
- Every spec and ticket starts with "Status: completed | in progress | not started".
  Keep it current when you finish or drop something.
- The code is the source of truth. If a plan, note or memory disagrees with the
  code, trust the code and tell me about the mismatch. Exception: for a ticket
  marked "in progress", follow the plan.
- Only touch what the task needs. Don't fix, refactor or "improve" anything else.
  If you notice something (an open TODO, a bug, dead code), list it at the end
  instead of changing it.
- Before building anything that isn't an existing ticket, compare it with the
  plans in /specs. If it overlaps or conflicts, stop and ask me, then update the
  plan before you build.
- One task per session. After planning, write the plan to a file and stop;
  I'll start a fresh session to build it.

Keep it short. Remember the ETH result: every line you add is a line the agent carries into every task. These earn their place because they cover non-standard behaviour the model won't guess on its own.

6. Run a report-only sweep skill

The rules stop new rot. They don't clean up what's already there. For that, create a sweep skill: it finds stale notes, plans, memory and TODOs, checks each against the code and git history, has an independent checker verify the claims, and reports instead of fixing. You approve, then it archives.

Diagram of a report-only sweep skill for AI agents: sweep, compare with code and git history, independent check, report, human approval, then archive with a hook that blocks reads
Source: growthvibes.ai

The design choices are what make it safe, and most of them are borrowed straight from Google's cleaner:

  • Report, don't fix. The sweep produces a list. Nothing changes until you say yes, the same human review step that Google's 95% acceptance rate leans on.
  • No proof, no change. If there's no evidence a note is outdated, the sweep leaves it alone.
  • An independent checker. A second agent gets only the claims, not the main agent's suspicions, so it can't be talked into agreeing.
  • Conflicts go to a human. If a memory or rule disagrees with the code, it isn't automatically stale. Maybe the code is the bug. Those get their own section in the report.
  • Archive, don't delete. Approved files move to an archive folder, and a hook that runs before reads and searches blocks the agent from opening anything in it. History is kept, context stays clean.

Here's a starting prompt. Ask your agent to turn it into a skill:

Create a skill called "sweep". Its job is to find stale notes that could
mislead a coding agent, and report them. It never fixes anything itself.

1. Scan CLAUDE.md files, /specs, plans, memory notes and TODO/FIXME comments.
2. For each item, compare it with the code as it is now and with the git
   history. Collect evidence: commit, file, line.
3. Hand only the claims (not your suspicions) to a separate checking agent
   that verifies each one independently.
4. Report in three lists:
   - Stale, with proof (and the evidence)
   - Conflicts between a note and the code, for me to decide
   - Unclear, left alone (no proof, no change)
5. Wait for my approval. Then move approved files to /archive and remove
   approved lines and comments.
6. Add a hook that blocks reading, searching or editing anything in /archive.

Treat it as a method to try, not a result. It's the same shape I use for skills generally: one job, written rules, a report at the end. If you want to see what skills look like in a real working setup, I wrote up how I built my content pipeline with Claude Code, CLAUDE.md and skills.

The same trap in marketing agents and SEO automation

My hunch, and it's a hunch rather than a measured result: this isn't only a coding problem. Any AI agent that works from files has it. An SEO agent writing from a content brief that predates your repositioning, a marketing agent reading a brand guide from two rebrands ago, an AI automation that pulls pricing from a doc nobody updated. Same mechanism, different folder, and probably the same fix: every file an agent reads needs an owner and a status. That's most of what I check first when a client's marketing automation starts doing odd things.

What this does not prove, and when to skip it

Google's study shows that stale TODO comments distract Google's internal agents, and what that costs per session. It doesn't measure CLAUDE.md files, Claude Code or your repo, and it doesn't show that cleaning up makes later sessions cheaper. It's strong evidence for the problem and good-faith evidence for the fix.

The limits, in plain words:

  • TODO comments only. The cleanest stale signal, not the only one. Everything I said about CLAUDE.md and memory is an extension of the finding, not part of it.
  • Google's agents, Google's codebase. A monorepo with millions of sessions isn't your side project. The mechanism transfers. The exact percentages may not.
  • Exposure and cost, not cure. The post reports the cleaner's acceptance rate, not whether sessions got cheaper afterwards. I'd love to see that number. It isn't there.
  • The setup isn't benchmarked. Steps 1 to 6 are sensible engineering. They're not a study.

And when to skip it. If your project is a few weeks old, your CLAUDE.md is 30 lines and you wrote every one of them, you don't need a sweep skill. You need to reread your file once a month. The sweep earns its keep on projects with history: a specs folder, a few hundred commits, memory that's been building up for months, more than one person or agent writing notes.

The one thing I wouldn't skip, even on a tiny project, is rule 3. Telling an agent to list instead of fix costs one line and removes the most annoying kind of surprise.

The cheapest fix is a true file

So, my CLAUDE.md. That "Connect Sanity" line is gone. No new model required, just a file that stops lying to the reader that trusts it most.

That's where this leaves you. Google spent millions of sessions proving something a good manager already knows: people, and now agents, do what the documents tell them. The work is keeping the documents honest. It's also the least glamorous part of any AI automation setup, which is exactly why it's usually skipped.

More on agents, automation and search is on growthvibes.ai. Now go read your CLAUDE.md. Out loud, if it helps.

Frequently asked questions

What is agent distraction?

Agent distraction is Google's term for a coding agent acting on stale or irrelevant notes it finds in files, like old TODOs, specs or docs, instead of the task you gave it.

Google measured it on its internal agents using TODO(bug/...) comments, in its Agent Distraction post of 6 November 2026. The same mechanism applies to CLAUDE.md files, plans and memory notes.

Did Google release a fix for Claude Code?

No. Google's post studies its own internal coding agents and never mentions Claude. The lesson, keep what the agent reads true, applies to any agent, Claude Code included.

What Google did build is a cleanup agent for its own codebase that removed thousands of obsolete TODOs in six months, with over 95% of its changes accepted by human reviewers.

How much does a distracted session cost?

Per session, an unprompted bug detour added 70% more steps, 77% more tokens and 105% more wait time in Google's data, after controlling for developer, codebase, task type and model tier.

Those numbers are for unprompted detours on TODO bug references specifically. They tell you the size of the problem, not what your own repo will see.

Do stale CLAUDE.md files mislead Claude?

They can, and it fits what Google found: an agent treats what it reads as true. CLAUDE.md loads every session and survives compaction, so a stale line keeps coming back.

Anthropic's docs tell you to review CLAUDE.md periodically and remove outdated or conflicting instructions. I haven't seen a published study that measures CLAUDE.md specifically, so treat this as a strong inference, not a measured number.

Should I delete my TODO comments?

Delete the ones tied to closed work, but only after checking the history, because some closed TODOs still explain something. Move real open issues into a tracked backlog instead of leaving them as notes.

That's what Google's cleaner did: it removed only TODOs it could confirm were obsolete, and a human reviewed every deletion.

How often should I clean up CLAUDE.md and specs?

Update the plan whenever requirements change, at the moment they change. On top of that, run a report-only sweep every few weeks on projects with real history, and keep a human approving every removal.

On a small, young project, rereading your CLAUDE.md once a month is enough.