thrifty

thrifty

Tiered-delegation task execution for Claude Code. A planner model writes the spec into sprints, a cheap model executes and self-verifies against the gate — same gate quality as the strong model, ~64% cheaper (≈⅓ the cost) (benchmarked).

Offload each sprint of work to the weakest model that can do it correctly.

The idea

Most of the work in a task is pattern-following execution, not reasoning. thrifty concentrates planning in one model and pushes execution down to a cheap one, with the gate (tests / a checklist) as the trust contract — independently re-run, never self-reported. This generalizes "tests as the source of truth" to any task, code or not.

Benchmarked architecture

The configuration that won the cost/quality bake-off (spec → working code, 7 tasks across JS / Python / Go / prose, gate-verified — see eval/RESULTS.md and experiments/):

spec ──▶ Sonnet  writes contract (pins cross-sprint + genuinely-ambiguous decisions)
                 + sprints.jsonl (one self-contained unit of work each)
            │
            ▼
         Haiku   one cached agent builds every sprint, runs the gate, and self-fixes
            │
            ▼
         Sonnet  a SCOPED patch — only if a specific failure is left (in practice: never;
                 the Haiku agent self-fixed to green on all 7 tasks)

Result: ~64% cheaper than Opus building the same spec, at equal gate quality — on large, multi-unit builds (the win grows with size). On trivial builds the planning overhead makes thrifty cost more than a single capable agent, so there's a crossover below which you should just use one strong model directly (see Usage). Two things make it work: a single cached agent reuses the contract across turns (cheap, no cold-call bloat), and the contract pins every decision that crosses a sprint boundary so the executor never invents a system-level choice (leave one ambiguous and the executor writes contradictory tests). Opus is not in the execution loop.

Install

thrifty ships as a Claude Code plugin (bundles all six skills):

/plugin marketplace add 2389-research/thrifty
/plugin install thrifty@thrifty

Then trigger it with "thrifty", "delegate this", or "tiered build".

The subagent-based skills (thrifty, thrifty-plan/brief/execute/check) need no external runtime. The lean thrifty-dispatch flow shells out to skills/thrifty-dispatch/dispatch.py, so it additionally requires Python 3 on PATH.

To hack on it locally instead, symlink the skills into ~/.claude/skills/:

for d in skills/*/; do ln -s "$PWD/$d" ~/.claude/skills/; done

Lineage

thrifty generalizes three existing systems to arbitrary tasks:

• speed-run — offload first-pass generation to a fast model; the strong model does architecture and surgical fixes, never wholesale regeneration.
• pipelines/local_code_gen — a strong architect pins every cross-sprint decision in a contract so the weak executor never makes a system-level choice.
• Noospheric Orrery — proof of the philosophy: Sonnet never extracts; Haiku does all the work; Sonnet writes and refines the spec until the cheap model reliably passes.

Where local_code_gen writes 600-line byte-pinned contracts for a tiny local model (qwen3.6 / gemma), thrifty deliberately sits well above that floor. Haiku is far stronger, so the contract pins only what is cross-sprint AND genuinely ambiguous — the seams, not the interiors. Since the planner's (Sonnet) output is the expensive part, terseness is the goal: pin the few decisions two capable sprints would otherwise diverge on, and let Haiku infer the rest.

Skills

Skill	Role	Model	Runs as
thrifty	orchestrator (subagent flow)	—	this session
thrifty-dispatch	orchestrator (lean dispatch flow — default)	—	this session
thrifty-plan	director's planning discipline	Sonnet	this session
thrifty-brief	expand a unit spec into a brief (split tier)	Sonnet	dispatched subagent
thrifty-execute	execute one unit	Haiku	dispatched subagent
thrifty-check	verify + fix one unit	Sonnet	dispatched subagent

Planning tiers (who writes the briefs)