One idea explains every move below, so it's worth 20 seconds. Every time you send a message, Claude Code quietly re-sends your entire context window in the background: the system prompt, every tool and MCP definition, your CLAUDE.md, and the whole conversation so far. You pay for all of it, on every single turn. So a long, cluttered chat taxes each new message, and Claude also reasons worse when the window is stuffed. The whole game is keeping that window lean.
Screenshot this and tick them off. The first three are the daily habits that save the most.
/clear between unrelated tasks/compact when a phase ends but you still need the thread/context to see what's eating your window/usage to watch your real spendCLAUDE.md under ~200 lines, push the rest into skills/model/clearWhat it does: wipes the conversation so your next message starts from a clean window. Why it saves: the moment you switch to a new task, the old thread becomes dead weight that still gets re-sent (and paid for) on every message. Clearing it drops that cost to zero. How: type /clear as soon as you finish one task and start an unrelated one. It's a full wipe with no summary, so when you still need the history, use /compact instead.
/compactWhat it does: replaces the long conversation with a short summary you can keep working from. Why it saves: you keep the important decisions but drop the token-heavy back-and-forth. How: run /compact at a natural break, and steer it if you like: /compact focus on the API code and the decisions we made. Claude Code auto-compacts when you're nearly full, but doing it yourself at a clean stopping point gives a much tidier result.
What it does: turns on plan mode, where Claude lays out the approach before touching anything. Why it saves: the most expensive tokens are the ones spent going down the wrong path and redoing the work. A 200-token plan you approve first prevents a 20,000-token wrong turn. How: press Shift+Tab to cycle into plan mode before any real task, read the plan, then let it run.
/contextWhat it does: shows a live breakdown of everything in your context right now, the system prompt, tool and MCP definitions, your memory files, and the conversation. Why it helps: you can't trim what you can't see. If a stack of MCP tools or a giant CLAUDE.md is hogging the window, this is where you catch it. How: run /context whenever things feel sluggish or pricey.
/usageWhat it does: shows your usage against your plan's limits. Why it helps: no bill surprises, and you can see when you're burning fast and ease off. How: run /usage once a day. On Pro or Max it shows your plan limits; if you're on pay-as-you-go API billing, /cost shows the dollar cost of the current session instead.
What it does: your CLAUDE.md loads in full at the start of every session, so its length is a tax you pay constantly. Why it saves: a bloated memory file eats your window before you've typed a word, and Anthropic's own guidance is to keep it tight. How: trim CLAUDE.md down to your always-true rules and facts, and move any multi-step procedure into a skill, which only loads when you actually call it.
What it does: hands a heavy, verbose task (running the test suite, parsing logs, fetching docs) to a subagent that has its own separate context. Why it saves: the wall of output stays in the subagent's window, not yours, and only a clean summary comes back, so your main chat stays small and cheap. How: ask Claude to "use a subagent to run the tests and just report what failed," or set up a named subagent for jobs you repeat.
/modelWhat it does: switches which model is answering. Why it saves: the bigger the model, the more each token costs, and most work does not need the biggest one. How: keep Sonnet as your everyday default, drop to Haiku for simple, repetitive stuff, and only reach for Opus on genuinely hard reasoning. Switch anytime with /model.
What it does: every connected MCP server loads its tool definitions into your context on every turn, whether you use it or not. Why it saves: turning off the ones you're not using this session frees real space, and specific prompts stop Claude wandering (and wandering is expensive). How: run /mcp to see and disable unused servers, and write "add validation to the login function in auth.ts," not "improve my codebase."
| Command | What it does | Use it when |
|---|---|---|
/clear | Wipes context, fresh start | Switching to a new task |
/compact | Summarizes, keeps the thread | A phase ends, you still need it |
/context | Shows what's in your window | Things feel slow or pricey |
/usage | Your spend vs plan limits | Once a day |
/model | Switch model | Task is simpler or harder than usual |
/mcp | Manage connectors | Turning off unused servers |
| Shift+Tab | Plan mode | Before any real work |
If you only build three habits, make them /clear between tasks, /compact at the end of a phase, and plan mode before real work. Those three alone cut the most, because they attack the biggest cost: a long, messy context that gets re-sent on every message. Then glance at /usage once a day so nothing sneaks up on you.
Claude Code, manage costs (Anthropic official)
p.s. this lean-setup thinking, a tight CLAUDE.md, skills, subagents, the right model for the job, is exactly the kind of system we build together inside The AI System Club. The waitlist gets in first.