$ crontab -l
0 */6 * * * claude -p "summarize overnight logs" >> digest.md
That one line is the most expensive habit in this whole article.
A Pro or Max subscription caps how fast you can call the model.
Spend is a separate question, and most people read the two as one.
After the 15 June 2026 Anthropic billing split, that confusion stops being academic.
I run Claude Code all day, every day.
When the billing change landed in my inbox, I spent a week mapping where my own usage would quietly leak.
Five patterns double a bill while the dashboard still says "subscription". Here they are.
1. Headless crons bill on a second meter
Look at the command at the top of this post.
A six-hour cron, print mode, append to a file. Harmless on the surface.
Interactive Claude Code and headless print mode do not always draw from the same balance.
After the split, agentic headless invocations route through a metered path rather than your flat subscription.
So the cron runs forever, you never touch the keyboard, and the meter ticks the whole time.
Automating is fine. The leak sits in where the model call lives.
Separate the prep from the thinking.
Let a plain shell job gather the data on a schedule, then let an interactive session consume it on your own terms.
Move only the model call back under the subscription and leave the boring data-shuffling to ordinary scripts.
2. Reasoning effort set high for work that does not need it
Effort tier is the control most people never touch.
Higher effort means longer reasoning chains, and longer chains mean more output tokens per turn.
Output tokens are where the money lives.
Running the maximum tier to rename a variable is paying a cardiologist to take your blood pressure.
I default routine maintenance to a low tier and keep the heavy tiers for debugging and architecture, the two places where extra reasoning changes the answer.
Match the tier to the blast radius of the decision rather than to your mood that morning.
Here the asymmetry matters.
Under-reason a hard problem and you pay with a broken build and a second attempt.
Over-reason an easy one and you pay tokens on every turn, silently, all day.
3. Five-minute cache cliff
Prompt caching has a short time to live.
Roughly five minutes of idle and the cache for your conversation expires.
Your next turn then re-reads the entire context uncached.
On a long session that means thousands of tokens billed at full rate every time you come back from a coffee.
Watch for the slow session with long gaps between prompts.
Keep momentum inside the cache window, or compact and start clean.
A fresh, lean context is cheaper than a stale, bloated one that keeps missing the cache.
People obsess over the model they picked and ignore the shape of the conversation around it.
That shape is half the bill.
4. Automation that fans out per run
Anything wired into CI that calls the model on every push, every issue, every pull request is a fan-out.
One developer is fine.
Ten developers pushing forty times a day is a different invoice entirely.
Treating a per-event model call like a free lint step is the mistake.
A per-event call costs real money and scales with team activity rather than with your intent.
Before you wire a model into a hot path, price the worst-case event volume over a busy week, not the happy path you imagined at setup.
Most surprise invoices come from automation that worked perfectly.
That is the point. It ran perfectly, on a schedule, forever.
5. Always-loaded tools
Every tool server you connect ships its definitions into context.
A rich set of connected tools can carry tens of thousands of tokens before you type a single word.
That weight rides along on every request in the session.
I audit my connected servers the way I audit dependencies.
If a tool set is not earning its place in context, it gets disconnected rather than left running on a hunch it might be handy later.
Idle tools are not free.
They are a standing tax on every prompt you send for the rest of that session.
What ties all five together
None of these is a bug.
Every one is the system doing exactly what you told it to do.
Your doubling stays invisible because the dashboard still shows a subscription and the work still gets done.
Cost shows up a tier down, in tokens you never watched yourself spend.
Those leaks existed long before the 15 June 2026 split.
Removing the subscription cushion made them visible.
My rule now is short.
Treat the subscription as a rate cap, never a spend cap.
Keep the expensive surface on a short leash, meaning the model call, the effort tier, and the loaded tools.
Move everything mechanical to a cheaper lane that never touches a metered call.
A longer list of these patterns sits in my notes than fits in one post.
Which one is leaking in your setup right now, and how did you catch it?
Top comments (1)
Great breakdown. One more I'd add as #6: running everything through the most expensive model.
The Anthropic subscription locks you into Claude for everything — but a lot of daily work (summarization, data extraction, routine code review) doesn't need a frontier model. I route simple tasks through a cheaper alternative (DeepSeek V4 is ~15x cheaper) and only use Claude for the hard stuff. Same SDK, same params, just different model name. Cut my total bill from $1,200 to ~$33 without noticing any quality difference on 80% of tasks.
The subscription is a rate cap, like you said. But the model choice is a cost lever most people never pull.