Rules re-injected as system-reminders on every tool call, consuming ~46% of context window

[poodle64]

Problem

Claude Code re-injects rule files (from .claude/rules/) as <system-reminder> blocks attached to tool call results throughout the conversation. This means the same rules are loaded into context repeatedly — not just once at conversation start.

In a real session with ~30 tool calls, this consumed approximately 93K tokens (46% of the 200K context window) just from rule re-injection, causing the context to fill up before meaningful work was completed.

Observed behaviour

• Rules with paths: YAML frontmatter are correctly filtered (only matching rules appear)
• However, matching rules are re-injected as <system-reminder> blocks on tool results throughout the conversation
• A single Read tool call resulted in 11 rule files (~6,200 tokens) being injected as system reminders
• Over a 30-tool-call session, the same rules are injected repeatedly, totalling ~93K tokens

Expected behaviour

Rules should be loaded into context once (or at most when the set of relevant files changes), not re-injected on every tool call.

Reproduction

1. Create a project with 10-15 rule files in .claude/rules/ scoped to common patterns (e.g. **/*.py)
2. Start a conversation and perform several file reads/edits on matching files
3. Observe <system-reminder> blocks containing full rule text appearing in tool results
4. Note context window fills rapidly despite rules being modest in size individually

Impact

Component	Tokens	% of 200K
Initial config load	~43K	21%
Rule re-injections (~30 tool calls)	~93K	46%
Actual conversation content	~50K	25%
Total	~186K	93%

The initial load (21%) is reasonable. The re-injection (46%) is the problem — nearly half the context window is consumed by repeatedly injecting rules the model has already seen.

Suggestion

• Inject rules once at conversation start (or on first relevant file access)
• Only re-inject if the set of relevant rules changes (e.g. user starts working on a different file type)
• Consider a hash/fingerprint approach to avoid re-injecting unchanged rules

Environment

• Claude Code VSCode extension
• ~45 master rule files (shared via symlinks) + 8 project-specific rules
• Rules use paths: frontmatter for scoping
• Model: Claude Opus

[github-actions]

Found 3 possible duplicate issues:

1. [BUG] Claude wasting MILLIONS of tokens! Read <system-reminder> injecting on every file Read #21214
2. [BUG] Infinitely repeated large <system-reminder> messages in Claude Code CLI in -p (headless) mode #27599
3. [BUG] Hundreds of lines of modified file notes being injected into context on EVERY user message via <system-reminder> #16021

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

🤖 Generated with Claude Code

[Sagargupta16]

This is a real pain point — I've measured similar overhead in my own sessions. Here are some practical workarounds until this gets fixed:

1. Keep .claude/rules/ minimal
Consolidate multiple rule files into one lean file. Each separate file gets re-injected independently, so 5 files × 30 tool calls = 150 re-injections vs 1 file × 30 = 30.

2. Move stable rules into CLAUDE.md instead
CLAUDE.md content benefits from prompt caching (90% discount on cache hits — $0.50/MTok vs $5.00/MTok on Opus 4.6). Rules injected as system-reminders may break the cache prefix on each tool call.

3. Use /compact proactively
Run /compact before hitting the wall. The context compression can reclaim significant space.

4. Budget your rule lines
The math: 100 lines of rules ≈ ~500 tokens. At 30 re-injections = 15K tokens wasted. At 60 re-injections = 30K tokens. Keep rules under 50 lines total — every line pays a multiplicative cost.

I wrote a detailed guide on context optimization strategies including this exact issue: Context Optimization Guide

[lilpacy]

Additional data point from OTEL telemetry capture:

I captured api_request events with token counts alongside InstructionsLoaded hook events for a single session. The nested_traversal mechanism re-injects the same subdirectory CLAUDE.md every time Claude reads a file in that directory.

Session: f3736323-1a26-460f-9dc9-845ee0c4c9b6

InstructionsLoaded events (same file loaded 3 times):

Time	load_reason	file_path
03:52:12	nested_traversal	.../apps/web/CLAUDE.md
04:03:57	nested_traversal	.../apps/web/CLAUDE.md
04:04:14	nested_traversal	.../apps/web/CLAUDE.md

Token counts from api_request OTEL events:

Time      total_context_tokens
03:52:10  26,973   ← before first load of apps/web/CLAUDE.md
03:52:17  45,593   ← after first load (+18,620 tokens)

The same ~18k-token CLAUDE.md was injected 3 times during this session.

Environment: Claude Code 2.1.72, macOS Darwin 25.2.0

[poodle64]

Related: #34209 covers a complementary problem — even if paths: re-injection is fixed, there's no mechanism for sub-projects to exclude inherited rules from parent directories. Claude Code's parent directory traversal loads all ancestor .claude/rules/ unconditionally, so a Swift-only project inside a multi-language governance tree still loads Python/Svelte/Rust rules at session start.

The two issues work together:

• This issue (Rules re-injected as system-reminders on every tool call, consuming ~46% of context window #32057): Fix paths: so matching rules load once, not re-injected per tool call
• [FEATURE] Allow projects to exclude inherited .claude/rules/ from parent directories #34209: Allow projects to control which ancestor rules they inherit

Both are needed for efficient rule management in monorepo/multi-project setups.

[poodle64]

Update on v2.1.74 testing

Tested using the InstructionsLoaded hook (Claude Code's own infrastructure, not model self-reporting) across three separate sessions from a Python project with a canary rule using paths: ['**/*.py'] frontmatter.

What is working in v2.1.74:

• paths: frontmatter scoping works correctly — rules with paths: ['**/*.py'] only trigger InstructionsLoaded when a matching file is read
• The hook fires once per rule per session (correct deduplication)

The working YAML format:

---
paths:
  - '**/*.py'
---

What is still broken:
The core problem in this issue — rules being re-injected as <system-reminder> blocks on every tool call — is still happening. I observed it directly: a single Grep tool call resulted in 9 full rule files being re-injected as <system-reminder> blocks attached to the tool result, despite those rules having already been loaded earlier in the session.

The InstructionsLoaded hook and the <system-reminder> re-injection are two separate mechanisms. The hook correctly fires once; the re-injection happens on every tool result regardless.

Leaving open for Anthropic to confirm and close.