Delegation — Think Once, Execute Cheap

Opus is the brain. Everything else is hands. This skill is the translation layer between insight and execution.

Core Principle

Never use a $0.10/task model for $0.002/task work. Never use a $0.002/task model for $0.10/task thinking.

OPPORTUNITY ──► OPUS THINKS ──► ATOMIC TASK QUEUE ──► CHEAP MODELS EXECUTE ──► EVALS VERIFY ──► SHIP
                 (once)           (written artifact)     (sonnet/flash/gptoss)   (automated)

Phase 0: VENTURE EVAL (new ideas only — skip for defined tasks)

When Ryan has a raw idea, before any decomposition, run the Venture Eval Protocol. This replaces VC due diligence with builder-optimized evaluation. 3 rounds max, then decide.

Round 1: Irrational Optimism (Flash — cheap, fast)

Prompt a cheap model to go MAXIMUM bullish. No skepticism allowed.

You are an irrationally optimistic founder evaluating this idea: {IDEA}

Assume everything goes right. Answer:
1. WHAT: one sentence
2. WHO PAYS: specific buyer (not "businesses" — name the persona)
3. WHY NOW: what changed in the world that makes this possible today
4. TAM: bottoms-up, not "1% of $X billion" — how many buyers × price
5. UNFAIR EDGE: what do we already have (infra, data, distribution, skills)
6. FIRST $1K: exact steps to the first thousand dollars in revenue
7. 10X SCENARIO: what does this look like if everything works for 2 years
8. EXISTING ASSETS: which of our products/pipelines/skills does this plug into

Round 2: Brutal Fix (Sonnet — stronger reasoning)

Take Round 1's output and try to KILL it:

You are a ruthless VC partner reviewing this pitch: {ROUND_1_OUTPUT}

For each of the 8 points, either:
- CONFIRM: evidence supports it, cite why
- FIX: the claim is wrong but fixable — here's how
- KILL: this is fundamentally broken and unfixable — here's why

Then answer:
- BIGGEST RISK: the one thing that kills this
- CAN WE TEST IT FOR <$100?: yes/no + how
- COMPARABLE EXITS: 3 companies in adjacent space that sold/IPO'd
- VERDICT: BUILD / PARK / KILL (with one-sentence reason)

Round 3: Questionnaire (only if Round 2 says BUILD)

If the idea survives, generate 5 questions that MUST be answered before committing resources:

Based on this evaluated idea: {ROUND_2_OUTPUT}

Generate exactly 5 questions where:
- Each question can be answered with data (not opinion)
- Each answer changes the build plan materially
- Each can be researched in <30 minutes
- Format: QUESTION | HOW TO ANSWER | WHAT CHANGES IF YES vs NO

Ryan answers the 5 questions → answers feed into Phase 1 decomposition.

Token Budget for Venture Eval

If we can't resolve it in $0.07 of reasoning, the idea isn't clear enough. Park it and revisit when more signal arrives.

When NOT to Venture Eval

• Task is already defined (bug fix, feature request, maintenance)
• Ryan explicitly says what to build
• It's a client project with specs
• It's infrastructure/tooling work

Phase 1: THINK (Opus only — ~500-2000 tokens output)

This is the ONLY phase that uses Opus. Everything after is delegated.

1a. Opportunity Frame (if Venture Eval was skipped)

Answer in ≤150 words:

WHAT: [one sentence — what is this]
WHO: [target customer — be specific, not "SMBs"]
WHY NOW: [timing signal — regulation, tech shift, market gap]
TAM: [total addressable market — even rough napkin math]
COMPETITORS: [top 3, their weakness]
OUR EDGE: [what we have that they don't — existing infra, distribution, data]
SLICE: [the specific wedge we'd enter with — not the whole market]

1b. Decompose into Atoms

Break the work into the smallest independently testable units.

Rules:

• Each atom has ONE clear output (a file, a URL, a data point, a yes/no answer)
• Each atom can be verified by a machine (not "looks good" — a command that returns pass/fail)
• Each atom takes <15 min for a sub-agent
• If an atom takes >15 min, it's not atomic — split again
• Dependencies are explicit (atom B needs atom A's output file)

Output format:

| # | Atom | Output | Eval | Model | Depends | Est. |
|---|------|--------|------|-------|---------|------|
| 1 | Research competitor pricing | `research/pricing.md` | ≥3 competitors listed | flash | — | 3m |
| 2 | Scaffold Next.js app | `src/app/page.tsx` | `npm run build` exits 0 | sonnet | — | 5m |

1c. Model Assignment

Is it code generation?          → sonnet
Is it bulk/template/classify?   → flash
Is it batch of 20+?            → gptoss
Does it need >100K context?    → gemini-pro
Is it client-facing copy?      → opus (exception)
Is it a yes/no check?          → flash

Default: flash. Only upgrade when there's a reason.

1d. Eval Specification

Every atom gets a machine-verifiable eval:

Phase 2: PLAN (still Opus, just ordering — fast)

1. Topological sort by dependencies
2. Group into waves (parallel atoms)
3. Estimate total time = longest path through dependency graph
4. Estimate total cost = sum of (model cost × est. time)

Write full plan to workspace/DELEGATION_PLAN.md.

Phase 3: EXECUTE (Opus hands off — never touches work again)

Hand DELEGATION_PLAN.md to orchestrator → spawner pipeline.

Opus's ONLY role during execution: monitor completion events, re-route on failure.

Opus does NOT: write code, generate content, run builds, do research queries.

Phase 4: EVAL (automated)

After each atom: run eval command → pass/fail → retry with model escalation if needed.

fail → retry same model → upgrade model (flash→sonnet→opus) → mark failed

Phase 5: LEARN (feeds auto-improve)

Append timing + pass/fail per atom to .learnings/LEARNINGS.md.

Anti-patterns

• ❌ Opus writing code
• ❌ Subjective evals ("looks nice")
• ❌ Atoms bigger than 15 min
• ❌ Skipping the frame for new opportunities
• ❌ Re-thinking during execution (plan is locked after Phase 2)
• ❌ Spending >$0.07 reasoning about an unvalidated idea
• ❌ Using gptoss for <20 items