Make Claude Code Use Less: 7 Habits and a Free Plugin

Me too!

Free PDF · 9 pages

The guide as a PDF, for you and for your agent.

Read it at your pace, print it or hand it to your AI agent: the prompt to paste is already inside.

Download the PDFCopy the link for your agent

If Claude Code burns millions of tokens a week for you, the problem is usually not how much you work, but how the chat is set up. Many teams use a single chat for everything, never empty it, never change model, and have Claude read whole files to find one line. Every message carries everything that came before it. Seven habits cut most of that waste. Quack, a free plugin, reminds you of them on its own.

Before You Start: 5 Words to Know

• Token: Claude's "fuel". Every word it reads or writes uses a few tokens. A 500-line code file can be worth several thousand.
• Context: everything Claude has in front of it while it answers: the conversation, the files it has read, the project instructions. It re-reads all of it on every message.
• Cache: a short-term memory that makes that re-reading cheaper. It expires after a pause: usually 5 minutes if you pay per use, one hour on a subscription.
• /compact and /clear: two commands you type in the chat. /compact summarizes the conversation and carries on from the summary. /clear empties it and starts fresh, while the project files stay where they are.
• Subagent and effort: a subagent is a helper that works in its own space, often on a cheaper model, and brings back only a summary. Effort is how much Claude thinks before answering: low, medium or high.

What It Is

Claude doesn't remember a chat the way a person does. On every message it re-reads the whole context from the start. In a long chat, even "ok, thanks" costs as much as re-reading a book.

Picture a colleague who, before answering you, reads out loud every email of the week. The answer is right, but it takes longer every time.

Why It Costs

An example with round numbers, just to show the scale. A chat used for days reaches 150,000 tokens of context. With 40 messages in an afternoon, Claude reads 150,000 tokens 40 times: 6 million. The same day split into tasks, with chats that stay around 20,000 tokens, reads 800,000. That's more than seven times less for the same work.

The cache lowers the price of that re-reading, but doesn't remove it. And after a pause it expires: the first message when you come back re-reads everything at full price.

This holds whether you pay per use or have a subscription: in the first case the bill grows, in the second the limit runs out sooner.

1. One Chat per Task

When you move to a different job, type /clear. The new chat starts light. What really matters, like the project rules and files, Claude finds again on its own.

2. /compact at a Natural Pause

If a task is long, type /compact halfway through. Claude summarizes what it did and continues from the summary. Do it at a resting point, not in the middle of a delicate fix.

3. The Right Model and Effort

For everyday work a mid-size model is enough: type /model sonnet. Or /model opusplan: the strongest model writes the plan, the mid-size one carries it out. For small edits, type /effort low. Don't switch model mid-task without a reason: the cache starts over.

4. Helpers for Long Searches

Finding where a function lives, reading a library's docs, searching the web: these jobs fill the chat with text you won't need again. Ask Claude to hand them to a subagent. It works in its own space and brings back only the summary.

5. A Short CLAUDE.md

CLAUDE.md is the project's instruction file, and Claude reads it on every message. The Claude Code docs suggest keeping it under 200 lines. Put the rest in documents Claude opens only when it needs them.

6. Files Read in Parts

To fix one function you don't need to read a 2,000-line file. Ask Claude to find the function and read only those lines.

7. Watch the Numbers

/context shows what fills the chat right now. /usage shows how much you've used. Check them once a day for a week: you learn fast where the tokens go.

Quack Does It Automatically

The habits work, but remembering all of them is a job in itself. Quack is a free Claude Code plugin that makes them automatic. Its home is quack.build.

How to install it. In Claude Code, type these two commands, one at a time, then restart:

1. /plugin marketplace add AlekDob/quack-marketplace
2. /plugin install quack@quack-marketplace

What it does:

• Rules at start. At every new session it gives Claude a few rules: short answers, files read in parts, searches handed to helpers, one chat per task.
• Reminders at the right time. Every 100,000 tokens it tells you: "New task? /clear. Same task? /compact." After a pause that expired the cache, it tells you how much the next message will re-read at full price.
• Big files. Before Claude reads a file of more than 400 lines in full, it reminds Claude to look for just the part it needs.
• A code map. /quack:index builds an index of the project: folders, files and functions, with exact line numbers. Claude reads the map and opens only the right piece. The map refreshes itself at every session.
• A team of ducks. Five helpers, each on the cheapest model that does its job well. You'll meet them below.
• Memory between chats. The docs helper notes in the project diary what was done and what's left. When you open a new chat, Claude gets the last lines: /clear doesn't mean starting over.
• A check of your setup. /quack:checkup measures what weighs on every message (instructions, skills, MCP servers) and suggests fixes. It applies only the ones you approve.

What it can't do. No plugin can type /clear or /compact for you, or change the main chat's model. Quack warns you, and you type the command. Automatic model switching happens only through the ducks, which have their own.

What it costs. It's free. It adds about 750 tokens per session: less than a single whole-file read it saves you. Everything runs on your computer. The only thing it sends out is one anonymous ping when you install or update it, and you can turn it off.

The Duck Team

Programmers call it "rubber duck debugging": you explain the problem to a rubber duck and, while you explain it, the answer shows up on its own. Quack is that duck, sitting next to Claude: it says little, at the right time. And it brings a team.

Each duck is a subagent: it works in its own space, with its own model and effort, and brings back only a summary.

