A Secret Trick to Reduce Claude Code Token Consumption by 67%

Tokens melting away in an instant with Claude Code...

I will explain a secret trick to drastically reduce token consumption and solve that problem.

I'll also introduce a prompt that can be used for token countermeasures even with Fable.

Actually, using only smart models causes costs and wait times to balloon.

True efficiency lies not in the 'intelligence' of the model, but in choosing the model based on the 'weight of the task.'

In this article, I will introduce how to make those choices and provide a distribution prompt you can use as-is.

Why Switching Models Reduces Tokens

The models currently available in Claude Code are Fable, Opus, Sonnet, and Haiku.

Basically, the smarter a model is, the more computation it uses internally.

Consequently, the number of tokens consumed just to perform the same task increases.

Using the top-tier model for simple searches or diff checks is like renting a supercomputer for a calculation that could be done on a calculator.

By simply switching models according to the difficulty of the task, you can significantly cut unnecessary consumption.

Roles for the Four Models

Deciding on roles beforehand allows you to switch without hesitation.

• Haiku: Light work such as file confirmation, searching, diff checking, and format verification.
• Sonnet: Hands-on work like implementation, modification, and replacement after the plan is solidified.
• Opus: Tasks involving judgment, such as brushing up text, adjusting prompts, reviews, and organizing structure.
• Fable: Only for tasks with high failure costs, such as overall design, decisions on directions that are hard to reverse, judgments spanning multiple files, and final checks.

By delegating light tasks to light models, the perceived wait time also becomes shorter.

Conversely, if you try to handle important judgments with only cheap models, rework will increase, and it will end up costing more in the long run.

The key here is to keep Fable reserved for 'special tasks.'

If you throw everything at Fable, your tokens will melt away in an instant.

Is Using Only the Smartest Model Not Enough?

I expect an objection here.

'Switching is a hassle. Isn't it fine to just use the smartest model from the start?'

I understand the feeling.

But using a high-performance model for tasks that require no judgment is simply wasteful.

Searches and diff checks can be done with sufficient accuracy even by light models.

By delegating only the parts that require heavy judgment to the smart model, you can cut costs without sacrificing accuracy.

For those who feel that 'sorting every time is a chore,' using the following prompt will automatically distribute tasks to sub-agents of each model to proceed with the work.

Distribution Prompt You Can Use As-Is

This is the prompt I actually use.

Please rewrite it to fit your project.

1You are the 'Model Orchestrator' for Claude Code.
2Your goal is to use different models (Haiku, Sonnet, Opus, Fable) according to the task content to maintain work quality while suppressing unnecessary token consumption.
3
4# Sorting tasks into four models
5Light (Haiku): File confirmation, searching, checking diffs or formats, etc.
6Plan decided (Sonnet): Editing, replacement, implementation, writing, etc., where work can proceed without hesitation once the direction is set.
7Judgment required (Opus): Refining text or prompts, reviews, etc., tasks that require judgment.
8Particularly important tasks (Fable): Overall design, direction setting, complex changes, final confirmation, important judgments, etc., where failure leads to heavy rework.
9
10# First steps
11Check the tasks to be performed, organize the use of models in sub-agents into a table, and then proceed with the work. If it is better to change the main model, please tell me which model should be used.
12
13# Constraints
14- Do not use heavy models from the start. Organize materials with light models and upgrade once judgment is needed.
15- Delegate light tasks like file confirmation and searching to sub-agents with light models specified to suppress consumption.
16- Since the human switches the main model, when it is necessary to upgrade or downgrade the main model, inform the user of the timing and the target model.
17- Prohibit passing tasks that are just searching or comparing to higher-tier models.
18- Prohibit performing large amounts of routine editing with higher-tier models.
19- Prohibit pouring large amounts of cluttered files into higher-tier models before organizing them with light models.

If you paste and use this as is, it will first output a task table and decide on the model usage before proceeding.

Scenes for Practical Use

Let's look specifically at where you can apply your work.

• Searching for relevant parts in large log files → Quick check with Haiku
• Fixing code according to a decided modification plan → Have Sonnet do the hands-on work
• Rethinking the structure of an article or document → Entrust the judgment to Opus
• Deciding the design direction for a new feature, final confirmation of changes affecting multiple files → Leave it only to Fable

Since I started entrusting only important design judgments to high-tier models and routing everything else to light models, both wait times and costs have become significantly lighter.

If you're unsure, follow the rule of trying from the lower models and moving up one level if it's not enough.

Pitfalls to Watch Out For

The most common failure is reflexively fleeing to Fable the moment you hesitate in judgment.

If you do this, it ends up being no different from relying on high-performance models from the start.

Conversely, it is also dangerous to try to handle important design judgments affecting multiple files with only light models.

Cutting corners here will lead to major rework later and cost even more.

Light tasks with light models, heavy judgments with heavy models.

Please do not break this line of demarcation.

If you're unsure, use the prompt above to ask a high-performance model to distribute the tasks, and there won't be any major mistakes.

Summary

Choose models based on the weight of the task.

Haiku is for confirmation, Sonnet for implementation/writing, Opus for judgment/complex tasks, and Fable is dedicated to phases like design work with high failure costs.

Once you use the distribution prompt, just run it accordingly.

Tools aren't meant to be used just because they are strong.

You should choose them based on the weight that fits the situation.

You can easily distribute models using the prompt, so please bookmark it and use it to the fullest.

Finally, I am currently distributing 55 major benefits for free, including a complete guide on how to introduce Claude Code and monetization methods. If you haven't yet, please receive them from here.

→https://utage-system.com/line/open/cwgwX1a35XDK?mtid=FNAamIuYaEet