the whole method, free · nothing held back
Here's how
I built it.
Yours to copy.
This page is the complete method behind Scrooge, laid out step by step. Follow it and you can build your own version for nothing. Or, if you would rather skip the afternoon of setup and the endless tuning that keeps the quality from slipping, the finished build is ten dollars, relentlessly tested, and it ships with the live savings meter. It pays for itself in the first couple of uses.
Nº 01 · build your own, free
The whole thing,
in five parts.
You need four things: a skill file that carries the standing order, a couple of cheap
workers to hand jobs to, a checker so nothing ships unread, and a receipt so you can
watch it save. Here is each one, with the actual files. This is a simpler cousin of
Scrooge, not a copy of it, but it works. Call yours whatever you like. This one is
named thrift.
Write the skill
Claude Code reads instruction files called skills from a folder in your home
directory. Make a folder and a SKILL.md inside it. The
frontmatter names the skill; the body is the standing order the model follows for
the whole session. Keep yours short and blunt.
---
name: thrift
description: Route mechanical work to cheap models; keep the hard thinking on the best one.
---
You are the coordinator. Do not read files, grep, or run
chores yourself. Split every job into three kinds of work:
chores clear and verifiable -> the runner (cheap model)
judgment contained reasoning -> the analyst (mid model)
hard architecture, one-way doors -> you keep it
Brief every worker with exact file paths and a tight output cap.
Fan out independent chores in parallel, not one at a time.
Never trust a summary; open the actual file and check it.
When the work lands, print the cost receipt.Now typing /thrift loads that as the playbook for the session.
Give it cheap workers
The coordinator needs someone to hand chores to. Claude Code lets you define
subagents pinned to a specific model. Drop a couple of files in
~/.claude/agents/. The runner rides the cheap model and
does the volume; a second file, analyst.md, is the same
shape with model: sonnet for the judgment calls.
---
name: runner
description: Mechanical execution: reads, greps, renames, running tests and builds.
model: haiku
tools: Read, Grep, Glob, Edit, Bash
---
Do exactly what the brief says, nothing more. If a file or
instruction is missing, stop and report. Return a tight summary
plus file:line references, never a wall of text.Route, and fan out
With the skill and the workers in place, the pattern runs itself. For any big job the coordinator classifies each task, spawns every independent chore at once (many runners in a single turn, not a queue), waits for that layer to land, then spawns the next. Parallel is the whole point: ten files read by ten runners at the same time cost a tenth of the top rate and finish in the time of one.
# classify, then send each task to the right rung
chores -> runner (haiku) x N, all in one turn
judgment -> analyst (sonnet) only when it needs it
hard -> you the best model, thinking hardCheck the work, then escalate
Cheap help is only safe if nothing ships unread. Two rules keep the quality flat. First, the worker who did a job is never the one who checks it: send the finished artifact to a fresh runner to verify it against the brief. Second, if the same task comes back wrong twice, bump it up a rung with the failure attached, so the stronger model does not waste time rediscovering the mistake.
That separate reviewer is the quiet upgrade. A single expensive model grades its own homework in one head. This splits the work from the check, so the cheaper path actually ends up looked at more, not less.
Print the receipt
The last piece is proof. Wire a Claude Code hook that fires when the session ends and runs a small script you write. The script tallies how many workers ran at each rung, multiplies by each rung's public rate, and compares that against what the whole job would have cost on the top model alone.
{
"hooks": {
"SessionEnd": [
{ "matcher": "",
"hooks": [
{ "type": "command",
"command": "~/.thrift/receipt.sh" }
] }
]
}
}Rough public rates to do the math with, per million tokens, blended: the cheap rung runs about $2, the middle about $7, the top about $11. Count the tokens each rung handled, take the gap between "all of it on the top model" and "most of it on the cheap ones," and that gap is your receipt. Big jobs with lots of chores save the most. A one-line question saves nothing, and an honest receipt should say so.
A blunt skill, two cheap workers, a checker, and a receipt. Build it in an afternoon and it will genuinely save you money. the free version, in one breath
Nº 02 · the idea
You hired a
five-star chef.
He's washing
the dishes.
Think of Claude as a brilliant, expensive expert. Out of the box, that expert personally does everything: the important thinking, sure, but also the reading, the searching, the copying, the double-checking. All at expert prices.
Without Scrooge · one expert does it all
expensive by the minute
- Reads every file, start to finish expert price
- Hunts for things, one search at a time expert price
- Does the copy-paste-rename chores expert price
- Runs the checks and reads the results expert price
- Does the actual hard thinking expert price
only the gold dot needed the expert. you paid expert rates for all five.
With Scrooge · the expert gets a crew
big decisions only
- Helpers read the files, all at the same time helper price
- Helpers hunt for things, side by side helper price
- Helpers do the chores helper price
- A checker double-checks their work helper price
- The expert still does the hard thinking worth every penny
same job, same standard. the expensive minutes now go only where they matter. bonus: helpers work side by side, so the job often finishes sooner.
Nº 03 · the architecture
One coordinator.
A crew of
cheaper minds.
Here is the same idea in engineering terms. You are building a coordinator: a top-tier model that refuses to do grunt work itself. It reads the job, splits it into pieces, and hands each piece to the cheapest model that can do it correctly. It spends its own expensive tokens only on decomposing, briefing, checking, and the genuinely hard calls. Everything else runs on a cheaper rung.
The cheap rung
A small, fast model (Haiku class). Handles anything with a clear right answer: reading files, grepping, renames, running tests and builds, boilerplate from a template. Runs many at once. Roughly $2 per million tokens.
The middle rung
A capable mid model (Sonnet class). Takes contained judgment: one non-trivial change, a bounded debug, a review of a single component. Called only when a cheap model would plausibly miss the nuance. Roughly $7 per million.
The top rung
The strongest model you have (Opus or Fable class). Architecture, one-way doors, ambiguous cross-cutting debugging, the final call. The coordinator itself lives here and stays here. Roughly $11 per million.
why it actually saves
Two savings, not one.
The obvious one: cheap tokens cost a fraction of top-tier tokens, and most of any big job is cheap-tier work wearing an expensive price tag.
The one people miss: grunt work done inside a helper stays out of the coordinator's context. Left on one model, every file it reads sits in the transcript and gets re-read, and re-billed, on every later turn. Isolation is money.
- The coordinator decides and briefs; it never does chores
- Independent chores fan out in parallel, not in a queue
- Cheap tokens do the volume; top rates buy only the thinking
- Helper context never bloats the expensive main thread
- A separate checker looks at every result before it ships
Nº 04 · where the money goes
These are the
numbers it hits.
Build the pattern above and here is what it does to a bill. Picture ten dollars of Claude doing a big job on one model. Most of it is not buying brilliance. It is buying chores at top-tier prices. Split those off and the same job costs a fraction.
Today · every coin spent at expert prices
$10 of claude, left on its own
about seven of these coins paid for chores. one paid for the thinking that actually needed the expert.
the same job, scrooged
the chores got helper prices. the same $10 job now costs about $3.50. the dashed coins never leave your pocket.
honest estimate from claude's public price list. big jobs with lots of chores save the most, up to about 73%; a one-line question saves nothing, and an honest receipt will tell you so.
one real example
A big project, both ways.
Say you ask Claude to go through a whole project, fix what's broken, and prove it works. A serious, multi-hour job.
Left on its own: about $33. Scrooged: about $10. You keep roughly $23, and you'd never spot which version the expert-only one was.
The same big job · estimated bill
expert does everything
expert + helpers
You keep $23
on this one job. estimates at claude's list prices.
Honest estimate, from Claude's own public price list.
no trust required
It shows you the receipt.
You don't have to take any of this on faith. Every time Scrooge finishes a job, it prints a little receipt: what the job would have cost, what it actually cost, and what you kept.
The numbers are honest estimates from Claude's public price list, and the receipt says so right on it. Watch them add up for a week.
Nº 05 · get more done
Same budget.
Five projects
instead of one.
Saving money is one way to look at it. Here's the other: the budget you already have suddenly goes a lot further.
What $50 of claude gets you
without scrooge · one big project, then you're out
with scrooge · five big projects on the same $50
real arithmetic, not a slogan: one big project runs about $33 wild or about $10 scrooged. fifty dollars covers one the first way, five the second.
yearly figures are illustrative, at claude's list prices, assuming roughly two-thirds of big-job spend stays in your pocket. your receipt keeps the real score.
Nº 06 · the fair question
"But won't cheaper
helpers do
worse work?"
They would, if anyone trusted them blindly. Nobody does. Three rules keep the quality exactly where it was.
Helpers only get chores
Helpers are only handed work with a clear right answer: find this, read that, change these. Anything that takes real judgment never goes to a helper in the first place.
Everything gets checked
No helper's work is taken on their word. A checker looks at the actual result, and if a helper gets something wrong twice, the job automatically moves up to a smarter brain.
The expert keeps the hard parts
The big decisions, the tricky problems, the things that would hurt to get wrong: those always go to the strongest brain available, thinking as hard as it can.
the part nobody expects
It's actually checked more.
Here's the funny thing about plain Claude: it grades its own homework. It does the work, then it checks the work, all in one head.
Scrooge splits those jobs up. The one who did the work is never the one who checks it. So the cheaper way isn't cutting corners. It added a second set of eyes.
- Hard thinking always stays on the strongest brain
- Helpers never make judgment calls
- Every result gets looked at by fresh eyes
- Mistakes bump the job up to a smarter brain, automatically
- And the receipt shows you the savings, every time
You wouldn't pay a surgeon to file your paperwork. Scrooge just applies that one piece of common sense to your AI, automatically, every time. the whole idea, one sentence
Nº 07 · or skip the build
Build it free.
Or hand it
ten dollars.
Everything above is real and yours to keep. But there is a reason the finished version costs ten dollars and not nothing: the distance between a coordinator that mostly works and one that never leaks a drop of quality is a lot of tuning, and a lot of testing on real jobs. That work is done. You can borrow it.
Roll your own
- The whole method above, yours forever
- An afternoon to set up, and honestly more to tune
- You decide the routing rules and when to trust the cheap rung
- You keep it working as models and prices change
- A text receipt you wire up yourself
Skip the work
- The same idea, tuned and tested across hundreds of real jobs
- Knows when handing work down would cost quality, and when it would not
- Adapts to whatever model you happen to be running on
- Ships with the native Mac menu bar meter: live savings, lifetime ledger
- Installs in about a minute, updates itself, and is supported
Nº 08 · the part you can see
You can watch
it save.
The free build gives you a text receipt when a job ends. The ten dollar version adds the part you actually watch: a small Mac menu bar app that counts your savings live.
Your purchase includes a small Mac menu bar app, not just the instruction file. It sits quietly up top and waits.
The moment you type /scrooge, a little receipt shows up in your menu bar and starts counting, live, what this job is saving you. It also keeps a lifetime ledger, so the total keeps adding up job after job.
It's a real Mac app you control: open it from the menu bar or a hotkey you can change, keep a running history, and drag it wherever you like. All on your own machine, with nothing sent anywhere.
It only reads your own machine's records, and it never sends any of it anywhere. No telemetry. Your ledger never leaves your Mac.
Counts up while you work. Never leaves your Mac.