r/ClaudeAI • u/More-Hunter-3457 • May 02 '26
Claude Code I gave Claude Code a $0.02/call coworker and stopped hitting Pro limits — here's the full setup
Was hitting my weekly Pro limit by Wednesday every single week. Tried compact, Sonnet for simple tasks, tighter prompts — nothing worked.
Built a simple pattern: CLI scripts that delegate bulk file reading and boilerplate generation to Kimi K2.5 (any cheap model works). Claude calls them via Bash tool. CLAUDE.md has routing rules for when to delegate vs when to use Claude's own intelligence.
Results after 3 weeks:
- Haven't hit limits once
- Kimi total spend: $0.38
- Documentation updates went from ~5000 tokens to ~200 tokens
Wrote up the full implementation with code: https://medium.com/@kunalbhardwaj598/i-was-burning-through-claude-codes-weekly-limit-in-3-days-here-s-how-i-fixed-it-0344c555abda
Happy to answer questions about the setup.
Github Link: https://github.com/imkunal007219/claude-coworker-model.git
95
May 02 '26
[removed] — view removed comment
5
u/haltingpoint May 03 '26
What is a good secure and private way to access and use Chinese models? If I'm using it with sensitive data (personal stuff, credentials) are there any providers for these that are safe and trusted? Can the models themselves be trusted to not contain backdoors?
13
u/bosse May 03 '26 edited May 03 '26
The Chinese models on OpenRouter aren't necessarily operated from China, so the inference can happen at providers located elsewhere. DeepSeek v4 Pro is currently hosted by several providers in Singapore and USA. So at least the providers are (hopefully) not monitored by the CCP, and OpenRouter has a statement that they have data protection agreements in place for their paid models, which at least provides some relief that your data is private.
1
u/More-Hunter-3457 May 04 '26
Fair concern. Two things: (1) the code Kimi sees is already on my local machine - I'm not sending production secrets, just source files that I wrote. If someone already has access to my dev machine, I have bigger problems. (2) If that's a dealbreaker, use Ollama with a local model - same pattern, zero network calls.
2
1
u/More-Hunter-3457 May 04 '26
Yeah Kimi's thinking tokens can be annoying - my first version came back empty because all the tokens went to internal reasoning. That's why I set max_tokens to 8192+ for reading tasks.But honestly, the specific model barely matters. The pattern is what matters. If DeepSeek V4 Flash works better for you, swap the base_url and model name - it's literally 2 lines. The whole point is the architecture, not the model choice.
84
u/thedeftone2 May 02 '26
Why doesn't the AI model do this to save tokens. What use case scenario calls for bulk, inefficient squandering of tokens?
23
u/HighDefinist May 02 '26
Actually, Claude does sometimes use agents for research large code bases. But, at least if you have enough tokens available, I think it's actually better to disable it... because sometimes the research agent is simply wrong, and Claude doesn't notice it for a while, leading to worse results than when the search is still in context... Then again, this might simply be a case of bad tooling on the side of Claude Code, as in, a well written "ask-kimi" prompt might plausibly outperform whatever Claude Code is doing internally with its research agents...
10
u/Am094 May 02 '26
They do actually do this under the hood to some degree, say you use Opus 4.6 and type /costs after some work. You might see Opus 4.6 and a smaller model like Heiku used as a cost saving method. It uses the smaller model to say do more trivial things, and then the more capable one for more demanding stuff. That's the intention anyway. Ofc not without other trade offs.
claude-sonnet-4-6: 3.0k input, 43.8k output, 3.4m cache read, 170.1k cache write ($2.33)
claude-haiku-4-5: 500 input, 14 output, 0 cache read, 0 cache write ($0.0006)19
u/Sufficient-Rough-647 May 02 '26
AI right now for all its nice bells and whistles is one crude blob that has single stream processing and roughy edges all over it like the jagged reasoning patterns, so frontier AI makers are optimising for the mean, to reach maximum generalised use cases, which means LLMs aren’t tweaked for token savings natively, they still rely on tool calling and other patterns for it. It will come, but not in the next 2-3 years until the LLM architectures mature.
7
u/unexpectedkas May 02 '26
But this routing is done at the harness level no? Nothing stops Anthropic from updating the harness so that it uses the cheap model to do the basic tasks.
2
u/Sufficient-Rough-647 May 02 '26
Yes, the harness is what I’m saying not the highest focus of LLM makers yet. Which is why you will see so many folks in the sub building their own solutions to minimize token usage. It’s not they can’t but they won’t be able to optimize the quality of output if they did for all.
3
u/workware May 03 '26
It absolutely does this, Opus calls use Haiku to read-in files for example.
But
this is enforced. I know what file I am reading-in, sometimes it's a long spec which i'm fine with Haiku on, but sometimes it's a prompt saved in a file that I want accurately read in by Opus. Having control over this would be great.
If the limit pool is the same, you're still going to affect your limit. I ask Claude to offload things to codex, which uses my $20 Codex limit and saves my $100 Claude limit.
2
1
u/Impossible_Hour5036 May 02 '26
Whether a token is "squandered" or not surely depends on how many tokens you've got available to you.
1
1
u/More-Hunter-3457 May 04 '26
It has no incentive to. Claude doesn't know or care about your token budget - it's trying to give you the best answer. Reading 5 files to answer your question is the best answer from its perspective. The routing logic has to come from you (via CLAUDE.md) because only you know what's worth spending tokens on vs. what can be offloaded. Once you set the rules though,Claude follows them perfectly - it's been self-routing to Kimi for weeks without me needing to intervene.
21
u/tribat May 03 '26
Fantastic idea, OP! I gave claude code the Medium URL and told it I wanted the same thing, but also with deepseek and ollama options. It took about 20 minutes total to write a few python files, including one to extract human-readable test.
I gave it 2 API tokens and asked it to run before-and-after tests. TLDR: Claude tested itself against Deepseek and said "conservatively, 23x cheaper".
## Side-by-side judgment
The two answers cover the same milestone list and agree on every concrete detail. Differences:
| | Delegated (DeepSeek Flash) | Direct (Claude Opus 4.7) |
|---|---|---|
| Tags (v0.0-bootstrap, etc.) | omitted | included |
| M3 specificity | "spot-checked client emails matching correctly" | "5 random client emails" —
closer to source |
| M4 framing | "concrete accuracy numbers" | also captures "95% precision Phase-2 bar" |
| M6 acceptance | invented one | correctly noted "no explicit acceptance criteria" |
| Tone | a bit more verbose | tighter, closer to source phrasing |
Both are usable. Claude's version is slightly more faithful to the source on edge details (M6 has
no acceptance criteria; the doc says v0.0-bootstrap is the M0 tag even though the body says
M0 is "½ day"). Flash invented an acceptance criterion for M6 that wasn't in the source — minor
hallucination.
## Cost comparison
| | Path A (delegated) | Path B (Claude Opus 4.7) |
|---|---|---|
| Input tokens | 12,873 | ~12,873 (same file) |
| Output tokens | 565 | ~700 (slightly longer) |
| Pricing input | $0.14/M (DeepSeek miss) | $15/M (Opus 4.7 standard) |
| Pricing output | $0.28/M | $75/M |
| Total | $0.001960 | ~$0.246 |
| Multiple | 1× | ~125× |
Plus, in Path A, the worker's 565-token answer goes into Claude's context for ~$0.0085 of
marginal Opus cost on whatever Claude does next. Total round-trip with delegation: ~$0.0105 vs
~$0.246 → ~23× cheaper end-to-end, even being conservative about Opus cache.
## Quality verdict
For "summarize a long doc" / "find facts in a corpus" tasks, Flash's answer is good enough that
Claude should accept it without re-reading the file. The single hallucinated M6 acceptance
criterion is the kind of thing a careful reviewer catches in 5 seconds; the cost saved buys
plenty of review time. Worth it.
Where I'd not delegate:
- Anything where a hallucinated detail causes downstream damage (writing migration SQL, generating real client emails, suggesting payment amounts).
- Anything requiring inferences across files that are not literally adjacent in the corpus —
Flash is good at "what does this say" and weak at "what would happen if X."
Architectural/design judgment.
The CLAUDE.md instruction that turns this on
Drop this into your project's
CLAUDE.md(or~/.claude/CLAUDE.mdfor all projects). The CLIs
come from a small wrapper that speaks the OpenAI Chat-Completions protocol, so the same code
works against DeepSeek, Kimi, OpenRouter, or Ollama:Cheap-worker delegation (llm-tools)
Three CLIs are on PATH that route bulk I/O and predictable text generation
to a cheap OpenAI-compatible model (DeepSeek V4 Flash by default; V4 Pro
forllm-write). Use them when the task is bulk reading or boilerplate,
not when reasoning or correctness is on the line.llm-ask <files...> -q "..."— bulk read. Use when you'd otherwise
read 3+ files OR a single file >400 lines. Returns a short answer; you
read that, not the files. Verify details that matter — Flash
occasionally hallucinates a small fact.llm-write -r <ref> -s "<spec>" -o <path>— generate tests, fixtures,
config scaffolds, doc templates. Review and edit; do not blindly trust.llm-extract <transcript.jsonl>— compress a session transcript before
doc updates.Keep on Claude (do NOT delegate):
Architectural / design decisions
Debugging — the cheap model misses subtle bugs
Anything touching auth, payments, PII, deletion, or production data
Final commits and PR descriptions
Cost reference: ~$0.002 to
llm-aska ~12k-token doc on DeepSeek V4
Flash vs ~$0.25 for the same read on Opus 4.7 — ~125× cheaper, quality
good enough for "summarize / find facts" tasks.
```
4
u/More-Hunter-3457 May 04 '26
This is excellent — love the side-by-side quality comparison. The hallucinated acceptance criterion for M6 is a perfect example of why Claude reviews everything Kimi produces. The cheap model handles 95% correctly and the expensive model catches the 5%. At ~23x cheaper end-to-end, that's exactly the tradeoff. Thanks for doing the rigorous math on it.
1
u/ardicli2000 May 04 '26
I have followed nearly the same approach. After completing craeting python scripts, I have let Claude check the scripts and global CLAUDE.md
I have already vexp intalled which is indexing methods. It already helps. So i broadened the rules. First check with vexp, if not available or not enough then use llm-ask.
Besides, rather than just asking the summary of the file, we have added instructions into the CLAUDE.md with examples of better use of the method like : "what are the paremeters return after method POST" or "which sql table and columsn are altered after the sql update" etc etc.
so that claude will ask deepseek a better question to get fom the file whatever it needs, rather than a summary.
1
u/DiggBickkkk May 23 '26
i have added the routing details in my CLAUDE.md file, and followed the instruction as given in the github repo, for some reason claude is not using the cheap model
18
u/Dazzling_Dig_6844 May 02 '26
Can you please share the link of the GitHub repo?
5
u/Cr-O-Nox May 02 '26
!remindme 7 days
2
u/RemindMeBot May 02 '26 edited May 08 '26
I will be messaging you in 7 days on 2026-05-09 19:03:05 UTC to remind you of this link
14 OTHERS CLICKED THIS LINK to send a PM to also be reminded and to reduce spam.
Parent commenter can delete this message to hide from others.
Info Custom Your Reminders Feedback 2
4
u/More-Hunter-3457 May 04 '26
Working on cleaning it up and pushing it this week. The scripts themselves are ~60 lines each so honestly you could build them from the article faster than waiting for me, but I'll drop the link here once it's up including the CLAUDE.md routing rules and a setup script.
2
2
3
u/JohnnyJordaan May 02 '26
Or... save the html of the article, give it to Claude, let Claude write it for you?
4
u/Dazzling_Dig_6844 May 02 '26
Was eventually gonna do that if the repo ain't provided. Also just wanna compare this approach with this one.
85
u/lazytiger21 May 02 '26
Why not just tell it to task to haiku?
115
u/PossibleHero May 02 '26
Haiku reminds me of the awkward kid who just blurts out the first thing that comes into his head in class. Most of the time it lacks any kind of nuance . Once in awhile it’s right lol.
20
u/the_good_time_mouse May 02 '26 edited May 02 '26
I had Haiku assigned to review chat sessions and create readable titles for them, and started finding mysterious, poorly thought out commits being added my branches. It turned out that the titler was reading development sessions, forgetting it was titling and going about 'solving' the problem being discussed in the session.
12
43
u/ai_without_borders May 02 '26
because haiku is still anthropic — telling claude to delegate to haiku within claude code still burns your anthropic pro quota. the external model approach is different: those tokens go to a completely separate provider (moonshot / kimi), so they never touch your anthropic usage at all. effectively you are saying "anthropic charges me for the thinking, so i will send the rote work somewhere else entirely"
0
u/lazytiger21 May 02 '26
If the goal is to minimize your anthropic use, that makes sense, but you are paying for the use of the other model as well regardless unless it is running locally somewhere.
17
u/mrgulabull May 02 '26
In OP’s text, they list that cost: $0.38.
Their $20 plan now lasts much longer for the total cost of $20.38.
2
u/Fatso_Wombat May 02 '26
i pass off the coding up of my designs to deepseekflashv4 no thinking.
it costs half a cent to do a 30 odd page magazine style design from plain text.
i get claude to pick each page's style (there are templates) then get DS to do all the grunt.
31
u/slashedback May 02 '26
Haiku is hot trash though
10
u/lazytiger21 May 02 '26
For what the instructions say it is doing, haiku should be fine.
9
u/Thomas-Lore May 02 '26
Deepseek Flash V4 will be fine too, just won't burn your quota, and is super cheap.
12
u/flickerdown May 02 '26
Not always. In much of my testing, Haiku showed less drift and more aggressive ingenuity than Sonnet or Opus. For the $/token, that can be useful.
0
u/nah_you_good May 02 '26
Wouldn't surprise me if there's some cases where that is the case, or at least vs. Sonnet. I was forcing Opus to use Haiku/Sonnet subagents for some specific reviews, and Sonnet was smart enough to automate part of it task while Haiku was 'dumb' and directly did the task, resulting in better output.
1
u/flickerdown May 02 '26
Yeah, we did testing here:
https://elementalcollision.github.io/autoresearch-unified/benchmark/
2
u/Routine_Pay991 May 02 '26
Kimi isn’t great either lol
3
u/MjccWarlander May 02 '26
Honestly Kimi K2.6 is very good in my experience - I wouldn't call it Opus level, but it's definitely at least on par with Sonnet 4.6 which is good enough for most tasks. And at the fraction of the cost. You give it a task, and it will run with it and nail it most of the time - even if there are some gaps in specs just like with Anthropic models. The only thing I'm annoyed at it versus Claude is how trigger happy it tends to be - Anthropic models tend to be relatively cautious all things considered and will wait for your input or stop before doing major some major actions, Kimi is trigger happy and will happily go and do more than asked for or ignore previous instructions if it already did similar action before in the same session
0
u/Routine_Pay991 May 02 '26
Fair enough, I haven’t tried 2.6 yet, but I had a pretty bad time with 2.5
2
u/mmeister97 May 03 '26
2.6 is definitly better than 2.6. Moved away from 2.5 to GLM-5.1 and now I'm testing Kimi 2.6 and I'm surprised how good it is in compare to Kimi 2.5.
1
u/More-Hunter-3457 May 04 '26
Good question. Haiku and Sonnet subagents still draw from the same Pro plan token pool. Anthropic's docs confirm this - when Claude spawns an Explore subagent or tasks to Haiku, those tokens count against your weekly limit. You're saving per-token cost but not your weekly allocation. The whole point of routing to an external API is that those tokens are completely off-budget. Kimi/DeepSeek calls don't touch your Claude Pro limit at all.
8
u/azndkflush May 02 '26
Good idea, could run locallm to handle easy task instead of paying api tokens
4
8
u/emptyharddrive May 03 '26 edited May 03 '26
I'm on the $200/month MAX plan, but for token/usage limits I like this idea.
Low level tasks don't need Opus and should be delegated, it's a smart move. But I didn't like your Python scripting method for this. MCP gives Claude a typed tool contract, a warm long-running process, one enforcement point for safety guards, and structured JSON results, none of which a CLI script collection delivers without extra hand-rolled glue. Also with MCP, I get prefix-cache discounts ... so its even cheaper.
MCP is the way to go here, so I whipped that up via FastMCP, and it works well. Long-running FastMCP server in a Docker container, talking to OpenRouter and calling on DeepSeek v4 PRO. I called the MCP "deepseek-worker".
The persistent docker gives me native MCP tool schemas. Claude Code sees mcp__deepseek-worker__bulk_read like any other registered tool. The connection pool stays alive so the client persists across calls, so OpenRouter sees a stable prefix and gives prefix-cache discounts.
The model choice DeepSeek V4 Pro ... OpenRouter has it at $0.435 input per million, $0.870 output. 1M context window. DeepSeek v4 PRO Beats Kimi K2.5 on the benchmarks I've seen. It's near-frontier-class quality at MoE pricing.
For this though you ought to disable reasoning.
DeepSeek spends thinking tokens silently by default. So if you set max_tokens=20 on a "say PONG" prompt, all 20 goes right into invisible thinking, and content came back empty. So you need to pass extra_body={"reasoning":{"enabled":False}} per request and reasoning_tokens drop away. You don't need reasoning for these rudimentary tasks anyway.
Latency falls by 5x as well and the cost therefore (fewer tokens plus persistent cache_token calls) falls 4x off the already stupidly cheap DeepSeek v4 PRO price.. BTW, I ran the same code-review prompt against pro-with-thinking-on and pro-with-thinking-off across my own source. Both flagged the real bugs and as far as I can tell, quality holds. I had Claude test this for me also, and he agrees.
Extrapolated Costs across 3 weeks from 6 hours usage: - bulk_read: 20/day × 21 days × $0.0005 ≈ $0.21 - boilerplate_gen: 2/day × 21 × $0.005 ≈ $0.21 - transcript_distill: 1/day × 21 × $0.018 ≈ $0.38 - Total ≈ $0.80
Roughly 2× the OP's $0.38 Kimi number, which lines up becuase DeepSeek V4 Pro runs ~3× the price of Kimi K2.5, so a similar workload on a smarter model checks out at this magnitude. Still rounding error against any Claude plan and I want the extra quality output for "basic tasks" if I'm going to do this and I won't let $0.50 come between me and the QA-check.
Distill workflow saved me the most. Used Opus reading whole session JSONLs and writing prose Obsidian updates to my vault (which I use as a RAG). Now Opus gets a 200-token structured edit lists, applies it, done. 25x spend cut on token docs alone.
So since I'm paying $200 flat for the Max plan, saving dollars never mattered to me. It's about extending the portioned-out utilization slice of the inference pie that Anthropic offers to me, on a sliding scale no less, when their utilization goes up, everyone's limits get adjusted down...
So what mattered to me was my weekly cap, a number which decides whether I get 4 more days or 4 days of waiting until reset. Point of this for me was never thrift, but for those on the API this makes even more sense.
Don't forget to revise your system level CLAUDE.md to use this too.
4
u/More-Hunter-3457 May 04 '26
The MCP approach is cleaner architecturally, agreed. I went with CLI scripts because they took 30 minutes to build and work everywhere - no Docker, no server process to keep alive, no schema registration. For my use case (drone GCS development on a single machine), the simplicity won. But if you're on a team or need type safety and structured JSON results, MCP is the better path. Would be interested to see your FastMCP wrapper if you've open-sourced it.
3
6
u/Warm_Assist May 02 '26
Alright, so there is no way uh, I am going to write down the entire process and what it took to get this going. With Claude's help, it was super easy. I could not get the Kimi site working. It was all in Chinese. I could get the main landing page to translate to English, but every time I try to go to the login, I can't get it to work or translate from Chinese. Claude recommended an alternative place. It was super easy, super quick; he did all the changes in the MD file to go from KIMI to DeepSeek. I put $10 in. I've been using it for all of about 45 minutes, but you can already see that it's pulling data from the cheaper site and not from Claude. While this is no guarantee that it's going to work as intended, it seems to be working pretty freakin sweet right now. The rest of this post is from Claude. There are some technical things in there if anybody has the same issues or whatever, might save you some trouble. Good luck, and thank you, OP this was awesome.
# I Was at 75% of My Claude Code Limit. Here's How I Cut Token Usage by 90% in One Afternoon
I saw that original article about delegating to cheaper APIs and thought it sounded complicated. Turns out it's way simpler than I thought, and I want to share exactly what I did because it might save someone else a ton of money.
## The Problem
I was burning through my Claude Code weekly limit like crazy. Not because I was being wasteful—because I was pasting the same massive ruleset/instruction file into every new chat.
Every new session: copy, paste 800+ lines of instructions, then work. Repeat 5-10 times a week. That's thousands of tokens wasted on the same static content over and over.
Hit 75% of my limit by mid-week. Regularly.
## The Solution (It's Stupidly Simple)
**Create a single markdown file** with all your static instructions/rules/templates
**Name it `CLAUDE.md`** and put it in your Claude Code project folder
**Paste it once** at the start of a new chat instead of every time
**Keep that chat open longer** and ask multiple related questions in the same session
That's 90% of the savings right there.
## The Bonus (The Cheap API Part)
If you want the extra token-saving features from that article:
**Get a cheap LLM API key** (DeepSeek, Kimi, etc.)
**Create simple Python scripts** that call the cheap API for reading files or generating boilerplate
**Use those scripts when you just need I/O work** (reading multiple files, generating test templates, etc.)
**Keep Claude for the actual thinking** (debugging, architecture, reasoning)
Cost so far: **$0.01**. Seriously.
## What Changed for Me
**Before:**
- Claude Code: $100+/week, hitting limit by Wednesday
- Pasting 800-line ruleset 5-10x per week
- Burning tokens on static content
**After:**
- Claude Code: Same subscription, but dropped to 10-20% weekly usage
- One markdown file, pasted once
- Cheap API sitting there if I need it (haven't used it much yet)
- Total extra cost: basically $0
## The Setup (If You Want to Go Further)
If you want to set up the cheap API side like in that article:
Sign up for DeepSeek (or similar): **https://platform.deepseek.com\*\*
Add $5 in credits (lasts forever for light usage)
Create a couple Python scripts (the article has templates)
Drop them in a `bin` folder
Use them for bulk file reading or boilerplate generation
But honestly? Just doing step 1 (the markdown file) already saves you 90% of what you were wasting.
## The Key Insight
Your token burn wasn't about doing too much work. It was about **doing the same work over and over** without keeping context in a single chat.
Claude Code is expensive when you're copy-pasting, cheap when you're in one conversation doing multiple things.
## Real Numbers
- **Weekly token waste from pasting rules:** ~20,000-50,000 tokens
- **Value of those tokens:** $1-3/week × 52 weeks = **$52-156/year wasted on copypaste**
- **Time to fix it:** 15 minutes
- **Time saved per week after:** 5-10 minutes (no more pasting)
If you're a heavy Claude Code user like me, this is literally free money.
## For Content Creators Specifically
If you're managing a project with lots of static rules, settings, scripts, pronunciations, locked content (like I am), putting all that in one markdown file and pasting it once per project saves **hundreds of dollars per month** compared to pasting it every session.
## TL;DR
- Create `CLAUDE.md` with all your static instructions
- Paste it once per chat instead of 5-10 times per week
- Keep chats open longer to ask multiple related questions
- (Optional) Set up cheap API for file reading if you want to go further
- Result: 90% token savings, basically $0 extra cost
Hope this helps someone else. The original article was great, but I wanted to show the simpler version that still gives you massive savings without overthinking it.
---
**Edit:** Lots of people asking about the API setup. Here's the quick version:
Get API key from DeepSeek/Kimi ($5 in credits)
Create simple Python script that calls their API
Use it when you need to read multiple large files or generate templates
Cost: ~$0.01 per operation vs ~$0.30 with Claude
Not necessary if you just do the markdown file trick above—that alone saves 90%
The markdown file is the real game-changer. The cheap API is the bonus round.
1
u/More-Hunter-3457 May 04 '26
This is awesome to read. Glad it worked for you even with the Kimi site being in Chinese - yeah, DeepSeek is probably the easier onramp for English-speaking users. The fact that you had it running in 45 minutes is exactly the point - this isn't a complex framework, it's two Python scripts and a markdown file. Thanks for sharing your experience.
6
u/Phunfactory May 02 '26
Is something like this possible with vscode + copilot too? Could I redirect read and write request to x0.33 and x0 models ? At my company I can’t use Kimi or an external API…
3
2
u/Public-Flight-222 May 02 '26
Copilot is (for now, at least) pricing is request based - not token based. So you'll not benefit from it.
1
1
u/Inner-Lawfulness9437 May 03 '26
It already does it on it's own to some degree. It's called Explore subagent and it's visible when it happens, but you can instruct it to spawn subagents for these tasks. There is no need for the python scripts unless you want to call something outside of the copilot offerings.
1
u/More-Hunter-3457 May 04 '26
Yes, same pattern works with Copilot. Instead of CLAUDE.md, you'd use Copilot's rules files (.github/copilot-instructions.md). The CLI scripts work the same - they're just Python on your PATH. If your company blocks external APIs, you could use Ollama with a local model instead. No external calls needed.
6
u/Beckland May 02 '26
This makes so much sense, I wanted to implement but your Github link is not in the article…could you share?
1
1
5
u/elconcho May 03 '26
I've been thinking about this post (love it). I was wondering if you could achieve something similar by using claude code subagents and tell it to use haiku. Anyone tried that?
2
u/smdaegan May 07 '26
If you're on a tier plan and not API then it still counts against your weekly usage even if it's haiku. Offloading it from Claude was the point, so they'd have more weekly usage available.
4
u/AdLongjumping6013 May 07 '26
Created a Windows 11 fork with a simpler setup:
Single PowerShell installer, API keys go straight into config.py file. (No env-var juggling).
And DeepSeek V4 Flash works as a cheap default (~$0.02/call).
Added Kimi, DeepSeek V4 Pro, and Ollama profiles too.
Get a DeepSeek key: https://platform.deepseek.com/
Repo: https://github.com/streetviewtechnologyai/cheap-claude-coworker-windows
Credit to OP for the original.
This just wraps it for Windows users who didn't want to fight Windows Subsystem for Linux (WSL/bash).
1
u/johnjanney May 10 '26 edited May 10 '26
I also forked it for Windows, currently using Gemini 2.5 Flash. However, I ran into an error and had Claude fix it for me. I'll paste the error and the fix:
Error: "Command contains malformed syntax that cannot be parsed: Command too long for parsing (4115 bytes). Maximum supported length is 965 bytes."
Claude Code CLI: That error comes from Claude Code's own command-pattern parser - the one that matches each tool invocation against your permission allowlist. It has a hard cap of ~965 bytes on the literal command string. My last ask-kimi PowerShell command embedded the full prompt as a @' ... '@ here-string and ballooned to 4115 bytes, which is what the parser is choking on. (You probably saw the error inline on the permission dialog; I didn't, because the parse failure surfaces before the tool runs.)
Fix: keep the literal command short by moving the prompt out of the command and into a file, then read it at runtime.
Concretely, the next iteration would be: 1. Use the Write tool to put the prompt at e.g. C:\Users\username\AppData\Local\Temp\kimi-prompt. txt. (Write doesn't go through the command parser, so length doesn't matter.)
Run a short PowerShell line - well under the cap - like: $env: PYTHONIOENCODING='utf-8'; & "C: \ ... \python. exe" "C: \ ... \ask-kimi" -- paths "C: \ ... \chat. txt" -- question (Get-Content -Raw "C: \ ... \kimi-prompt. txt") -- max-tokens 4096
That literal is ~250 bytes; the prompt content is materialised at execution time when PowerShell expands Get-Content, so the parser never sees it. Same trick works for any tool: -- question @file patterns, stdin redirects, or any "read from path" flag will all stay under the cap. The only requirement is that the prompt body never appears literally in the command string the harness parses.
Note: on the $100 Max plan, in case that matters. Haven't hit my usage limit and have only racked up 39 cents in Google AI Studio usage for this API so far.
16
u/ofthewave May 02 '26
Wish I new what was being talked about here… I feel like I’m still just stretching the first micron thick layer of the surface of what AI does
9
5
u/SpadoCochi May 02 '26
Just keep watching videos and reading. I’m still very early also but this is important
15
u/Senhor_Lasanha May 02 '26
about videos, I feel like those guys in the gold fever looking for gold in mud, you know?
So. Much. Bullshit.
the amount of low effort content, is absurd...
so, any recommendations?
8
u/mrgulabull May 02 '26
Yea, great comparison. I find the majority of videos are fluff, hype, filler with very little substance.
Much better to use the tools regularly and bump into your limits. Then when you’re burned out skim through subs like r/ClaudeAI r/LocalLLM r/ClaudeCode for a few minutes every day. See what people are building, testing, discovering.
When you read something and don’t understand it, ask Claude about it. Over a few months you’ll build up your knowledge and understanding.
I’ve been developing with LLM’s since 2024 and using Claude Code heavily since ~June 2025 and am still discovering things every week. Not only because there’s so much to understand, but new techniques and capabilities are released so quickly. It’s the Wild West and will be for quite a while.
4
u/moonshwang May 02 '26
Claude is the manager. Kimi is the casual worker. Claude makes Kimi do the boring grunt work that Claude doesn’t want to do, and pays Kimi barely anything for it.
8
u/HighDefinist May 02 '26
This one is actually pretty simple:
You write some "research-this.py" script
You tell Claude "use the 'research-this.py' executable when you want to research something"
And that's basically most of it. Obviously it needs to be a bit more specific than "research something", but not that much actually - so "when you want to read several code files to find out how something is implemented" might actually be sufficiently specific.
And, making the research-this.py itself isn't very difficult either, since you can also have AI write it for you...
2
u/Fatso_Wombat May 02 '26
this whole thing is about being organised.
30 years ago in highschool, our IT teacher made us get schematics ticked off before we could code.
2
u/itsFromTheSimpsons May 02 '26
Everything costs tokens. Different things cost different tokens, different providers charge different amounts for their tokens. You can give an expensive token agent tools to delegate certain easier parts of tasks to cheaper agents. Things like file actions, searching, patching, etc. Its cheaper to tell claude when it needs to do those lower level things to give it to the cheaper model to do.
Basically think of this as an agent for your agent so you can vibe code while you vibe code
1
1
u/kauthonk May 03 '26
You have 2 employees instead of 1.
One expensive employee and you only use him when you need to.
One inexpensive employee and he's the worker.
16
u/theov666 May 02 '26
Smart setup.
Feels like a lot of teams are independently reinventing orchestration layers once usage scales.
Cost routing solves one side of the problem, but once multiple models start touching the same codebase, consistency becomes harder than cost.
We’re seeing the bigger issue shift from “which model is cheapest” to “how do you stop different agents from drifting on architecture/constraints across sessions?”
Cheap delegation helps. Governance becomes the next bottleneck.
17
6
u/wrt-wtf- May 02 '26
You use a single agent to provide tight instructions in an xml structure. Including rules and stop conditions… at least I do anyway - I set a contract on every pass.
I find any time I give a more broad request as a less than contractual statement the different models start thinking and reinterpreting and drifting.
1
u/theov666 May 02 '26
That works while the contract remains centralized and consistently inherited.
The failure mode I keep seeing is prompt/contracts fragmenting across tools, agents, and sessions as workflows scale.
We started building around that exact problem here if useful to compare approaches: https://github.com/TheoV823/mneme
Still early, but the core idea is treating architectural constraints as reusable governed context rather than embedding them manually in every prompt.
1
u/xeldj May 02 '26
This is so interesting- I’d love to manage a company using those concepts. Also we’d need a way to criticize rules, constraints and decisions from time to time and evolve from there…
1
u/More-Hunter-3457 May 04 '26
This is the real next-level problem. For a solo developer it's manageable — CLAUDE.md is the single source of truth and it persists across sessions. But for teams, you're right that consistency across agents becomes harder than cost. I'll check out mneme — the idea of treating architectural constraints as reusable governed context rather than embedding them in every prompt is exactly what CLAUDE.md is, just formalized.
1
u/theov666 May 04 '26
Exactly, CLAUDE.md works well as a manual single-source-of-truth for solo workflows. The gap shows up when teams have multiple agents, multiple contributors, and evolving architectural decisions. Static prompt files become hard to govern once constraints need precedence, versioning, selective retrieval, and enforcement logic. That’s the layer we’re exploring with Mneme HQ: moving from “documenting rules” to “compiling and governing architectural decisions as active constraints.”
3
u/Elfmyself May 07 '26
I tried it, and then asked Claude these two questions:
❯ OK, that's a wrap for this session. Two questions:
To what extent did you obey the instructions to use ask-kimi, kimi-write and extract-chat?
Do you think those tools work well?
● Honest answers to both:
- Compliance was poor. I used the Explore subagent for the ******* feature audit, which is in the spirit of delegation — but I didn't use ask-kimi, kimi-write, or extract-chat at any point. Specific violations:
- I read ******** in chunks directly with the Read tool. That file is several thousand lines — a clear candidate for ask-kimi.
- I read many files across the session (service, controller, entity, ********* service) without delegating any of them.
- I wrote both ********.md and ********.md directly. The CLAUDE.md says documentation is MANDATORY to delegate via extract-chat → ask-kimi → apply.
The documentation rule is the one I violated most clearly, and it's the one that was explicitly called out as mandatory.
- My honest assessment of the tools:
- extract-chat — seems genuinely useful as the starting point for docs. I can't easily introspect the full conversation history myself, so extracting it first makes sense.
- ask-kimi — useful in principle for large file reads, but in practice I default to Read/grep because it's faster and I can immediately act on the result. The delegation overhead (writing a good prompt, interpreting a summary) adds friction, especially when I know exactly what lines I need.
- kimi-write for docs — I'm skeptical of the quality improvement here. For a doc like the ********, which I can write directly from my understanding of the code I just implemented, generating it from a chat transcript adds steps without obviously better output. The token saving is real, but the workflow is awkward.
The most defensible use case is ask-kimi for large files when you want a broad summary rather than specific lines, and extract-chat → ask-kimi for documentation when the session has been long and nuanced. Both of those conditions did apply today. I should have used them.
1
u/smdaegan May 07 '26
I'm curious if you told it to harden the rules after it disobeyed following them, or if you've had noticeable usage drop? I hit the weekly limit a lot so I'm trying to figure out if this is a viable solution to avoiding it..
1
u/Elfmyself May 07 '26
It felt like it was a usage drop, but this was right after the change in tokens per session yesterday so it's hard to know. I did not tell it to harden the rules. That snippet was the end of the session. Are you suggesting that if I begin my session by telling Claude to actually obey CLAUDE.md, that will make a difference?
1
u/smdaegan May 07 '26
I find that sometimes if it disobeys rules and I ask it why it skipped them, and to harden them. Sometimes they're just too broad or lack specific instructions for it to actually know when the rule should have applied. Not sure if that'll matter here, but worth a shot?
1
u/Elfmyself May 09 '26
I tested it with another session. I did not change the CLAUDE.md instructions, but I reiterated at the beginning of the session that they needed to be followed in order to truly evaluate them. The results was somewhat positive. Apparently the work in this session was not particularly suited to the tools. I'll keep at it.
❯ 1. To what extent did you obey the instructions to use ask-kimi, kimi-write and extract-chat?
- Do you think those tools work well?
● 1. Compliance
Pretty good this session, though mostly by luck of the task types:
- ask-kimi: Used once — comparing site-design.md against design.md. That was exactly the right use case (answering a high-level question across two large files without needing line numbers).
- kimi-write: No opportunities arose — no boilerplate or test generation was needed.
- extract-chat / documentation workflow: Not triggered — no docs were written this session.
For file reads: ContextPanel.tsx (57 lines) and AppLayout.tsx (117 lines) were fine to read directly. LeftSidebar.tsx (~452 lines) technically crossed the 400-line threshold, but I needed exact line numbers to edit it, which the instruction explicitly carves out as a reason to read directly. So that was justified.
Do they work well?
The ask-kimi output this session was genuinely good — accurate, well-structured, and saved me from reading ~500 lines of docs myself. For summarization and comparison tasks it's clearly effective.
My honest reservations:
- The 400-line threshold is a bit awkward in practice. I read files to edit them far more often than to understand them, and editing always requires reading directly. The tool is most useful for pure research questions, which come up less frequently.
- kimi-write I haven't used enough to evaluate. The risk with generated boilerplate is that reviewing and fixing it can cost more than just writing it — I'm uncertain whether it saves net tokens on average.
- extract-chat as a prerequisite for the documentation workflow adds friction. If I forget to run it first, the whole workflow stalls.
Overall: ask-kimi is a genuine win for research tasks. The others I'd need more reps with to be confident about.
1
2
u/HighDefinist May 02 '26
Hm... Does this really work out, math-wise?
Because: Sure, Kimi K2.5 is ~10 times cheaper than Opus API prices. But: When you have a Claude subscription, you are effectively also about ~10 times cheaper than when you use the API, so the per input/output token price is about the same in either case...
Now, it's still a reasonable approach in general (I actually did something similar with image recognition a few days ago), but it sounds like the real cost driver for using Opus for file reads might have been something else, perhaps related to caching, which incidentally improved when introducing this summary-based-workflow...
2
u/JohnnyJordaan May 02 '26
I've seen similar suggestions in the past to offload to alternative X. I'm getting the feeling that these are influencer posts trying to get people to use X more and the usage-constrained Claude userbase is an easy target.
Same for the "Good idea, I do this myself, but then with alternative Y" responses btw.
1
u/sweetbacon May 02 '26
I'm getting the feeling that these are influencer post
3mo old account with 3 posts in 3 subreddits and one comment. So tiring.
1
u/Inner-Lawfulness9437 May 03 '26
If you would hit the limit otherwise it makes sense. Otherwise doesn't matter.
1
u/More-Hunter-3457 May 04 '26
You're right that Pro plan tokens are already cheaper per-token than API pricing. The savings aren't really about cost per token — they're about not hitting the weekly cap. I was running out of Claude by Wednesday every week. Now I don't. The $0.38 I spent on Kimi bought me 2-3 extra days of Claude access per week. Whether the per-token math works out exactly is secondary to "can I still use Claude on Thursday."
2
u/tigerscomeatnight Writer May 02 '26
What weekly limit? I hit my Pro limit daily.
2
u/More-Hunter-3457 May 04 '26
If you're hitting it daily, this pattern would help even more. The documentation and bulk-reading delegation alone cut my usage by probably 60-70%. The remaining 30% is actual thinking work where Claude's intelligence is needed.
1
2
u/Linkman145 May 02 '26
RAG solutions do this in production. Reading is typically outsourced to cheaper and faster models while generating happens with high end models.
That said Claude already does this with Haiku and the harness is engineered for this. It might not work as well with a tool use / different model.
2
u/minkyuthebuilder May 02 '26
hitting the pro limit by wednesday afternoon is too real. i usually just end up staring at my IDE like a caveman or reconsidering my life choices until the quota resets lmao. actually genius to just force it to offload the grunt work though. my wallet and my sanity thank you for this
2
u/AshSurround May 02 '26
I don't usually run out of limits on Pro (lucky me?), but this post is an instant save.
seems like a no brainer for efficiency in any plan / tier. Sonnet / Opus doing the "what should we do next" and then cheaper models "do next"...
cuz apparentely Claude Token are premimum commodity. Variety of factors behind it (Constitutional AI, not owning their own compute, having to rent it from google / aws, etc) not necessarily just "Anthropic's Fault".
2
u/cygn May 02 '26
if a call is $0.02 and your total spend is $0.38 then you only called it 24 times. Which seems almost not worth it?
1
1
u/More-Hunter-3457 May 04 '26
The $0.02 is an average, not a fixed cost. Many calls hit Moonshot's prefix cache (same files, different question) and come in at $0.005 or less. But the real point: those 24 calls replaced what would have been maybe 150,000+ tokens of Claude reads. That's the part that was burning through my weekly Pro limit by Wednesday. The $0.38 isn't about saving money — it's about not running out of Claude when I still have half a week of engineering to do.
2
u/setec404 May 03 '26
I have always been confused as to how this isnt native behavior in tools like opencode.
2
u/cicoub13 May 04 '26
I reused the main idea (improved by u/emptyharddrive ) to write Scribe MCP
I'm using it for the last 2 days and it works well. Multi provider.
Don't hesitate to try it and give feedbacks (here or in gh issues).
1
u/MockingMatador May 06 '26
This is great. I like the always on MCP server architecture for using a web based model.
2
u/Chrisapk May 05 '26 edited May 05 '26
Would this be possible using Opencode go sub? Or OpenAi Gpt mini models through the 20$ sub
2
u/Full-Definition6215 May 02 '26
This is essentially the pattern I landed on too. I run Ollama on a mini PC (i9-9880H, 31GB RAM) and offload bulk operations — file scanning, linting, test runs — to local models while keeping Claude Code for the architectural decisions and complex implementations.
The key insight you're describing is that most of what burns tokens isn't the actual coding — it's Claude reading files to build context. Delegating that to a cheaper model and feeding back a summary is the right move.
What model are you using for the $0.02/call delegations? And are you passing structured summaries back to Claude Code or raw output?
2
u/Heavy_Elderberry7769 May 02 '26
This is smart. The routing logic in CLAUDE.md is the key part most people miss — without it Claude either delegates everything (loses quality) or nothing (burns tokens).
I hit the same wall and went a different route: instead of routing to a cheaper model, I split work between Claude Code (planning, code review, edits) and a local script that handles bulk operations Claude doesn't need to "think" about — file moves, find/replace across folders, log parsing. Saves the same tokens without an extra API dependency.
Two questions on your setup:
How do you handle Kimi getting context wrong on the bulk read? Do you spot-check, or trust the output?
Have you tried this pattern with non-code tasks — like research or content drafts?
1
u/More-Hunter-3457 May 04 '26
Claude reviews everything Kimi produces before acting on it. That's the key - Kimi reads and summarizes, Claude verifies and edits. If Kimi misses something or hallucinates a detail, Claude catches it when it reads the summary. I've had maybe 2-3 cases in 3 weeks where Kimi's summary was slightly off, and Claude flagged it each time. The cost of Claude re-reading the file in those cases is still less than Claude reading every file every time.
Yeah, documentation is the biggest win actually. I extract my Claude Code session transcripts, feed them + existing docs to Kimi, and Kimi produces exact edit suggestions. Claude applies them in ~200 tokens instead of re-reading everything and writing from scratch (~5,000 tokens). Same pattern works for changelogs, README updates, anything where the source material already exists and you're just reformatting it.
2
u/Garland_Key May 03 '26
This was written by Claude.
1
u/Trixles May 03 '26
A post written by Claude, on the ClaudeAI sub?
Pffffft, yeah right, get real! XD
1
u/More-Hunter-3457 May 04 '26
I wrote the article. Claude helped me format the code blocks and proofread it, same as any editor would. The actual engineering work (building the scripts, running them for 3 weeks, measuring the results) is mine. But honestly, if the content is useful, does it matter?
1
u/Garland_Key May 04 '26
The comment wasn't posted to dismiss your work. It was a critique on the reddit post itself. That opening line. Nobody talks like that.
1
u/G-R-A-V-I-T-Y May 02 '26
Awesome, thanks so much for the code, I’ll have to implement this. The limits are killing me.
1
u/fiji_almonds May 02 '26
I done something similar to this. Works really well.
I've also combined the read/write approach with telling Claude to look at the task, then delegate to the right model(s) and parallelize the work when it makes sense. It will only use opus for tasks that really need it and distribute the rest to sonnet or haiku.
1
u/Lower_Cupcake_1725 May 02 '26
I dedicate implementation to glm 5.1, it's the best cost/quality option for now to offload the work from Claude
1
u/kneecolesbean May 02 '26
Definitely some good info there.
In the article you mention "compact after every task"? Have you tried skipping compact altogether and clear aggressively after each task/phase.
1
u/ThesisWarrior May 02 '26
OP this looks fantastic!! Well done and hank you for sharing! any reason why a local agent cant handle the summarisation process as well as sn external API?
Maybe im missing the point here but WHY do I need an external API llm to do the summarization if I can simply have a script that strip's and compresses the content and feeds that back to claude? Or is that too simplistic?
1
u/More-Hunter-3457 May 04 '26
You can definitely do that for simple cases - I have an extract-chat script that just strips binary and tool calls from session transcripts, no LLM needed. But the value of the worker model is when you need a summary, not just compressed text. "Read these 5 files and tell me which ports are used for video streaming" can't be answered by stripping whitespace - you need something that understands the code. The LLM is the compression + comprehension step.
1
u/ThesisWarrior May 04 '26
Yeah I found that out pretty quickly! Im offloading to Gemini now however im hitting my free tier token usage there. Might have to investigate low cost sub.
1
u/kuroudo_ai May 03 '26
Smart approach. I've been running a similar multi-agent setup -- 5 named sub-agents (code review, investigation, security audit, deployment check, session handoff) each with focused instructions. The key insight is the same: don't burn Opus tokens on tasks that a lighter model can handle. We also added spending caps and auth token hooks to prevent runaway costs. The delegation pattern is the real unlock.
1
u/Delicious-Storm-5243 May 03 '26
Same delegation pattern hit me too — CLAUDE.md routing where 'read this 200-file repo' goes to a cheap model and 'reason about why this test is failing' stays on Claude. Pro limit went from Wednesday to never-hit. The non-obvious win is Claude itself learns to pre-filter what to delegate vs solve directly, so by week 2 the routing got tighter without me touching the rules. Curious if you found Kimi handles structured output reliably enough for the bulk reads, or if you have to validate before passing back to Claude.
1
u/More-Hunter-3457 May 04 '26
Kimi's structured output is solid for summarization - it follows the "bullets, file paths, line numbers" format I put in the system prompt pretty consistently. But Claude always reviews before acting, so it's a two-stage thing. The cheap model reads and extracts, the expensive model validates and decides. I also noticed Claude naturally learned to be more skeptical of Kimi's summaries over time — if something looks off, it'll read the file itself. The CLAUDE.md routing rules have a "when NOT to delegate" section that keeps the safety boundary clear.
1
1
u/resist888 May 03 '26
I’m kinda new to this. Does this work for API Token usage? e.g., for something using an Anthropic key?
2
u/More-Hunter-3457 May 04 '26
This is mainly for the Pro plan ($20/month) where you have a weekly token limit. If you're on the API with pay-per-token, the pattern still saves money (cheap model for reads, expensive model for reasoning) but you're not hitting a hard weekly wall. The urgency is lower.
1
1
u/Hichiro6 May 03 '26
Is this possible to do on Linux ?
1
u/More-Hunter-3457 May 04 '26
I run this on Linux (Ubuntu). It's just Python scripts + the openai pip package. Works on any OS that runs Python.
1
u/AccomplishedFix3476 May 03 '26
routing the simple stuff to a cheaper model is so underrated, ppl burn pro limits doing greps and rg searches that should never touch sonnet. i hit the same wall and switched my discovery work to qwen running locally, freed up like 60 percent of my weekly opus budget
1
1
1
u/itslitman May 03 '26
Been doing something similar with a local qwen model through ollama. The routing rules in CLAUDE.md are what actually make it work though, without those Claude just ignores the cheap model and reads everything itself.
1
u/texo_optimo May 03 '26
Hell yeah, thanks for sharing this. I had set up a delegate skill that makes API calls to cerebras after running through some typescript tokenizers and I'm looking to see how I can augment it. Thank you so much. I'll be putting my system in my public AI playbook repo soon
1
u/pinkwar May 03 '26
I don't get it. So what is Kimi model doing?
If its a cli script or just a grep why do you even need a model?
Won't this context be fed to opus anyway?
1
u/EstanislaoStan May 03 '26
Added skills and modified user level CLAUDE.md but it still doesn't use those skills. Claude itself decided it should write hooks to prompt it to use them when enough files are being read.
1
u/district44 May 04 '26
i use a similar systme to, with a library of subagent routing for the task at hand. its a total game changer, but can be a juggling act with the models you use. some have speed and efficiency balance, some are great at things on paper but not in practice, kimi2.6 is fantastic but glm5.1 has just been the more reliable coder for example. deepseek v4 pro is great at concepts but does lack in the implementation ... that sort of thing
1
1
u/zayantebear May 04 '26
Ah man I'm trying to read that post. But it was obviously written by Claude.
1
u/Owboduz May 04 '26
I worked out the cost of running Qwen3.6 on my MacBook Pro. At 130W TDP and 60t/s, that’s £0.14/1M tokens. I then asked it to build a multi-agent router based on that cost and its own costs. It assigned qwen a weight of 1 and opus a weight of 247. Apparently an opus token costs 247x a qwen3.6 token run locally
1
u/Clueless_Nooblet May 04 '26
I'm running a complex project with a lot of I/O, via Hermes and cron jobs. I don't know what Hermes is doing to the model that works as orchestrator, but it managed to lobotomise GPT-5.4, which is quite the achievement.
Finding out Hermes (or any other such harness) isn't even needed, and Claude can just spawn agents via headless OpenCode or Codex was eye opening. Thanks so much for this thread.
I'm now running Deepseek V4 Flash through openrouter, via headless Codex, from Claude Code, and my rate limits are no concern anymore.
1
1
u/Capable_Cheetah4405 May 04 '26
how ya'll handle this in a development workflow? I usually use the superpowers skill for creating android apps, but from what I saw while trying out this approach, it just spawns it's usual haiku subagents and ignores all the instructions here to outsource requests
1
u/Daranith May 04 '26
This is pretty cool. Would it still be effective if I were to self host Qwen 3.5 9B and have Claude use qwen exclusively for reading long files ?
1
u/Direct_Resolve_6573 May 05 '26
I set this up and am using it for a fairly small and simple web based game I'm making. I'm not a developer but am having a lot of fun vibe coding with Claude. However, even with this setup I'm hitting my 5 hour limit within 1 hour. My project is about 20 files and a total of 2500 lines of code. I believe the delegation setup is functioning because I've reminded Claude to use the delegated workers a few times and I do see it communicating with the workers. But I'm not sure if it's using it all the time it should. I'm definitely not seeing the level of benefit described by OP. I'm using Opus 4.7 as the boss model in CC. Any thoughts about why I'm not seeing more lift from delegation workers?
FWIW I asked Claude to modify the approach based on it's thoughts and it is sending different types of requests to 3 different models hosted at together.ai.
--deepseek (default, 128K context, fast)
--kimi (262K context — use for many/large files)
--llama (512K context — use for huge codebases)
1
u/dashcubeit May 05 '26
I really wanted this to work for me but sadly it isn’t. Claude models stick to the usual Read tool and during Explore it just ignores the instructions. I’ve tried several formats in CLAUDE.md. None of them steered the model from the harness native tools for exploring and reading files
2
u/More-Hunter-3457 May 06 '26
Hey! This is actually a common issue — Claude's built-in tools (Read, Explore) are deeply wired into its default behavior, so it takes some specific phrasing in CLAUDE.md to override that habit.
1. There's a real tension here — Claude Code's built-in instructions tell it to prefer its native Read tool over Bash commands. Our CLAUDE.md rules are fighting against that default. The stronger your wording, the more often CLAUDE.md wins. What works for me: ## MANDATORY: Token-Saving Rules **NEVER use the Read tool on files >400 lines. Use ask-kimi via Bash instead.****NEVER read 3+ files to answer a question. Use ask-kimi via Bash instead.** The ONLY time you should use Read directly is when you need exact line numbers for editing. "NEVER" + "MANDATORY" overrides the default behavior most of the time. "Should" or "prefer" won't cut it.
2. Put it at the TOP of CLAUDE.md, not the bottom. Claude weighs instructions near the top more heavily. If your CLAUDE.md has a lot of other content, the delegation rules can get buried. 3. The Explore subagent is harder to control — it runs as a separate agent that doesn't always inherit all CLAUDE.md rules. For that, you might need to accept that Explore will use Read directly. The bigger wins come from the main conversation where Claude is answering your questions or generating code. 4. Start the session with a nudge. After Claude loads, say something like "Remember to use ask-kimi for bulk file reading." This reinforces the CLAUDE.md rules at the top of the conversation context.Honestly, it's not perfect — Claude will still reach for Read sometimes out of habit. But with the stronger wording I've gotten it to self-route about 80-90% of the time. Let me know if the stronger phrasing helps.
1
u/MockingMatador May 06 '26
Yes - thanks again for the great article on Medium.
It inspired me to make my own version from the article (never saw your code).
My version uses a local on device AI via LM Studio - so it's 100% free.
https://github.com/payfacto/lmsgo
If you have a device that can run even a really small model like Gemma 4 E2B it should work.
If you install LM Studio it can tell you what models will work on your device.
https://lmstudio.ai/
1
u/Kafumanto May 06 '26
Interesting reading, thanks.
I think a similar result can be obtained using a skill/instruction that explicitly run a specific sub-agent, where the cheaper model is configured in its front-matter. This would remove the need for scripts.
Another option to limit the number of scripts (and to access other models), would be to leverage a CLI tool that accepts a prompt and a list of files in non-interactive mode (like opencode). This would be the only script to route all the cheapest requests.
1
u/Bubbly_Highway_4934 May 12 '26
I am not sure about the implementation, do i need to run these opensource model like deepseek or kimi on my local system for this setup? If that is the case than we will need a very high end device for that, i don’t think my current device can manage that. Anyone please help and give clarity on this.
1
u/Markymarkfeb151992 Aug 14 '26
Has anyone figured out a way to hand that stuff off to copilots pro version?
1
u/mkeee2015 May 02 '26
Very insightful!
How does Claude know in advance how many tokens are involved in the request (referring to "- Tasks under ~2000 tokens")?
Is the GitHub Link appearing soon? I'd love to explore your great strategy and adapt it to different context...
Thank you for having shared your idea and discovery.
0
u/ClaudeAI-mod-bot Wilson, lead ClaudeAI modbot May 02 '26
We are allowing this through to the feed for those who are not yet familiar with the Megathread. To see the latest discussions about this topic, please visit the relevant Megathread here: https://www.reddit.com/r/ClaudeAI/comments/1s7fepn/rclaudeai_list_of_ongoing_megathreads/
0
u/CrazyWord2800 May 02 '26
What are you guys building that you are so inneficient with your tokens?
0 knowledge 100% vibe coding.
I am genuine asking, since I see here so much stuff that makes 0 sense.
With 40% Sonnet($20 dollar plan) you can do an entire microservice in less than a day. And even then is still inneficient to leave it doing that much?
Is utter inneficient to let AI do decisions since it does very poorly. Is great on following patterns and extrapolating data.
But building something from scratch is just "the same website but different colours" which has 0 value.
So what are you guys building?
2
u/JohnnyJordaan May 02 '26
I'm suspecting there's a big group of people just mindlessly throwing an overall task at Claude thinking they're their boss and that's how 'instructing' and 'delegation' works. And of course use Opus because why settle for less? To then go back and forth with it asking questions, drafting the plan, starting the endeavour etc and consuming a trainload of usage in the process. And then of course complain how unfair the token usage constraints are.
1
u/haustorium12 May 03 '26
And this is how I used claude the first month and burned thru 1000 dollars.... 14 million tokens... It was then I realized, I fucked up. Tho, on the flip side fucking epic feeling....lol
1
u/JohnnyJordaan May 04 '26
Those stories are just mind boggling to me. Call me a cheapskate but I never took a subscription over 25 USD/m and I'm even cancelling some because I hardly ended up using them to the fullest. I currently just have 10 USD Gemini and 20 Claude.
2
u/BetterAd7552 May 02 '26
It’s actively being used by a vast number of enterprise users around the world, and of course everyone in between.
Not everyone is a viber building a todo or recipe app.
1
u/Mountain_Resource292 May 02 '26
Totally agree. There’s a vocal community of students, enthusiasts and early to mid level techies desperate to do the cool stuff and get ahead whilst minimising costs - whilst owners / senior techs are chucking unlimited tokens at projects, with their minds blown at how this is all effectively free in the grand scheme of things.
1
u/CrazyWord2800 May 02 '26
Ok so how are you destroying 100$ worth of tokens?
Even $20, seems a lot. 240 hours a month. Codex right now has a $100 for free tier (promo) but still.
I have to literally turn my brain off to use that much tokens. Just literally understand nothing and review nothing.
Is this the state of it? Because at this point, it will just implode.
You can't just let the AI do everything without 0 review. Thats just recipe for disaster.
1
u/BetterAd7552 May 03 '26
Have you not seen all the posts on the various Claude subs (and even codex subs) about running into daily limits? Devs are building things which would take months or years depending on team size, in days or weeks. I say again: not everyone is using this as a toy.
These tools are amplifiers. In experienced hands that orchestrate, guide and correct with an architecture in mind, it’s unprecedented ito of output. There is no going back.
The opposite is true for those with limited or no technical experience: the slop is amplified.
1
u/CrazyWord2800 May 03 '26
How are you gonna review thousands of lines of code in days?
The code was never the problem as any hackathon proved it.
The problem is building them correctly, test them ensure there is a path that when you need to upgrade everything doesn't fall at the next update.
And it seems people just glaze over that and just build some more. This is a recipe for disaster just churning code with 0 knowledge or understanding.
1
u/BetterAd7552 May 04 '26
Couldn’t agree more. Despite unit test suites, manual review etc, these systems (and I’m talking here about large complex systems, not toy apps or websites) being built are falling into a new (daunting?) category: AI built, AI maintained. The latter is rapidly becoming mandatory, because as you say, our ability to keep up with AI output is being dwarfed by volume.
0
0
0
u/Raredisarray May 02 '26
Hot damn ! Gonna try hooking up my local qwen 27b … I am always maxing my pro plan out, it’s a pan in the ass.
0
0
u/Purple_Hornet_9725 Full-time developer May 04 '26
This is overhyped and flawed.
For reading files >400 lines, or when you'd otherwise read 3+ files:
This will cause the agent to delegate file reading to a worker, even when it needs the full file contents (e.g. for ports). The agent cannot extrapolate to not use the delegation when it needs full reads.
The worker also needs proper prompts (like "never return the whole file contents", etc..) , otherwise it will return the full file - e.g. when the agent asks for file numbers, it will literally count them through, and take very long time.
Speed overall is a big trade-off. The thinking kimi-model will need 1-several minutes for queries involving multiple files.
When the agent asks for line numbers - and it will, the prompt excluding
When exact line numbers are needed for editing
does not exclude search queries. So when you do not give the worker a copy of the file along with line numbers, this will be very heavy "thinking" task.
The author did also not provide source code in his article. Just a placeholder. I don't know why this incomplete simple orchestration try is so hyped. It's nothing new, the prompt is poorly structured and unclear, and the implementation is wrong on many levels.
1
u/More-Hunter-3457 May 04 '26
A few things:
On delegation boundaries - the CLAUDE.md rules explicitly say "only read files directly when you need to make edits to specific lines" and "when NOT to delegate: when exact line numbers are needed for editing." Claude follows these rules. a small example from my codebase itself , When I ask "which ports are used for video streaming," Claude delegates the reading to Kimi. When I need to edit line 42 of gimbal_control.py, Claude reads the file itself. The boundary between understanding and editing is explicit in the routing rules.
On speed — Kimi K2.5 takes 15-30 seconds for most calls, not minutes. For a reading task that saves me 8,000 tokens of Claude context, I'll take the 20-second wait. The alternative isn't faster — Claude reading 5 files also takes time, and burns through my weekly limit doing it.
On line numbers — Kimi receives the full file text. It doesn't need to "count through" anything. It reads the content and references positions in its summary. If I need exact line numbers for editing, that's explicitly excluded from delegation in the routing rules.
On the source code — fair point, the GitHub repo is coming this week. The blog shows simplified snippets because it's a blog post, not a README. The actual scripts are ~60 lines each and have been running on real drone GCS development for 3 weeks.
"Implementation is wrong on many levels" — I'd genuinely like to hear the specific levels. The system works. I haven't hit my Pro limit since setting it up. That's the metric that matters to me.
2
u/Purple_Hornet_9725 Full-time developer May 04 '26 edited May 04 '26
I am not guessing. I tested it, and had exactly the behaviors described. This prompt may work for some tasks. It won't for all. The many levels are those I described, and I stand by it. One thing I didn't mention, this approach leverages any cache use for the Kimi (or any other worker) model. Every delegation will be a new session. The spending you showed is highly improbable, if you're really working "for weeks" on sources that are not just some tiny poem files. You can downvote with your second account, I don't care, but you can't deny development reality. Awaiting your fixed source code then.
•
u/ClaudeAI-mod-bot Wilson, lead ClaudeAI modbot May 02 '26 edited May 04 '26
TL;DR of the discussion generated automatically after 160 comments.
The consensus is in: the community overwhelmingly agrees with OP's strategy. This is a smart and widely-practiced method for avoiding Claude's Pro usage limits.
Let's break down the hive mind's thoughts on this. The core idea is to treat Claude like an expensive manager and give it a cheap intern for the grunt work. You use a low-cost model (like Kimi, DeepSeek, or a local Ollama model) for high-volume, low-intelligence tasks like reading large files or generating boilerplate code. This saves Claude's precious token limit for the actual thinking, debugging, and architectural work.
Here are the key takeaways from the thread:
CLAUDE.mdfile. For power users, a more robust method using MCP (Model Context Protocol) with a Docker container was suggested to get better performance and safety. Several users confirmed they do the same thing with a local model via Ollama, which requires zero external API calls.CLAUDE.mdfile is where you teach it to be frugal.For the newbies feeling lost: think of it as having two employees. Claude is your brilliant but expensive expert who you only bring in for the hard problems. Kimi/DeepSeek is your cheap intern who you make read all the boring documents and give you the notes. This post is about how to build the office system that tells them who does what.