discussions/.wiki/raw/research/tokens-economy/2026-05-05-i-gave-claude-code-a-$0.02call-coworker-and-stopped-hitting-pro-limits---here's-the-full-setup.md

title, source, fetched, published, fetched_via, tags

title	source	fetched	published	fetched_via	tags
I gave Claude Code a $0.02/call coworker and stopped hitting Pro limits — here's the full setup	https://www.reddit.com/r/ClaudeAI/comments/1t1o43w/i_gave_claude_code_a_002call_coworker_and_stopped/	2026-05-05	2026-05-02	obsidian-web-clipper	wiki-raw clipping

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:

1. Haven't hit limits once
2. Kimi total spend: $0.38
3. 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

---

Comments

ClaudeAI-mod-bot · 2026-05-02 · 1 points

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:

• Why not just use Haiku? This was the top question. Answer: Haiku still burns your Anthropic Pro usage limit. The whole point of using an external model like Kimi or DeepSeek is that it's on a completely separate budget, effectively bypassing the weekly cap.
• Which cheap model is best? While OP used Kimi, the crowd favorite seems to be DeepSeek V4 Flash. Commenters found it more reliable and less prone to "overthinking" than Kimi. One user did a detailed cost-benefit analysis and found DeepSeek was ~23x cheaper than using Opus for a summarization task, with "good enough" quality.
• How do you set it up? The simple way is OP's method: CLI scripts and routing rules in your CLAUDE.md file. 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.
• Why doesn't Claude do this automatically? It sort of does by using Haiku for some tasks, but as mentioned, that still hits your limit. The consensus is that only you can define the rules for what's worth spending tokens on. Claude doesn't know or care about your budget; it just wants to give the best answer, even if that means reading five files. The CLAUDE.md file is where you teach it to be frugal.
• Is it worth it? Absolutely, if you're hitting your limits. The goal isn't to save pennies on a $20 subscription; it's to make that subscription last the whole week. OP's $0.38 spend on Kimi effectively bought them several extra days of Claude access.

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.

RTG_ZODIAC · 2026-05-02 · 89 points

This is a great idea but from my experience I found that Kimi tends to overthink a lot .
I think using deepseek v4 flash works best for this case

spinthebottl · 2026-05-02 · 23 points

Went through this exact same pipeline. Though I use v4 pro. It's so cheap it doesn't matter.

haltingpoint · 2026-05-03 · 4 points

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?

bosse · 2026-05-03 · 10 points

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.

More-Hunter-3457 · 2026-05-04 · 1 points

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.

nemzylannister · 2026-05-03 · 2 points

do you mean the api? cause even flash requires a ton of vram, no?

More-Hunter-3457 · 2026-05-04 · 1 points

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.

thedeftone2 · 2026-05-02 · 81 points

Why doesn't the AI model do this to save tokens. What use case scenario calls for bulk, inefficient squandering of tokens?

HighDefinist · 2026-05-02 · 22 points

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...

Am094 · 2026-05-02 · 9 points

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)

Sufficient-Rough-647 · 2026-05-02 · 17 points

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.

unexpectedkas · 2026-05-02 · 7 points

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.

Sufficient-Rough-647 · 2026-05-02 · 2 points

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.

workware · 2026-05-03 · 3 points

It absolutely does this, Opus calls use Haiku to read-in files for example.

But

1. 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.
2. 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.

t_zk · 2026-05-03 · 2 points

Subagents (Task)

Impossible_Hour5036 · 2026-05-02 · 2 points

Whether a token is "squandered" or not surely depends on how many tokens you've got available to you.

Inner-Lawfulness9437 · 2026-05-03 · 1 points

Copilot regularly does this with an explore subagent as well.

More-Hunter-3457 · 2026-05-04 · 1 points

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.

tribat · 2026-05-03 · 20 points

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.md for 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
for llm-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-ask a ~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.

More-Hunter-3457 · 2026-05-04 · 3 points

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.

ardicli2000 · 2026-05-04 · 1 points

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.

Dazzling_Dig_6844 · 2026-05-02 · 18 points

Can you please share the link of the GitHub repo?

Cr-O-Nox · 2026-05-02 · 4 points

!remindme 7 days

RemindMeBot · 2026-05-02 · 2 points

I will be messaging you in 7 days on 2026-05-09 19:03:05 UTC to remind you of this link

13 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

Dazzling_Dig_6844 · 2026-05-03 · 2 points

!remindme 7 days

