stretch-usage-limits

---
name: stretch-usage-limits
description: >-
  Diagnose why a Claude Code session is burning through usage limits and fix the
  causes, in order of what actually costs the most. Use this whenever the user
  says they hit their limit, ran out of usage, got rate limited, wants to know
  why Claude is "so expensive", asks how to make their plan last longer, mentions
  the 5-hour or weekly window, or complains that a session got slow and costly —
  even when they do not name tokens or limits explicitly. Start here rather than
  guessing, because it routes to the specific skill that fixes each cause.
license: MIT
metadata:
  author: Emerick Chasse
  homepage: https://claudeusagelimits.com
---

# Stretch your Claude usage limits

Someone who has hit a limit usually wants one of two things: to understand what
ate it, or to get more work done before the window resets. This skill covers
both, and its main job is to stop you from optimising the wrong thing — most
guesses about where the tokens went are wrong, and the measurement takes a
minute.

## The three facts everything else follows from

**1. A limit window is shared across models.** On Pro, Max, Team and Enterprise,
usage draws from a per-seat allowance on a rolling 5-hour window and a weekly
window, and those windows are shared across every model. Switching to a cheaper
model with `/model` does **not** restore access once the window is spent. It does
keep you working after a model-specific message ("You've hit your Opus limit"),
which is a different thing and worth saying out loud, because the two get
confused constantly.

**2. Every request carries the whole conversation.** Claude Code sends the full
history with each request, and each tool call sends another request carrying that
history plus the new tool results. A one-line question at 5pm in a session opened
at 9am still pays for the whole day's context. Prompt caching makes that cheap
rather than free — a cached input token is about a tenth of a fresh one — but the
history is still re-read on every single turn.

**3. Output costs about five times input, and about fifty times cached input.**
On current pricing an output token is 5× an input token; a cached input token is
0.1×. That ratio is the whole game, and it decides what is worth fixing:

| Worth it | Not worth it |
| --- | --- |
| Not writing out text you already read (output tokens) | Shortening your own prompts (input tokens, usually cached) |
| Keeping verbose tool output out of the main context | Trimming a few words from CLAUDE.md |
| Clearing between unrelated tasks | Fewer, longer sessions "to save on setup" |

## Work in this order

The order matters. The first two steps cost almost nothing and tell you which of
the rest is worth doing — skipping to a fix because it sounds plausible is how
people spend an afternoon trimming a file that was never the problem.

### 1. Read what was actually spent

Run `/usage`. On a paid plan it shows the plan-limit bars **and an attribution
breakdown**: recent usage split across skills, subagents, plugins and individual
MCP servers, each as a percentage. It also raises behaviour flags — long context,
cache misses — when one accounts for 10% or more of recent usage. Press `d` or
`w` to switch between the last 24 hours and the last 7 days.

That breakdown is the answer to "what ate my limit". Read it before forming a
theory.

Then run `/context` to see what is occupying the window *right now*: system
prompt, tools, MCP servers, memory files, conversation.

### 2. Make the limit visible from now on

If the user is repeatedly surprised by hitting a limit, the fix is not a smaller
CLAUDE.md — it is being able to see the window fill up. Load
[`show-usage-limits`](../show-usage-limits/SKILL.md): Claude Code hands the status
line the live 5-hour and weekly percentages, so they can sit at the bottom of the
terminal permanently.

### 3. Fix the causes the measurement pointed at

Match what `/usage` and `/context` reported to the skill that addresses it:

| What you measured | What to load |
| --- | --- |
| A large memory file, or "long context" flagged | [`optimize-claude-md`](../optimize-claude-md/SKILL.md) — and [`count-tokens`](../count-tokens/SKILL.md) to size it first |
| Tool results and file dumps dominating the context | [`delegate-to-subagents`](../delegate-to-subagents/SKILL.md) |
| Long sessions writing lots of code | [`write-compact-code`](../write-compact-code/SKILL.md) |
| Work that went down the wrong path and had to be redone | [`optimize-prompt`](../optimize-prompt/SKILL.md) |

### 4. The habits that beat every tool here

Say these plainly when they apply, because they are larger effects than anything
this plugin automates:

- **`/clear` between unrelated tasks.** Stale context is re-read on every
  subsequent message, and clearing costs nothing. `/rename` first if the session
  is worth returning to with `/resume`.
- **Match the model to the job.** Sonnet handles most coding work; reserve Opus
  for architecture and multi-step reasoning. This reduces spend *within* a
  window even though it does not reset one.
- **Lower `/effort` on simple tasks.** Thinking tokens bill as output — the
  expensive kind. `low` and `medium` are genuinely strong on current models.
- **Use plan mode (Shift+Tab) for anything complex.** The cheapest tokens are the
  ones spent on a path you did not have to abandon.
- **`/compact` is itself a large request** because it reads the conversation it
  summarises. When you want a fresh start rather than continuity, `/clear` is
  free.

## What this plugin does not do

It does not change your plan, raise a limit, or reset a window. Nothing here
touches Anthropic's accounting — it changes how much work fits inside it. If
someone is hitting a weekly limit every week on real work, the honest answer is
that they need a bigger plan or usage credits (`/usage-credits`), and no amount
of token discipline substitutes for that. Say so rather than optimising in
circles.

---

Part of the [Usage Limits Optimizer](https://claudeusagelimits.com/claude-usage-limits-skill/),
a free and open plugin. MIT licensed.