A CLAUDE.md File Triples Over Its Lifetime, and Nobody Can Prove It's Safe to Prune

Across 1,867 repositories and 247,694 individual instruction lifetimes, a CLAUDE.md file gains 4.9 net instructions every commit and more than triples in length before anyone rewrites it. Chakrabarti’s new paper traces why: appending a line costs nothing, but once the reason for that line is forgotten, safely removing it means checking its interaction with every other instruction already there, a cost that grows as O(2^|D|) in the number of directives. The paper names this catastrophic remembering, the mirror image of catastrophic forgetting, and it isn’t only diagnosis: inverting IFEval to build verifiable prompt worlds, the author shows that comments explaining an instruction’s rationale remove 99.3% of the excess growth (a synthetic prompt that would otherwise balloon 211% instead grows 1.4%), and the same trick lifts real-world instruction-following by up to 23.1% on WildIFEval. English may be the new code, but until agent context files get something like inline comments, they’ll keep accreting the way undocumented codebases always have.

Coordination is having its own rethink. AWS’s kiro-flock throws out the supervisor-and-subagents pattern that dominates multi-agent tooling (Strands, Kiro CLI’s own subagent delegation) and replaces the planner with an S3 bucket: each agent runs a fresh session, reads a bounded window of its neighbors’ append-only logs, decides on one contribution, and writes its own line. No broker, no orchestrator, no single point of failure, and per-agent cost stays flat as the cluster grows, since an agent at radius 2 reads four neighbors whether the cluster holds 8 agents or 800. Their largest run so far: 184 agents across 11 cooperating clusters, generating a programming language. The tradeoffs are concrete: full mesh visibility collapses diversity, because every later agent just agrees with the first signal it saw; persistent session history creates behavioral drift, which the fresh-session-per-iteration design specifically defeats; and there is no verification gate between steps, so the pattern only fits work, code review sweeps, module migrations, test generation, that decomposes into many independent contributions toward one goal, not work with strict ordering.

Reliability engineering for code review agents is converging on the same insight from a different angle. OpenCodeReview, out of Alibaba, argues that the freedom coding agents are usually given, open-ended tool use, unbounded exploration, is exactly what makes review agents unstable and prone to hallucinated comments. Its fix injects determinism at three points: rule-based file and criteria selection instead of agent-driven triage, a curated tool set instead of free-form exploration, and an independent reflector that only sees the diff (not the reviewing agent’s tool trace) to filter out unsupported claims without the self-reinforcing bias that would come from showing it the same context. On a 200-PR, 10-language benchmark with 1,505 expert-verified comments, it beats Claude Code and Codex configured as reviewers by up to 2.17x on SEM-F1 while using 5-15x fewer tokens. The through-line with the CLAUDE.md paper is worth noting: both are arguments that agent freedom needs deliberate constraint, not more context.

Grab’s new internal eval harness makes the case for why that constraint matters operationally. Grab Bench is not chasing leaderboard position; it is built to catch what the team calls subtle plausibility: a SQL query that keeps its shape but silently changes the metric it computes, a tool call that picks the right tool family but drifts on parameters, a coding patch that passes every visible test while breaking a stateful invariant nobody wrote a test for. Its scoring is mechanical wherever the task allows it, checking that evidence IDs actually exist and actually support the claim cited, rather than asking another LLM if an answer seems good, and every benchmark ships baselines built to catch shortcuts: a cite-everything baseline, a visible-tests-only coding agent, an empty-output baseline. If a shortcut baseline passes, the eval is not measuring what it claims to measure. Their finding that more reasoning helps planning-heavy tool use and actively hurts tasks needing literal schema discipline is a reminder that model settings do not generalize across task types, however consistent it feels from inside one team’s own stack.

Retrieval had its own effort-scaling moment. Weaviate shipped a tunable effort parameter for its Query Agent’s Search Mode, and the benchmarks show why three tiers beat one: on BRIGHT Biology, one of the hardest reasoning-intensive retrieval sets, ultrahigh effort lifts nDCG@10 from 13.0 (hybrid BM25 plus vector search) to 57.5, while on less reasoning-heavy domain benchmarks like WixQA, medium effort already captures most of the available gain and the higher tiers add only a couple of points. The pattern holds across all eight benchmarks tested: harder, more reasoning-intensive queries reward more test-time compute, easier ones do not, so the right move is picking effort per request instead of fixing one budget for every query. Separately, a new assessor-sensitivity study is a useful caution for anyone building LLM-judge retrieval evals off a single assessor prompt: conditioning an LLM judge on different personas shifts strictness and evidential thresholds even when the underlying relevance judgment barely moves, and smaller judge models are considerably more sensitive to that framing than large ones, worth checking before trusting a small model’s judgment on a system ranking.

On the tooling side, JetBrains brought the Agent Client Protocol to WebStorm, the same decoupling move LSP made for language tooling two decades ago: any ACP-compliant agent, GitHub Copilot’s CLI, Claude Code’s official adapter, whatever ships next month, becomes a first-class citizen in the editor without a bespoke integration. The pitch is specialization: no single agent wins across component architecture and design-token extraction in independent Figma-to-code benchmarking, so switching agents mid-workflow without losing file context or diff state matters more than picking one best agent and living with it.

Watch whether other IDEs standardize on ACP the way editors converged on LSP, and whether Grab-style mechanical scoring becomes the norm for enterprise agent evals now that plausible-but-wrong has a name instead of just being an anecdote.