What Claude Code Actually Costs: Six Months of Hacker News Receipts

On April 12, 2026, two separate threads appeared on Hacker News in the same calendar day: one about cache infrastructure Anthropic had changed on March 6, and one about a Pro Max subscription quota exhausted in 90 minutes. The first reached 552 points and 402 comments; the second, 759 points and 548. Neither thread connected the two events. The cache change had been live for 37 days before either was posted.

That single day sits in the middle of a sequence that runs from January to July 2026. The sections below follow it in order.

"You literally send your first message 'you are Claude code'"

The sequence starts on January 9, when a thread about Anthropic blocking third-party use of Claude Code subscriptions reached 625 points and 512 comments. The thread linked to an issue in the OpenCode repository, where the technical implementation of the block was already visible. commanderkeen08 described the original authentication mechanism: third-party clients that routed through a Claude Code subscription did so by sending their first message as "you are Claude code." That was the check, and as they put it: "The fact that this ever worked was insane."

Anthropic closed it on a Thursday night with no public notice. One commenter noted the timing: "the inevitable shitstorm would be very predictable."

The comments split between people who thought the crackdown was legally inevitable and people who read the Thursday-night deployment as hostile. What's harder to dispute is what the move reveals about the product. Claude Code subscriptions are flat-rate access to a bundle: the server and the client together. The argument, stated explicitly in later threads, is that this pricing model works because Anthropic controls both ends: they know how the official client uses the API, can test it against known scenarios, and can price the subscription accordingly. A third-party client with different cache behavior and different context management breaks that cost model.

The business logic is coherent, but it makes something visible: a Claude Code subscription isn't quite a product you own. It's access that requires the provider to approve of how you use it.

From patch to lawsuit

Ten weeks later, Anthropic took legal action against OpenCode. The project had already been patched around the January block; the lawsuit escalated the response. The thread reached 483 points and 389 comments.

The comments are worth reading for what they reveal about the community's read on the dynamic. noemit: "This is not the behavior of an innovative company - it is fear-driven. They are seeing a rapidly shrinking moat." Another commenter compared the likely endgame to the MySQL/Postgres split and predicted open tooling would eventually close the gap.

Neither of those claims is verifiable from comment threads. What the pattern does establish: in ten weeks, Anthropic moved from a silent technical block to litigation over the same behavior. That escalation curve matters if you're building a workflow that depends on the subscription staying accessible and the terms staying stable.

Six weeks of undisclosed change

The cache TTL thread is the most precise data point in the dataset.

On April 12, a thread about a cache infrastructure change deployed on March 6 reached 552 points and 402 comments. The change had been live for 37 days before it surfaced publicly. The original GitHub issue title included units that triggered a debate (whether "M" meant minutes or months) before the title was changed. One commenter noted the revision "totally hides the scale of the issue."

What the change meant in practice: Claude Code relies on prompt caching to avoid resending large context blocks on every request. When the cache TTL drops, more requests pay to re-send context that had been cached, because it expires faster between turns. _blk described the before-and-after: "where I could work on 3-5 projects at once on the max plan a month ago, I can't even get one to completion now on the same Opus model before the 5-hour session locks me up."

Anthropic's response, quoted by commenters from the GitHub thread, argued the March 6 change made the service cheaper overall. Commenters found the reasoning circular: if the cache expires faster, longer sessions hit more misses, and the per-session cost rises even if the average per-request cost falls. Anthropic said it wasn't planning a toggle to restore the previous behavior.

The change wasn't announced when it shipped. Users who noticed sessions burning faster in mid-March had no way to know the cache behavior had changed. That 37-day gap is the gap in which decisions get made on incorrect information.

One morning, two fires

Several hours after the cache thread appeared, a second thread landed: "Pro Max 5x quota exhausted in 1.5 hours despite moderate usage", 759 points and 548 comments.

"Moderate usage" has no denominator in the headline. The thread doesn't supply one: no task type, no context size, no session structure. Our standing rule is that we audit claims we agree with as well as claims we don't, and this one fails the same test we apply to income screenshots: the complaint proves someone hit a limit; it doesn't prove the limit was unreasonable for the plan. We cite the pattern because the timing is documented (quota exhaustion coinciding with the undisclosed cache regression), not because any individual claim is verified.

What is in the record: multiple cancellation announcements, including wg0, who wrote "Fair transactions involve fair and transparent measurements of goods exchanged. I'm going to cancel my subscription this month." And a counterpoint that cuts to the actual dependency: comandillos described Opus as "a great - if not greatest - model at coding and Anthropic is the only one serving it at reasonable prices when going through their subscription model." The reply, from sdevonoes: "Sounds like an addiction to me."

Both reads are present in the thread simultaneously, which is the more useful thing to know.

The routing bug and the refund policy

The HERMES.md thread from April 29 is the cleanest example of undisclosed billing cost in the dataset.

