From plan-and-delegate
Orchestrate non-trivial development work by planning first, then delegating implementation to subagents. Use this whenever the user asks to build a feature, app, library, refactor, or any task that spans more than a couple of files or steps — even if they don't say "plan" or "delegate". The workflow: (1) think through and plan the work at high reasoning (Opus), (2) write a concrete implementation spec, (3) hand each step to an implementation subagent on the model that fits the step — Sonnet for well-specified mechanical work, Opus for ambiguous or judgment-heavy work — then review and integrate. Trigger on "build X", "implement X", "add a feature", "create a project", "refactor X", or any multi-step engineering task where jumping straight to code would risk wasted work.
How this skill is triggered — by the user, by Claude, or both
Slash command
/plan-and-delegate:plan-and-delegateThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Big or fuzzy coding tasks fail in two predictable ways: you start coding before
Big or fuzzy coding tasks fail in two predictable ways: you start coding before you understand the problem, or you burn an expensive reasoning model on mechanical work that a faster model would have nailed. This skill is a workflow that avoids both. You plan once, carefully, at high reasoning, then fan the implementation out to subagents, matching each piece of work to the cheapest model that can do it well.
You — the session running this skill — are the orchestrator. You stay in the loop end to end: you hold the plan, you write the briefs, you pick the models, you review what comes back, and you integrate. Subagents do scoped implementation work and report back; they don't own the architecture.
Don't bring out the whole apparatus for a one-line fix. Use judgment:
If you're unsure, lean toward planning. The cost of a five-minute plan is small; the cost of building the wrong thing is large.
Planning is where the leverage is, so do it at the top of your reasoning
ability. If a brainstorming or planning skill is available (e.g.
superpowers:brainstorming, superpowers:writing-plans), use it here — this
skill composes with them rather than replacing them.
Before writing any code, get clear on:
End Phase 1 with a written plan: a short prose summary plus an ordered (or dependency-annotated) list of steps. Confirm it with the user before you start spending tokens on implementation — a wrong plan caught here is nearly free.
A subagent starts cold. It does not share your context, your conversation, or your mental model — it sees only the brief you give it. So the spec you write is the single biggest determinant of whether delegation succeeds.
For each step you intend to delegate, write a brief that is self-contained:
src/auth/session.ts:42), don't describe vaguely.A good test: if you handed the brief to a competent engineer who has never seen the project, could they do the step without asking you a question? If not, add what's missing.
Dispatch each step to an implementation subagent via the Agent tool, setting
the model parameter deliberately. The whole point is to spend reasoning where
it pays off and move fast where it doesn't.
Use Sonnet (model: "sonnet") when the step is well-specified and the path
is clear — the spec removed the ambiguity, so what's left is execution. Sonnet
is faster and cheaper, and on a tight brief it's excellent. Good fits:
Use Opus (model: "opus") when the step needs judgment that the spec can't
fully pin down — getting it subtly wrong is expensive, so pay for the better
reasoning. Good fits:
Rule of thumb: if the spec made the step unambiguous, Sonnet. If real judgment remains, Opus. When a step on Sonnet comes back wrong in a way that reveals hidden complexity, that's your signal to re-run it on Opus with a sharper brief — don't just keep retrying the same thing.
superpowers:dispatching-parallel-agents pairs well here.)Subagent output is a draft, not a merge. You're accountable for what lands, so:
Only call the work done once you've watched it pass, not because a subagent said it would.
Plan (Opus, with the user)
└─ write specs for each step
├─ Step 1: schema design → Opus (foundational, judgment-heavy)
├─ Step 2: CRUD endpoints → Sonnet ┐
├─ Step 3: form components → Sonnet ┤ parallel, depend on Step 1
└─ Step 4: tests for endpoints → Sonnet ┘
└─ review every result, verify, integrate
Keep the orchestration visible to the user: say which step is going to which model and why, so the delegation is legible rather than a black box.
Guides creation, editing, and verification of skills for AI coding agents using test-driven development with subagent scenarios. Use when authoring or debugging skills.
npx claudepluginhub danielfrengl/plan-and-delegate --plugin plan-and-delegate