• Pia, the planner (Opus, high effort). Reads the code and writes a short plan: which files, which steps, how to check. Never edits.
• Kit, the coder (Opus, medium effort). Builds Pia's plan or a long job in his own space, runs the tests and reports only what changed.
• Marco, the scout (Haiku, low effort). Finds where things are: paths and line ranges, never whole files.
• Iris, the researcher (Sonnet, medium effort). Looks things up on the web and answers with sources.
• Dante, the scribe (Haiku, low effort). Writes the diary, gotchas and decisions: the memory the chat starts from after /clear.

Who gets the work. No plugin can change the main chat's model. But Quack can choose which duck gets the work, and each duck has its own. This is the rule it gives Claude:

• A small or short task: your chat does it. Calling a helper has a startup cost, and on a short job it costs more than it saves.
• The chat runs on Sonnet and the task is big or unclear: Pia plans it and Kit builds it, both on Opus. The cheaper chat coordinates and checks.
• The chat runs on Opus: it plans itself, and hands only long jobs to Kit. That keeps the chat small.
• Searching the code, searching the web, taking notes: Marco, Iris and Dante.

You can always ask for a duck by name, for example: "have Pia plan this".

How It Works, Behind the Scenes

Quack isn't an app to open: it plugs into the Claude Code you already use, with three kinds of pieces.

• Hooks run on their own at three moments. When a session starts, they give Claude the rules, refresh the code map and hand over the last diary lines. When you send a message, they check how big the chat is and whether the cache expired, and only then warn you. Before Claude reads a big file, they suggest reading just a part. They never block your work.
• Skills are the two commands you run: /quack:index for the code map, /quack:checkup for the setup check.
• Subagents are the five ducks.

Everything runs on your computer with Node, with nothing to install. The code is on GitHub, in a few short files you can read.

We Measured It: With and Without Quack

We gave Claude Code the same tasks twice, with and without Quack, on a copy of the same project: a 280-file Next.js site. The main chat ran on Opus, and we repeated each test twice. Here is the average cost:

• Explain how a piece of the code works: $0.40 without Quack, $0.41 with Quack.
• Explore a whole section: $0.48 without, $0.49 with.
• Add a rate limit across three files, with a test: $0.56 without, $0.54 with.
• Review every API, fix one and write the diary: $0.51 both ways.
• The same rate limit with the chat on Sonnet: $0.25, with and without Quack, and the same result.
• The same rate limit, forcing "Pia plans, Kit builds" with both on Opus: $0.92 from a chat on Opus, $0.63 from a chat on Sonnet.

What these numbers say:

• On a single task Quack doesn't change the bill. The differences are a few points, up or down. On tasks like these Opus worked alone and called no duck. That's the right call.
• The biggest lever is the model. The same job on Sonnet cost less than half, with the same result. That's habit number 3, and it's worth more than any plugin.
• The ducks buy quality, not discounts. Pia and Kit put Opus on the plan and the code, each in a clean space, and they cost more than Opus alone. Use them on big or unclear tasks, not on everyday edits. That's why Quack's rule looks at both the task's size and the chat's model.
• Quack's savings are in long chats. The /clear and /compact reminders, the expired cache and the code map matter when a chat reaches 100,000 tokens, and a one-message test can't show that. To see it, try the small test below.

All 32 runs, the method, the limits and the script to repeat them are published: full results.

The First Prompt

Ready to copy. After installing, paste it into Claude Code inside your project:

Small Test

Before installing Quack, open the chat you've used for days and type /context: see how many tokens it carries. Then install the plugin, type /clear and take on your next task in a new chat. After a week, compare /usage with the week before.

Frequently Asked Questions

Do I need to code? You need to know how to use Claude Code. The rest is two commands to copy.

Does it work with a subscription or only the API? Both. On a subscription your limit lasts longer; on the API you spend less.

Do my files go anywhere? No. Quack runs on your computer. When you install or update it, it sends one anonymous ping to quack.build: the version and a random id, nothing else. It tells us how many people use it. Set QUACK_NO_PING=1 to turn it off.

Why is it called Quack? After the programmers' rubber duck: you explain the problem to it and the answer comes. Quack is the duck next to Claude, with its team.

How do I remove it? Type /plugin in Claude Code, pick Quack and uninstall it.

Does it work with Cursor or Codex? No, Quack is a Claude Code plugin. The seven habits work with any assistant.

Watch Out For

• The 6 million is an example. It shows the scale, it isn't a measurement. How much you save depends on how you work today.
• Quack warns, it doesn't decide. /clear and /compact stay with you: you know when a task is done.
• /compact summarizes, and a summary can drop a detail. Before you run it, ask the docs helper to note where you got to.
• Ducks aren't free. Every call has a startup cost: on a short task the chat should do it. Quack knows this, but if you ask for a duck by name, it listens.
• Our test is small. Two runs per task, on one project. The numbers give an idea, not a guarantee.
• The code map refreshes every session. If a function moved in the meantime, Claude searches for it.
• Limits and prices change. Check /usage and the Claude Code docs.

Next step: pick the right model for each job with cost-aware routing, and give your agents a memory so they stop repeating mistakes. Using Grok Bot too? There's a guide to make it use less.

Sources: Anthropic's Claude Code cost guide. The code map follows the idea of PageIndex: a tree to reason over, then read only the right branch. The short-answer rule is inspired by caveman, though a plain "be brief" rule gets most of the saving. To shorten command output, Quack pairs well with RTK.

Quack is free and open source, by Alek Dobrohotov and Studio Futuro: quack.build and the code on GitHub.

In short: Every message re-reads the whole chat: one chat per task, helpers on cheaper models, files read in parts. Quack reminds you automatically.