How to Make Claude Code's Usage Limits Last Longer Without Max
Practical habits that stretch Claude Code's 5-hour usage limits, from handoff docs to cache-aware workflows, without upgrading to the Max plan.
Why do Claude Code usage limits run out so fast?
Most of the time it isn’t Anthropic quietly tightening limits. It’s context. Claude Code charges you for every token it has to read, and a lot of that reading happens invisibly: stale chat history, bloated memory files, idle sub agents, and commands like /compact that silently reload an entire conversation before summarizing it. Users who track their usage with /usage often find that a single habit, like running /compact on a long-cold chat, burns double-digit percentages of their 5-hour limit without producing any actual work.
TL;DR
- Cache expiry is the hidden cost driver: once a conversation’s cache goes cold (roughly an hour of inactivity), your next message re-reads the whole chat at full price instead of a fraction of it.
/compacton a cold chat is expensive, not cheap, because Claude has to read the entire conversation to summarize it;/clearis free but wipes everything, so a handoff document sits in the useful middle ground.- Writing a
handoff.mdfile before ending a session (goal, what’s done, what’s next, decisions made, dead ends) lets you/clearand resume cheaply, a pattern similar to what Anthropic’s own long-running agents and newer Projects view already do. - Stable context belongs in files, not chat history: saving agreed-upon details (pricing, specs, decisions) into a markdown file means tomorrow’s session reads a short file instead of re-sending yesterday’s entire back-and-forth.
- Preloaded context adds up before you type anything: oversized CLAUDE.md files, unused plugins, and stale memory notes all get billed on every message, so trimming them (and keeping CLAUDE.md under roughly 200 lines) cuts baseline cost.
/usageshows exactly what’s draining your limit, including per-skill, per-subagent, and per-plugin breakdowns, cache miss rates, and specific trim recommendations you can apply directly.- Sub agents help only when used deliberately: each one draws from the same usage pool, so custom sub agents for small jobs often cost more than letting Claude decide when to spawn one.
What actually eats a Claude Code usage limit?
Anthropic’s caching system is built to make repeated reads of the same context cheap, but only while that cache is “warm.” In practice this means:
- A conversation you return to within about an hour still benefits from cheap cached reads.
- A conversation you return to after that window has to be fully reprocessed at full price before Claude can respond.
- Switching models or changing reasoning effort mid-session also invalidates the cache, even if you’re still inside the warm window.
One Reddit user’s experience illustrates the scale of this: restarting a stale conversation with something as simple as “continue” produced roughly five times the token usage of resuming within the cache window. The cost isn’t the work Claude does. It’s the re-reading Claude has to do before it can start.
Is /compact actually a good way to save context?
Not on a conversation that’s gone cold. /compact summarizes the whole chat, which means Claude has to read all of it first. If the cache is still warm, that read is cheap. If it’s expired, which is common when you compact a conversation you’ve come back to later, it becomes one of the most expensive single actions available in Claude Code. One Pro user reportedly burned 11% of their 5-hour limit running /compact on a cooled-down chat without getting any actual work done afterward.
/clear sits at the other extreme: it costs nothing, but it throws away all context immediately. Neither option is ideal on its own. The practical middle ground is writing a handoff document before clearing, so you keep what matters without paying to re-read what doesn’t.
How do handoff documents reduce token usage?
Before ending a session, ask Claude to write a handoff.md file summarizing only what a fresh chat couldn’t figure out on its own: the goal, what’s been completed, what should happen next, which files have already been touched, decisions that were made, and anything that was tried and didn’t work. Then run /clear and start the next session by telling Claude to read the handoff file.
This mirrors a pattern Anthropic already uses internally. Their own long-running agents produce a progress file and commit it to GitHub at the end of each session, so the next run can pick up state without re-reading everything that came before. Anthropic’s newer Projects view in Claude extends this idea structurally: each job gets its own conversation thread, and the main project conversation acts as an orchestrator that pulls from recent threads and project memory rather than the full history. That means you’re no longer manually managing context inside a project at all, the structure does it for you.
Why does saving context to files matter more than it seems?
A lot of people (by their own admission, including the creator of the source video) keep returning to yesterday’s chat because that’s where all the context already lives: pricing decisions, specs, prior reasoning. The problem is that every message in that reopened chat re-sends the full history once the cache has expired, which after about an hour, it has.
The fix is simple: before closing a chat, tell Claude to save the relevant output to a file, for example “save the pricing we agreed into pricing.md.” The next day, open a fresh conversation and tell Claude to read from that file instead of resuming the old thread. You get the same context at a fraction of the token cost, because Claude is reading a short, targeted file instead of reconstructing an hour of back-and-forth.
This same logic applies to model and effort-level selection. Pick the right model and reasoning effort at the start of a session and stick with it. Switching mid-session throws away the cache just like resuming a stale chat does.
What’s loaded into every chat before you even type anything?
Every new Claude Code session starts with baseline context already loaded, and you pay for it on every message. Running /context in a fresh chat shows what’s included: your CLAUDE.md file, every installed skill and plugin, and memory files. MCP tool schemas used to load in wholesale and inflate this baseline, but that’s no longer the case since tools now load only when Claude actually needs them.
To keep this preloaded context lean:
- Keep CLAUDE.md under roughly 200 lines.
- Move recurring workflows (like a weekly report format) into a skill rather than leaving them in a conversation thread.
- Uninstall plugins you tried once and forgot about.
- Move finished tasks and old project notes out of CLAUDE.md and into separate files that Claude only reads on request.
- Check your reasoning effort level before starting, and don’t change it mid-session, since that also breaks the cache.
How can you tell what’s actually consuming your limit?
Rather than guessing, Claude Code’s /usage command shows a breakdown of which skills, sub agents, plugins, and MCP servers are consuming your limit, with a weekly view available by pressing W. It also surfaces specific recommendations for anything using more than about 10% of your usage, often naming the exact cause (for example, a bloated CLAUDE.md costing tens of thousands of tokens per request) and in some cases letting you apply the fix directly from that screen.
/usage also reports a prompt cache line showing how often a given chat missed the cache, along with likely causes such as changed tool definitions. If you run /loop or other long-running tasks, those get their own usage row so you can see exactly how many tokens each run consumes.
Do sub agents save or cost context?
Both, depending on how they’re used. Sub agents were designed to protect your main conversation’s context by offloading work, but every sub agent you spin up draws from the same usage limit, so using more of them can increase total cost rather than reduce it.
Without shadow IT.
The general guidance is to avoid custom sub agents unless they’re handling something genuinely substantial, and let Claude decide when a task actually warrants delegating to one. For a job like scanning a large log file, Claude will typically reach for a sub agent on its own because it needs to. For small jobs, a sub agent just adds context overhead for no benefit.
When you do use one, be explicit about what should come back to the main conversation. Anthropic’s own example: use a sub agent to run a test suite and report only the failing tests with their error messages, not the full output. That keeps the main thread small while the bulk of the context stays contained inside the sub agent.
One technical detail worth knowing: sub agents only hold their cache for 5 minutes by default. If you’re running long jobs with pauses in between, setting the sub agent prompt cache TTL environment variable to 1 hour prevents the cache from being discarded and rebuilt unnecessarily between runs.
Frequently Asked Questions
Does Claude Pro have a lower usage limit than Claude Max?
Yes, Max plans offer higher usage limits than Pro, which is why heavy users often upgrade. The habits described here are aimed at reducing wasted token consumption so Pro’s limits stretch further, rather than replacing the need for Max in genuinely heavy workloads.
Is /compact always a bad idea?
No. On a chat where the cache is still warm (used recently), compacting is cheap because the context is already loaded efficiently. It only becomes expensive on conversations that have gone cold, where Claude must fully re-read the chat before it can summarize it.
How long does Claude’s context cache last?
Based on reported behavior, a conversation’s cache lasts about an hour of inactivity before it expires, after which the next message re-reads the full chat history at full price. Sub agents have a much shorter default cache window of 5 minutes, which can be extended via an environment variable.
What’s the single highest-impact habit for saving usage?
Writing a short handoff file (or saving key decisions to a dedicated markdown file) before ending a session appears to have the biggest effect, since it avoids full-price re-reads of long chat histories in future sessions.
Can I see exactly what’s using my Claude Code limit?
Yes. The /usage command breaks down consumption by skill, sub agent, plugin, and MCP server, shows a weekly view, flags anything using more than about 10% of your limit, and reports cache miss rates with likely causes.
