| name | delegate |
| description | Push heavy work into sub-agents and keep the main conversation's context clean. Use when starting any multi-step task — codebase research, sprint execution, browser/Playwright verification, or anything that would otherwise dump large output (screenshots, file listings, wide search results) into the main loop. Bring back only the conclusion. |
| license | Complete terms in LICENSE |
Delegate — keep the main loop clean
The main conversation loop is the scarce resource. Every screenshot, file dump, long
search result, and verbose tool output that lands in it costs context, slows every
subsequent turn, and degrades reasoning quality. The fix is simple and nearly always
correct: do the heavy work in sub-agents and bring back only the conclusion.
The rule
When a task is more than a couple of steps, or would pull large output into context,
delegate it to a sub-agent. The main loop should orchestrate and decide — not be the
place where 30 screenshots, a 2000-line file, or a wide grep dump accumulate.
When to delegate (default yes)
- Codebase research / exploration — "where is X", "how does Y work", sweeping many
files. Use a read-only exploration agent and get back a tight summary with
file:line
pointers, not the file contents.
- Browser / Playwright verification — this is the big one. Screenshots are the
fastest way to blow up context. A sub-agent should drive the browser, take the
screenshots, and report back "all flows pass, here are the 3 that matter" plus the
saved paths. Keep the image payloads out of the main loop.
- Sprint / task execution — each chunk of an implementation plan runs in its own
sub-agent with the relevant plan section and file paths.
- Anything fan-out-able — independent chunks of work run as parallel sub-agents in
a single message. Parallel is great but not required; serial sub-agents still keep
the main context clean.
Run them in parallel
When delegated tasks are independent, launch them in parallel — issue multiple
agent calls in a single message and they run concurrently. This is the default for
independent work (research multiple subsystems, verify multiple flows, execute
independent sprints): it's faster and keeps the main loop just as clean as serial.
Only go serial when one sub-agent's output feeds the next. When in doubt and the
tasks don't depend on each other, fan out.
Forcing yourself to name what can run in parallel is half the value of this skill — it
makes you decompose the work into independent units instead of one long serial slog.
Reasoning effort
If a delegated task is genuinely hard and needs strong reasoning, give that sub-agent a
stronger model / higher reasoning effort rather than pulling the work back into the main
loop to "do it carefully here." The point is to keep the main loop clean and fast —
strong reasoning belongs in the sub-agent doing the hard part.
What stays in the main loop
- Orchestration: deciding what to delegate, in what order.
- The user-facing narrative and decisions.
- Small, cheap reads where spinning up an agent costs more than it saves (one known
file, one config value). Don't delegate a single
cat.
The smell test
Before running a wide search, a browser flow, or reading a big file directly in the
main loop, ask: will this output be large, and do I only need the conclusion? If yes —
delegate it. When in doubt, delegate.
For concrete before/after delegation patterns, see EXAMPLES.md.
