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.

CODEBLOCK0

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.

CODEBLOCK1

Round 2: Brutal Fix (Sonnet — stronger reasoning)

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

CODEBLOCK2

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

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

CODEBLOCK3

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:

CODEBLOCK4

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:

CODEBLOCK5

1c. Model Assignment

CODEBLOCK6

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

CODEBLOCK7

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