Get More Out of Your Weekly Claude Quota: 3 Context Habits

By AI Tool Review November 10, 2026 5 min read
Claude Code Token Usage Context Window Cost Optimization Developer Productivity
Bottom line: Three small habits get you more tasks out of the same weekly quota (or a lower API bill), sharper answers late in long sessions, and faster results. One habit is a single command you run once. Another avoids a hidden charge that can make one message cost about 25x. Nothing to install, and the same ideas work with other LLMs too. Want to know which habits? Just scroll down…
Split illustration with the AI Tool Review logo in the center. Left: four small orange robot assistants buried under paper stacks, forgetting sticky notes, and a weekly usage bar full and red: limit reached. Right: the same robots with small neat stacks, a tall pile of finished tasks, and the usage bar only 40% used, in teal.

What You Get

  • More tasks from the same weekly quota. On a Pro or Max plan, every message draws on your limit, cached or not. Less context per message means more messages per week. (Paying per token on the API? Then it’s a lower bill.)
  • Sharper answers late in the session. The summary keeps your plan and drops the noise, so Claude stops forgetting what you said an hour ago.
  • Nothing to install. Two commands and one rule.
  • Faster results, not faster messages. The big win is finishing tasks sooner, not each message answering faster:
    • Fewer redo loops. This is the big one. Fewer “you forgot what I said” moments, and fewer turns spent fixing them.
    • No waiting for a reset. When your limit lasts the day, you don’t lose hours waiting for it to come back.
    • A warm cache starts sooner. Anthropic says caching improves time to first token on long prompts. One of the habits keeps the cache warm.
    • The trade-off: each compact pauses while Claude writes the summary, and that summary reads the full context once. Compacting more often means more short pauses. For me, it’s worth it. (I didn’t benchmark per-message latency, so I won’t give you a number.)

How much you gain depends on how big your sessions get today. If you already stay under 150K, expect a small change. If you often run past 500K, expect a big one.

This guide is focused on Claude Code, so the commands are Claude’s. But the principles work with any LLM: ChatGPT, Codex, Gemini and the rest all re-send the conversation, and all lose recall as it grows. Using another tool? Jump here.

The Problem: Limits by Noon

I love the 1M context window in Claude Code. No more “conversation too long”, one session can hold a whole feature. So I let my sessions run… and run.

Then I hit my usage limit before lunch. Again. And late in those long sessions, Claude started forgetting things I told it an hour earlier. I asked myself:

  • Why does the same kind of work cost more every day?
  • Why does a session get dumber the longer it runs?
  • Is the big window the problem, or how I use it?

When I audited my usage, the answer jumped out: 49% of it came from messages sent with more than 150K tokens of context. Not from hard tasks. From long sessions I never cleaned up.

Why Long Sessions Cost More

Bar chart: tokens read per message in one Claude Code session keep growing toward the 1M window, where auto-compact only starts at about 967K. The later bars turn red, labeled 'cost per message keeps climbing' and 'accuracy and recall drop as it grows (context rot)'. Every message re-reads everything before it. Let the session grow, and every message costs more and remembers less.

Every message re-sends everything

Turns out Claude Code sends the entire conversation with every message: your instructions, every file it read, every tool output, every reply. Prompt caching makes the repeated part cheaper, but cached reads still count against your plan. So a session at 750K pays about 3x per message what a 250K session pays, for the same question.

Bigger context, worse memory

It’s not just cost. Anthropic’s own docs say it plainly: as token count grows, accuracy and recall degrade, a phenomenon called context rot. The stale exploration from an hour ago competes with what matters now.

The window only cleans up at the very top

On models with a native 1M window, Claude Code auto-compacts at about 967K tokens. So by default, a session can grow almost to the ceiling before anything trims it. The window is a ceiling. I was treating it like a target.

The Fix: Three Habits

Chart: the same session with a dashed 250K cap labeled '/autocompact 250k'. Context climbs to the cap, drops back after each '/compact keep…' marker, and climbs again, never going above 250K. Checkmarks read: each message reads 250K or less, the summary keeps what you need next, one model all session so the cache stays warm. After: the session never goes past 250K, and each compact keeps exactly what the next step needs.

Habit 1: /compact with instructions

The Challenge: a plain /compact summarizes everything. It can’t know what you need next, so it may drop the one detail you care about (the failing test name, the plan you agreed on).

The Solution: tell it what to keep. /compact takes free text:

/compact keep the failing test names, the files we changed, and the next 3 steps. Drop the exploration.

Do it at natural breaks: after a research phase, before you start building, after a fix lands. If you always want the same focus, add a section to your CLAUDE.md and every compact (manual or automatic) follows it:

# Compact instructions

When you are using compact, please focus on test output, code changes, and the next steps.

And when you switch to an unrelated task, skip the summary: /clear starts fresh, for free.

Habit 2: Stay under 250K

Why it matters: without a cap, nothing trims the session until about 967K. Until then, every message pays for everything before it.

The Challenge: you will forget to compact. I did, every time.

