JoeyChen's own telemetry revealed that 469 of 691 API calls came from two background sessions left open in terminal tabs, running auto-compaction, retrospectives, and hook processing without active user interaction. Only 222 calls came from the main active session, meaning over two-thirds of the token burn was invisible background activity the user wasn't aware of.
The initial hypothesis shared on Hacker News posited that cache_read tokens — priced at 1/10th normal input rate for billing — were counting at full weight against the quota limiter. If true, this would mean 103.9M cache_read tokens consumed quota as if they were regular input tokens, making the advertised caching savings meaningless for rate-limited plans.
After spending 24 hours collecting telemetry across approximately 1,500 API calls and 6 quota reset windows, cnighswonger's statistical analysis found the lowest coefficient of variation (34.4%) when modeling cache_read tokens as counting at 0.0x against the quota — effectively disproving the full-rate hypothesis. This suggests the quota exhaustion has a different root cause than cache_read token mispricing.
The editorial frames the issue as a lightning rod for broader frustration: developers paying $100/month for AI coding tools are hitting invisible walls with no clear way to understand or predict their quota consumption. The fact that a meticulous user had to build their own token-level telemetry to diagnose the problem — and a community member had to run a 24-hour statistical study to test hypotheses — underscores a fundamental observability gap in the product.
On April 9, a developer named JoeyChen opened [issue #45756](https://github.com/anthropics/claude-code/issues/45756) on the Claude Code repository with meticulous token-level telemetry showing their Pro Max 5x plan — Anthropic's $100/month tier — had been completely exhausted in just 90 minutes of what they described as "moderate usage, mostly Q&A and light development." The issue collected 104 upvotes and 19+ comments within days, becoming one of the most-discussed quota complaints in the repository's history.
The numbers were striking. During the 1.5-hour window in question, JoeyChen's sessions made 691 API calls consuming 103.9M cache_read tokens, 1.4M cache_create tokens, and 387k output tokens across three sessions. The main active session accounted for only 222 of those calls — the remaining 469 came from two background sessions the user wasn't actively using. Those background sessions, left open in other terminal tabs, were silently running auto-compaction, retrospectives, and hook processing.
The issue quickly became a lightning rod for a broader frustration: developers paying premium prices for AI coding tools and hitting invisible walls that make sustained work impossible.
The initial hypothesis was elegant and damning: cache_read tokens, which Anthropic prices at 1/10th the rate of regular input tokens for billing purposes, appeared to count at full rate against the quota rate limiter. If true, this would mean the caching discount that makes large-context interactions affordable was a billing fiction — you'd save money per token but burn through your quota allocation just as fast.
A community member named @cnighswonger spent 24 hours collecting telemetry across ~1,500 API calls and 6 quota reset windows to test this hypothesis — and found it was likely wrong. Their statistical analysis showed the lowest coefficient of variation (34.4%) when modeling cache_read tokens as counting at 0.0x against the quota, meaning cache_read tokens probably don't count toward the rate limit at all. The 0.1x (published rate) and 1.0x (full rate) models both produced wildly inconsistent predictions across reset windows.
So if cache reads aren't the problem, what is? The answer turns out to be more mundane but arguably more insidious: prompt cache misses on 1M context windows.
Claude Code uses a 1-hour prompt cache window for its main agent. When you step away for lunch, take a meeting, or just context-switch to another task for 70 minutes, your cache expires. The next interaction triggers a full cache miss — sending up to 960,000 tokens as new cache_creation input in a single API call. On a 1M context window, a handful of these cache misses can obliterate a 5-hour quota window in minutes. The larger context window that's supposed to make Claude Code more capable becomes the mechanism that makes it unusable.
Perhaps the most practically important finding was how much quota leaked to sessions the user wasn't actively using. JoeyChen had three Claude Code sessions open: one active development session, and two others from previous tasks left in background terminals.
Those background sessions consumed 78% of the post-reset quota through automatic operations — compaction cycles that triggered when context grew too large, retrospective generation, and various hook processes. The user had no visibility into this consumption and no warning that idle sessions were draining their quota.
This is a UX design problem masquerading as an infrastructure problem. Claude Code's architecture assumes session lifecycle management is the user's responsibility, but provides no tooling to make that manageable. There's no dashboard showing per-session quota consumption. There's no idle timeout that suspends background sessions. There's no warning when a session you haven't touched in hours starts burning tokens on housekeeping.
For developers running Claude Code as a persistent tool — which is exactly how Anthropic markets it — this creates a trap. The more sessions you use (and Claude Code encourages multi-session workflows), the faster your quota evaporates.
Let's put this in context. Anthropic's Claude Code subscription tiers are:
- Pro ($20/mo): Base quota - Pro Max 5x ($100/mo): 5x the base quota - Pro Max 20x ($200/mo): 20x the base quota
Issue [#43274](https://github.com/anthropics/claude-code/issues/43274) reports a user on the 20x plan at $200/month exhausting their quota in approximately one hour. If a $200/month plan can't sustain one hour of active development, the pricing model has a fundamental disconnect with the usage patterns it's designed to serve.
The comparison to API pricing makes the disconnect clearer. At API rates, the 105.7M tokens from JoeyChen's 1.5-hour session would cost roughly $15-30 depending on the cache hit ratio — meaningful but not catastrophic for a professional tool. The subscription model is supposed to provide predictability, but instead it provides unpredictability: you don't know when you'll hit the wall, and when you do, your session is dead until the 5-hour reset window expires.
If you're using Claude Code today, the immediate action items are concrete:
Session hygiene matters more than you think. Close Claude Code sessions you're not actively using. Each idle session is a quota drain running compaction and hooks in the background. If you're working across multiple repos, exit and re-enter rather than leaving sessions parked.
Treat the 1M context window as opt-in, not default. Anthropic's Boris Cherny confirmed they're investigating defaulting to 400k context with a configurable upper bound. Until then, if you're hitting quota limits, a smaller context window means smaller cache misses. The practical sweet spot appears to be around 200-400k tokens of context — enough for meaningful codebase awareness without the catastrophic cache miss penalty.
Run `/clear` religiously. Before resuming any session that's been idle for more than an hour, clear the context. This forces a fresh start rather than triggering a full cache miss on a stale 1M context. It feels wasteful — you're throwing away context — but it's cheaper than the alternative.
Budget for the API if you need sustained throughput. The subscription model is designed for intermittent usage patterns. If you're doing sustained multi-hour development sessions, the API with pay-per-token pricing may actually be more predictable and cost-effective, despite the higher per-token rate.
Anthropic's response — shipping UX nudges and investigating smaller default context windows — addresses symptoms rather than the structural issue. The core problem is that quota accounting is opaque, session lifecycle is unmanaged, and the 1M context window creates failure modes that are invisible until you hit the wall. The community has done Anthropic's debugging work for them here, and the quality of analysis in this issue thread (particularly the statistical hypothesis testing on cache_read accounting) is genuinely impressive. Whether Anthropic matches that rigor in their response will say a lot about how seriously they take the power-user segment that's paying $100-200/month for a tool that sometimes can't sustain a morning's work.
Claude has gotten noticeably worse for me too. It goes into long exploration loops for 5+ minutes even when I point it to the exact files to inspect. Then 30 minutes later I hit session limits. Three sessions like that in a day, and suddenly 25% of the weekly limit is gone.I ended up buying the $100
I skimmed the issue. No wonder Anthropic closes these tickets out without much action. That’s just a wall of AI garbage.Here’s what I’ve done to mostly fix my usage issues:* Turn on max thinking on every session. It save tokens overall because I’m not correcting it of having it waste energy on dead
I'm afraid the music may be slowly fading at this party, and the lights will soon be turned on. We may very well look back on the last couple years as the golden era of subsidized GenAI compute.For those not in the Google Gemini/Antigravity sphere, over the last month or so that community
I'm noticing a fair number of degradation of Claude infrastructure recently and makes me wonder why they can't use Claude to identify or fix these issues in advance?It seems a counter intuitive to Anthropic's message that Claude uncovered bugs in open source project*.[*] https:/&
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
Hey all, Boris from the Claude Code team here.We've been investigating these reports, and a few of the top issues we've found are:1. Prompt cache misses when using 1M token context window are expensive. Since Claude Code uses a 1 hour prompt cache window for the main agent, if you leave yo