claude-code - 💡(How to fix) Fix TodoWrite system-reminder fires too aggressively when an active todo list exists [2 comments, 2 participants]

Official PRs (…)
ON THIS PAGE

GitHub issue graph ai analysis

Paste a GitHub issue URL. We fetch that issue, discover linked issues from bodies/comments/timeline, collect linked pull requests, and produce a structured English report.

The report is written in English Markdown for sharing and archival.

Helpful · Quick feedback

Loading…
GitHub stats
anthropics/claude-code#56415Fetched 2026-05-06 06:28:40
View on GitHub
Comments
2
Participants
2
Timeline
6
Reactions
0
Author
Timeline (top)
labeled ×3commented ×2cross-referenced ×1

The <system-reminder> that nags the agent to "use the TodoWrite tool" fires far too often during sessions where a todo list is already present, actively maintained, and being updated. In practice it adds substantial token cost and creates behavioral pressure toward performative TodoWrite calls instead of substantive work.

This is a fresh signal point following the auto-closure of #40573 (closed as stale). The comment thread on #40573 is the canonical history; prior related reports include #9769, #6760, #4464, and #21693. Filing this as a new issue so the signal isn't lost in a closed thread.

Root Cause

Two concrete harms:

  1. Token cost. The reminder re-injects the entire current todo list each time it fires. With a 13-item list firing ~15 times, that's a non-trivial fraction of context budget spent re-stating state the model already has.
  2. Behavioral pressure. Repeated nagging pushes the agent toward performative TodoWrite churn — re-writing the list to satisfy the reminder — rather than doing the actual work. This is the opposite of the tool's intended effect.
RAW_BUFFERClick to expand / collapse

Summary

The <system-reminder> that nags the agent to "use the TodoWrite tool" fires far too often during sessions where a todo list is already present, actively maintained, and being updated. In practice it adds substantial token cost and creates behavioral pressure toward performative TodoWrite calls instead of substantive work.

This is a fresh signal point following the auto-closure of #40573 (closed as stale). The comment thread on #40573 is the canonical history; prior related reports include #9769, #6760, #4464, and #21693. Filing this as a new issue so the signal isn't lost in a closed thread.

Concrete data point

During a single ~3-hour refactor session focused on one task, with a continuously-updated 13-item todo list, the reminder fired roughly 15 times, including immediately after TodoWrite calls (i.e., the agent had just written the list and was reminded to write the list). The list had a clear in_progress item throughout and was being kept current.

Why this matters

Two concrete harms:

  1. Token cost. The reminder re-injects the entire current todo list each time it fires. With a 13-item list firing ~15 times, that's a non-trivial fraction of context budget spent re-stating state the model already has.
  2. Behavioral pressure. Repeated nagging pushes the agent toward performative TodoWrite churn — re-writing the list to satisfy the reminder — rather than doing the actual work. This is the opposite of the tool's intended effect.

Suggested heuristics

Either of these would dramatically reduce false positives without losing the reminder's value for sessions that genuinely lack a plan:

  • Recency suppression: suppress the reminder when the most recent N tool uses (e.g., N=5) include any TodoWrite call.
  • Staleness gating: suppress when there is an in_progress item whose last update is within the last M minutes (e.g., M=10).

A combination (suppress unless both no recent TodoWrite and no fresh in_progress item) would be even tighter.

Cross-references

  • #40573 (auto-closed as stale; comment thread there is the canonical history)
  • #9769
  • #6760
  • #4464
  • #21693

Reporter

Mike Famulare ([email protected]) — Institute for Disease Modeling / Gates Foundation. Heavy daily Claude Code user on research-engineering workloads; happy to provide session traces if useful.

extent analysis

TL;DR

Implementing recency suppression or staleness gating heuristics can reduce the frequency of the <system-reminder> firing during sessions with an actively maintained todo list.

Guidance

  • Consider implementing recency suppression by tracking the number of recent TodoWrite calls (e.g., last 5 uses) and suppressing the reminder if any of these calls are present.
  • Implement staleness gating by checking the last update time of the in_progress item and suppressing the reminder if it is within a certain time threshold (e.g., last 10 minutes).
  • Combine both heuristics to create a more robust suppression mechanism that only triggers the reminder when both conditions are met.
  • Review session traces to determine the optimal values for the recency suppression and staleness gating thresholds.

Example

No code snippet is provided as the issue does not contain specific implementation details.

Notes

The suggested heuristics may need to be fine-tuned based on actual usage patterns and session data to minimize false positives while maintaining the reminder's effectiveness.

Recommendation

Apply a workaround by implementing the suggested recency suppression and staleness gating heuristics to reduce the frequency of the <system-reminder> firing during sessions with an actively maintained todo list. This approach can help mitigate the token cost and behavioral pressure issues without requiring a full fix.

Vote matrix · Quick signals

Works
Did the solution work? Tap to confirm.
Easy Fix
Was it a quick fix?
Time Saver
Did it save you time?
Blocking
Was it severely blocking?
Common Issue
Are others likely hitting this too?
Flaky / Intermittent
Is it intermittent?
Verified / Reproducible
Can you reproduce it reliably?
Loading…

Still need to ship something?

×6

Another batch ranked right after the header list — different links, same matching logic.

Back to top recommendations

TRENDING

claude-code - 💡(How to fix) Fix TodoWrite system-reminder fires too aggressively when an active todo list exists [2 comments, 2 participants]