The Solution: let Claude Code compact earlier, by itself. One command:

/autocompact 250k

It is saved to your user settings for the current model, so it sticks across sessions. Prefer a file? Put it in ~/.claude/settings.json (applies to every model):

{ "autoCompactWindow": 250000 }

Why 250K? It is my rule, not an official number. Anthropic recommends habits, not a size. For my work, 250K holds a full feature with room to spare, and it keeps every message at a quarter of the ceiling. Pick yours with /context, which shows what is filling the window right now.

Habit 3: Don't switch models mid-session

Why it matters: Claude keeps a cheap, ready copy of your conversation (the cache), but only for the model you’re on. Switch models, and the new one has no copy. So the next message pays close to full price to read your whole conversation again.

The Challenge: it’s tempting to start on a cheap model, then /model to a stronger one for the hard part (or the other way round).

The Solution: pick the model at the start, and keep it. How big is the hit? On Opus 5.5 or Sonnet 5.5, a cached read is billed at 0.05x the input price. Building the new cache costs 1.25x or more. So the first message after a switch costs about 25 times a normal one (yes, you read that right!!!). At 250K, that’s survivable. At 800K, it hurts.

Need a different model anyway? Three cheaper ways to get there:

  1. Hand over to a new session. Ask Claude to write a short handover file: the goal, what’s done, the files that matter, the next steps. Then start a new session on the right model (claude --model opus, or /model before your first message) and point it at that file. The new session starts at a few thousand tokens, not 800K.
  2. Send the job to a subagent. A subagent runs on its own model with its own small context, and only its answer comes back to your session. (More in Stop Burning Tokens on Subagents.)
  3. Compact first, then switch. If you must switch in place, run /compact first. The new model then re-reads a short summary, not the whole history.

Not on Claude? Same Habits

This guide is about Claude Code, but the three habits travel. Here is what each one looks like elsewhere (checked against each vendor’s docs, November 2026):

Habit Codex CLI Gemini CLI ChatGPT app
1. Compact /compact /compress No command. Start a new chat and paste a short summary.
2. Cap the context model_auto_compact_token_limit = 250000 in ~/.codex/config.toml {"model": {"compressionThreshold": 0.25}} in settings.json (a share of the window; restart after) Not available
3. One model per session Yes Yes Yes

A few differences worth knowing:

  • No instructions. Neither Codex’s /compact nor Gemini’s /compress documents a way to say what to keep. So compact at natural breaks, right after a phase ends, when the summary has less to lose.
  • Gemini has a price step. On the Gemini API, Pro models charge more per token above 200K input tokens. Staying under 200K there saves twice.
  • OpenAI caches per model too. Its docs say a different model can mean a different cache, so a switch misses it.
  • ChatGPT counts messages, not tokens. Plus limits are a number of messages per few hours, so a small context won’t stretch your quota there. It still gets you better answers in long chats.

Tools That Help

The habits cost nothing. These tools make them easier, mostly by keeping junk out of the context in the first place. All have pages on this site; the numbers are each maker’s own claims.

Tried one of these? Leave a review on its page (look for Write a review), so the next person knows what really works. Found a tool that belongs on this list? Suggest it with + Suggest a tool at the top of any page. Both help everyone pick faster.

Make the agent write less

Output stays in the context too, and gets re-read with every message.

  • Ponytail makes the agent reach for what already exists (built-ins, platform features) before writing new code. Smaller diffs, less to re-read (80 to 94% less code output, per its maker).
  • Caveman makes the agent answer in short, plain sentences, with every technical fact kept (about 75% fewer tokens, per its maker).

See where your context goes

  • Token Optimizer audits a Claude Code (or Codex) setup and shows what is filling the window and wasting tokens. It also keeps your work safe through compactions, which pairs well with Habit 1.
  • Claude Dashboard is a local dashboard of your Claude Code usage: burn rate, sessions, models. Use it to see the difference before and after you adopt the habits.

Put less into the context

Every file read and every command output lands in the context and gets re-sent with every message after it. These tools shrink it before it gets there, so you hit the 250K cap less often:

  • Context Mode sandboxes tool output so only the useful part enters the conversation (up to 98% less, per its maker).
  • RTK trims the output of common dev commands like test runs and git (60 to 90% less).
  • Headroom compresses everything an agent reads: files, logs, tool output (60 to 95% less).

Ask a map, don't read every file

Graphify turns your code and docs into a knowledge graph your agent can query. Why does that help? Most context is the agent reading files to understand how things connect. With a graph, it asks “what calls this function?” and gets a short answer, instead of opening ten files and keeping all of them in the context for the rest of the session. Its maker claims 71x fewer tokens than reading the raw files.

Browse more in AI Cost Reduction, including Token Optimization and Usage Analytics, and the LLM Skills subcategory.

Final Thought

The 1M window is a great safety net. Use it like one. Run /context in your current session right now. I bet it’s bigger than you think : )

Less context. More tasks. Better answers.

Sources