More-Hunter-3457 · 2026-05-04 · 4 points

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.

Dazzling_Dig_6844 · 2026-05-04 · 2 points

Will do it.. appreciate for the article..it's good

kryspee · 2026-05-03 · 2 points

!remindme 4 days

JohnnyJordaan · 2026-05-02 · 3 points

Or... save the html of the article, give it to Claude, let Claude write it for you?

Dazzling_Dig_6844 · 2026-05-02 · 5 points

Was eventually gonna do that if the repo ain't provided. Also just wanna compare this approach with this one.

Link : https://www.reddit.com/r/ClaudeCode/s/55HuqO1THs

lazytiger21 · 2026-05-02 · 87 points

Why not just tell it to task to haiku?

PossibleHero · 2026-05-02 · 118 points

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.

the_good_time_mouse · 2026-05-02 · 21 points

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.

fprotthetarball · 2026-05-02 · 11 points

Titler had some good ideas

jtoomim · 2026-05-03 · 6 points

He has become self-aware. Now we call him Mecha-Titler.

ai_without_borders · 2026-05-02 · 42 points

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"

slashedback · 2026-05-02 · 31 points

Haiku is hot trash though

lazytiger21 · 2026-05-02 · 10 points

For what the instructions say it is doing, haiku should be fine.

Thomas-Lore · 2026-05-02 · 9 points

Deepseek Flash V4 will be fine too, just won't burn your quota, and is super cheap.

flickerdown · 2026-05-02 · 12 points

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.

More-Hunter-3457 · 2026-05-04 · 1 points

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.

azndkflush · 2026-05-02 · 9 points

Good idea, could run locallm to handle easy task instead of paying api tokens

newmacbookpro · 2026-05-03 · 4 points

Qwen 32 comes to mind 

Warm_Assist · 2026-05-02 · 7 points

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)

1. **Create a single markdown file** with all your static instructions/rules/templates
2. **Name it `CLAUDE.md`** and put it in your Claude Code project folder
3. **Paste it once** at the start of a new chat instead of every time
4. **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:

1. **Get a cheap LLM API key** (DeepSeek, Kimi, etc.)
2. **Create simple Python scripts** that call the cheap API for reading files or generating boilerplate
3. **Use those scripts when you just need I/O work** (reading multiple files, generating test templates, etc.)
4. **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:

1. Sign up for DeepSeek (or similar): **https://platform.deepseek.com**
2. Add $5 in credits (lasts forever for light usage)
3. Create a couple Python scripts (the article has templates)
4. Drop them in a `bin` folder
5. 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:

1. Get API key from DeepSeek/Kimi ($5 in credits)
2. Create simple Python script that calls their API
3. Use it when you need to read multiple large files or generate templates
4. Cost: ~$0.01 per operation vs ~$0.30 with Claude
5. 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.

More-Hunter-3457 · 2026-05-04 · 1 points

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.

Phunfactory · 2026-05-02 · 6 points

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…

Whole-Ad-9429 · 2026-05-02 · 3 points

Yes, you just need to define your own agent for it

Public-Flight-222 · 2026-05-02 · 2 points

Copilot is (for now, at least) pricing is request based - not token based. So you'll not benefit from it.

Inner-Lawfulness9437 · 2026-05-03 · 1 points

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.

More-Hunter-3457 · 2026-05-04 · 1 points

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.

Beckland · 2026-05-02 · 6 points

This makes so much sense, I wanted to implement but your Github link is not in the article…could you share?

katerlouis · 2026-05-03 · 1 points

/remind 2 days

emptyharddrive · 2026-05-03 · 6 points

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.

MockingMatador · 2026-05-03 · 3 points

Sounds great! Link to github repo please!

More-Hunter-3457 · 2026-05-04 · 3 points

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.

elconcho · 2026-05-03 · 4 points

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?

ofthewave · 2026-05-02 · 15 points

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

eesperan · 2026-05-02 · 8 points

Just keep reading.

SpadoCochi · 2026-05-02 · 5 points

Just keep watching videos and reading. I’m still very early also but this is important

Senhor_Lasanha · 2026-05-02 · 15 points

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?

mrgulabull · 2026-05-02 · 7 points

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.

moonshwang · 2026-05-02 · 4 points

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.

HighDefinist · 2026-05-02 · 7 points

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...

Fatso_Wombat · 2026-05-02 · 2 points

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.

itsFromTheSimpsons · 2026-05-02 · 2 points

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

