Stop hitting Claude's usage limits

No commands here. These are habits. The single biggest waste in Chat is a giant conversation that keeps re-charging you for its whole history on every new message.

• Start a new chat for each new task. A 100-message thread re-reads all 100 every time you hit send. Short, focused chats are dramatically cheaper.
• Use Projects for files instead of re-uploading. Attach a document to a Project once and it stops getting re-read (and re-charged) in every separate chat.
• Set Project instructions once. Put your tone, format, and rules in the Project settings so you're not retyping them every message.
• Leave "extended thinking" off by default. Only switch it on for genuinely hard problems, because it burns far more per answer.
• Turn off web search, research mode, and connectors when idle. They quietly add tokens to responses even when you don't need them.
• Batch your questions. Ask three things in one message instead of three back-to-back messages.
• Match the model to the job. Summaries, rewrites, and quick edits don't need the heaviest model.

Cowork is the desktop assistant that acts on your actual files and apps (Word, Excel, Chrome) and hands back a finished result. Because it works in many steps on its own, it burns through your limit faster than chatting. It has fewer dials to turn, so the wins come from how you point it.

• Point it at a specific folder or file, not everything. Every file it opens is context you pay for, so narrow the target.
• Describe the finished result, clearly. Vague goals make it wander and redo work, which is where the token burn explodes.
• One deliverable per session, then reset. Don't let a single run sprawl across unrelated jobs.
• Choose the model for the job's difficulty before you set it loose.

This is the most controllable of the three. It has real commands you type to manage what Claude is holding in memory. Copy any of these and paste them straight into a Claude Code session.

/clear

Wipes the conversation when you switch to unrelated work, so stale context stops getting re-charged on every message.

/compact Focus on the current task and any file changes

Summarises the chat so far and frees up room. Adding your own focus keeps the important bits and drops the noise.

/context

Breaks down what's filling the window (system prompt, tools, memory, and history) so you know what to cut. Pair it with /usage to watch your consumption.

/model opusplan

Uses Opus to plan, then Sonnet to execute. Planning is where deep reasoning pays off; the build is mostly mechanical, so you stop paying Opus rates for routine work. Type the full thing rather than hunting for it. It's a named alias, not one of the standard rows in the /model picker.

/effort

Thinking tokens are billed as output tokens, and the default is high on every model that supports effort (Opus 4.7 is the one exception; it defaults to xhigh). The full ladder is low, medium, high, xhigh and max. Drop to low or medium for straightforward work and you cut the most expensive part of each answer. Save the top settings for genuinely hard problems.

/usage

On a paid plan this is the single most useful command here. It shows your plan usage bars and breaks recent usage down by skills, subagents, plugins and individual tool servers, and it flags any behaviour eating 10% or more, like long context or cache misses. Press d or w to switch between the last 24 hours and the last 7 days.

/mcp

Claude Code now defers tool definitions by default: only the tool names load up front, and the full detail arrives when Claude actually reaches for one. So connected servers cost far less than they used to. They still aren't free: every server adds names, instructions and connection overhead, and each tool Claude touches pulls its full schema in for the rest of the session. Disable the ones you're not using, then run /clear.

• Keep your CLAUDE.md short. Anthropic suggests under ~200 lines. It's re-loaded every session, so treat it as a cheat sheet, not a manual.
• Use Plan Mode (Shift+Tab) before big jobs: review the plan, cut the waste, then let it run. Kills expensive trial-and-error.
• Ask for changes as a diff, not a full rewrite. Editing 15 lines shouldn't reprint the whole file.
• Tell it "no commentary, just the output" when you already know what you want.
• Send big side-jobs to a subagent. It does the messy searching in its own memory and hands back only the summary. For simple ones, set the subagent's model to Haiku.
• Prefer command-line tools over connected tool servers where both exist. Things like the GitHub or AWS CLI add nothing to your context, while a tool server adds a listing to every message.
• Move long instructions out of CLAUDE.md and into skills. CLAUDE.md loads at the start of every session whether you need it or not; a skill only loads when it's actually called.
• Be specific in the prompt. "Improve this codebase" triggers a broad scan you pay for. "Add input validation to the login function in auth.ts" doesn't.
• Go easy on agent teams. They run roughly 7× the tokens of a normal session when teammates are planning, because each one keeps its own context window open.