Learn / Usage limits

Claude Code usage limits, explained

If you use Claude Code seriously, you've hit the wall: a message saying you're out of usage, often earlier in the day than you expected. Here's what the limits actually are, why they arrive early, and what you can honestly do about it.

Last updated 2 July 2026 · ~7 min read

The two limits that matter

Claude subscriptions (Pro and the Max tiers) meter your usage on two rolling windows at once, and you're subject to whichever one you hit first:

• A 5-hour window. Usage is measured in rolling five-hour sessions. When a session's allowance runs out, you wait for that window to reset — not for a fixed clock time, but five hours from when the session began.
• A weekly window. On top of the short window, there's a longer allowance that resets on a roughly weekly cadence. Heavy days early in the week can eat into it and leave you throttled later, even when a fresh 5-hour window is available.

The exact allowances differ by plan and Anthropic tunes them over time, so this page deliberately avoids quoting specific token or message numbers that would go stale. For the current figures, check Anthropic's own documentation — the mechanics below are what stay true.

Why the wall arrives early

The surprising part isn't that a limit exists — it's how fast a coding agent can spend against it. A single Claude Code session can burn far more than a human chat would, and most of that spend is invisible while it's happening. Three patterns do the damage:

1. Context bloat

Every message to the model resends the whole conversation so far — your prompts, the assistant's replies, and everything the agent has read or run. As a session grows, each new turn carries more context, so the same amount of "work" costs more tokens the deeper you get. A long, messy session is expensive on every remaining turn, not just at the end.

2. Redundant re-reads

Agents frequently pull the same file into context more than once — reading it, doing something else, then reading it again a few steps later. Each re-read is billed in full, even though the file hasn't changed and its contents are usually still in the window. In a busy session this quietly repeats across many files.

3. Oversized tool output

When the agent runs a command, searches the codebase, or fetches a page, the entire result lands in context — a thousand-line log, a giant test dump, a verbose build output. You'll read maybe ten lines of it; the model is charged for all of it, and it keeps costing you on every subsequent turn because it's now part of the resent history.

What you can actually do

There's no trick to raise your allowance, and you shouldn't trust anything that claims to. What you can do is spend the allowance you already pay for more carefully. In rough order of effort:

Compact and reset sooner

Use /compact to summarize a long session and shrink the context you're carrying, and start a fresh session when you switch tasks instead of letting one balloon all day. Claude Code also compacts automatically as the window fills — but that's reactive, and it works by replacing detail with summaries, so you lose the specifics it decided to drop.

Read smaller, on purpose

Point the agent at the exact function or line range you care about rather than whole large files. Ask for narrower searches. When a command is going to be noisy, pipe it through something that trims the output before it reaches the model.

Delegate to subagents

Hand big, self-contained searches or reviews to a subagent. The subagent does the heavy reading in its own context and returns only the conclusion, so the bulky intermediate work never lands in — and never keeps costing you across — your main session.

Automate the parts you'll forget

Every technique above depends on you remembering to do it, mid-flow, on every session. That's exactly the kind of discipline that slips when you're deep in a problem. This is the gap Tare fills: it runs locally inside Claude Code and handles the mechanical parts for you — it blocks redundant re-reads before they cost anything, trims oversized tool output down to a recoverable summary, and eases off intelligently as the window fills. Then it writes a ledger of what it saved, so the effect is measured, not assumed.