kiruzo · 2026-05-02 · 1 points

dude I was in your spot just two weeks ago. Keep reading and being curious.

kauthonk · 2026-05-03 · 1 points

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.

theov666 · 2026-05-02 · 16 points

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.

KrazyA1pha · 2026-05-02 · 18 points

Bot comment.

jcumb3r · 2026-05-03 · 2 points

Plus bot upvotes

wrt-wtf- · 2026-05-02 · 5 points

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.

theov666 · 2026-05-02 · 1 points

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.

xeldj · 2026-05-02 · 1 points

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…

More-Hunter-3457 · 2026-05-04 · 1 points

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.

theov666 · 2026-05-04 · 1 points

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.”

HighDefinist · 2026-05-02 · 2 points

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...

JohnnyJordaan · 2026-05-02 · 2 points

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.

tigerscomeatnight · 2026-05-02 · 2 points

What weekly limit? I hit my Pro limit daily.

More-Hunter-3457 · 2026-05-04 · 2 points

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.

Linkman145 · 2026-05-02 · 2 points

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.

minkyuthebuilder · 2026-05-02 · 2 points

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

AshSurround · 2026-05-02 · 2 points

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".

cygn · 2026-05-02 · 2 points

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?

setec404 · 2026-05-03 · 2 points

I have always been confused as to how this isnt native behavior in tools like opencode.

Full-Definition6215 · 2026-05-02 · 2 points

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?

Heavy_Elderberry7769 · 2026-05-02 · 2 points

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:

1. How do you handle Kimi getting context wrong on the bulk read? Do you spot-check, or trust the output?
2. Have you tried this pattern with non-code tasks — like research or content drafts?

Garland_Key · 2026-05-03 · 2 points

This was written by Claude.

G-R-A-V-I-T-Y · 2026-05-02 · 1 points

Awesome, thanks so much for the code, I’ll have to implement this. The limits are killing me.

fiji_almonds · 2026-05-02 · 1 points

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.

Lower_Cupcake_1725 · 2026-05-02 · 1 points

I dedicate implementation to glm 5.1, it's the best cost/quality option for now to offload the work from Claude 

kneecolesbean · 2026-05-02 · 1 points

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.

FlightCautious3748 · 2026-05-02 · 1 points

what does your weekly throughput look like across active clients rn because that changes how aggressive the routing logic needs to be. we were running like 8 projects simultaneously and the limit problem got bad fast so we ended up routing almost everything through blink's ai gateway which covers 200+ models so claude handles the reasoning layer and cheaper models get the grunt work without wiring up separate providers. the routing decision is the hard part tbh once that's solid the cost math basically handles itself

ThesisWarrior · 2026-05-02 · 1 points

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?

More-Hunter-3457 · 2026-05-04 · 1 points

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.

ThesisWarrior · 2026-05-04 · 1 points

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.

arctide_dev · 2026-05-02 · 1 points

I actually get this to work. I use pretty much the same process as you, but divide the work in a different way. I send a lot of reading and standard stuff to the Codex CLI instead of Kimi. My OpenAI payment gives me about 12 and a half minutes of thinking time (or 5 hours!) that is separate from the amount of time I’m allowed to use with Claude Pro. Because of this, when Claude gets stuck in the middle of a feature, I use codex exec from a PostToolUse hook to pass the problematic part of the work over to Codex, and at the same time, I add to a file named .shared/cross-tool-log.md. This file works like a circular record, so the next time Claude is used, it can see what Codex just changed. I pay a set price for both services each month and spend no extra money.

Also, someone up above was saying 24 calls to Kimi is “almost not worth it”, but they’re missing the main advantage: the limit on how much you can use doesn't increase with each use. Claude Pro has a weekly limit, but Kimi doesn't. So, those 24 times Kimi was used, Claude didn't use up its limited amount of time on a difficult task that you would have likely given up on by Wednesday afternoon.

More importantly for me, I’ve made the instructions for deciding where to send the work in CLAUDE.md very precise. I have it say, “Before Reading a file, if the file has more than 800 lines and isn't about the actual edit being done, first use a search subagent”. Just that rule has reduced my reading of entire files (around 3000 tokens) to looking at a summary of files (around 150 tokens), and that benefit increases throughout a session.

kuroudo_ai · 2026-05-03 · 1 points

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.

Delicious-Storm-5243 · 2026-05-03 · 1 points

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.

Cazique__ · 2026-05-03 · 1 points

!remindme 2 days