A file named HERMES.md appearing in commit messages triggered a routing path that sent requests to an extra usage billing tier. The bug was Anthropic's. The support response, quoted directly in the GitHub issue and then reproduced in the HN thread: "we are unable to issue compensation for degraded service or technical errors that result in incorrect billing routing."

The top comment: "Not sure I've ever seen a company openly take this position. This is a crazy policy." The thread reached 1,251 points and 520 comments.

The comments debated whether the no-refund policy was legally enforceable in various jurisdictions. One observation that holds regardless of jurisdiction: "anything they say is legal until a judge says it's not, and to get to that point, you need to be willing to spend a lot more than $200." Several commenters noted a secondary irony: the support response read as AI-generated, which meant Anthropic's AI support bot may have hallucinated a billing policy and then applied it to refuse a refund for a bug in Anthropic's own product.

What's not in the record: the exact dollar amount of the incorrect billing. The top comments reference the situation and the policy response; no specific figure appears. So we can confirm the routing behavior existed, that Anthropic acknowledged it, and that the stated position was no refunds for their own technical errors. The scale of the charge is unverified from the data we have.

33,000 tokens before the prompt

The most recent data point: a July 12 study that logged requests between coding agents and Anthropic's endpoint, 701 points and 389 comments. The finding: Claude Code sent approximately 33,000 tokens before reading the user's prompt. OpenCode, pointed at the same endpoint with the same model, sent roughly 7,000.

The study was motivated by a billing hunch: the researchers had been "forced to use Claude Code for a while" and noticed "the usage meter rise much, much more quickly than when using OpenCode." They added logging to confirm it.

Now apply this site's usual test to the study itself, because it fails the first part of it. The benchmark showing OpenCode roughly 4.7x leaner was written by people who open by saying "we usually use OpenCode." That is a finding published by the tool's own users about the tool's competitor. It's the same shape as the Reddit posts we take apart every week: a number that happens to flatter the thing the author already uses. MallocVoidstar went further in the top comment, arguing the article was AI-written and the testing AI-run.

The methodology attracted the rest of the scrutiny. The study used an older model version pinned for cost reasons, and the test traffic ran through a local gateway that added its own overhead. The authors acknowledged the constraints, said the harness payload numbers wouldn't change much with a newer model, and offered to re-run, which is more than most people asked to show their work ever do.

So hold it loosely and precisely at once. The direction was never contradicted by data in the thread, only by objections to method. But "4.7x" is not a fact you should repeat; "the people who prefer OpenCode measured OpenCode as leaner, and nobody has yet measured otherwise in public" is. If that distinction feels like hair-splitting, it is exactly the distinction between a receipt and a claim. This whole site exists in that gap.

The 33,000 figure is overhead sent per request, not task-compute. It doesn't appear in the subscription pricing. One commenter in the same thread described the broader pattern as "tokenflation," citing research showing that simple prompts like "Hey" or "commit" sometimes triggered 30-plus tool calls in agentic setups. The overhead is not unique to Claude Code, but the benchmark puts a number on the gap between harnesses.

The token-overhead-audit prompt in the sidebar turns this into a task-level calculation: what does your actual workflow cost per useful output, including harness overhead, at your specific model and plan? That is the number that determines whether the subscription makes sense, not the headline price.

What the exits say

Across the four threads from April and beyond, a consistent set of alternatives appears: Codex, open-source models, and ChatGPT subscriptions. Several commenters named the specific moment they switched and why. The thread from April 12 contains cancellations alongside people explaining why cancellation isn't viable: Opus remains, in some users' assessments, the strongest available model for the tasks they run, and the subscription is how they access it at a price the per-token API doesn't match.

The platform-dependency-ledger prompt is designed for this exact position: you have a tool that's genuinely useful, a provider that has demonstrated it will change terms without notice, and no clear map of what a switch actually costs. The exit-cost-estimator prompt works through the migration math before you make the decision.

The project pages for Claude Code and OpenCode in the Toolbox track star history and top-voted open issues, where the community's ongoing complaints accumulate between the HN threads with more granularity than any single viral post.

What the threads actually prove

Six months, seven threads, a consistent pattern: costs that don't appear on the pricing page, infrastructure changes deployed silently and discovered weeks later, and billing terms that shifted faster than the billing cycle.

What the threads don't prove: that any individual bill was unreasonable for the usage. "Moderate usage" in the quota thread is undefined. The HERMES billing amount is not in the public record. The cache TTL change may or may not have raised costs for any specific user's actual workflow. The one commenter who described losing session capacity had no baseline cost figures to compare.

What is in the record: the blocking of third-party clients in January, escalated to litigation by March; a cache change deployed March 6 and disclosed April 12; a routing bug that Anthropic declined to compensate; and a harness that sends 33,000 tokens of overhead before it reads your prompt. These are the charges that don't appear on the pricing page. Whether they add up to a bad deal depends on your workflow, your alternatives, and how much the specific Opus subscription matters for your tasks.

The subscription price is easy to find. This is the rest of the receipt.