delegation-discipline

name

Delegation Discipline

description

Delegate work to subagents, background tasks, or parallel workers effectively - and verify their outputs before relying on them. Activate when spawning agents, fanning out searches or reviews, orchestrating multi-agent workflows, running background tasks, or incorporating any output produced outside your own context. Trigger signals: "use agents for this", "fan out", "in parallel", a task too large for one context, or noticing you're about to restate a subagent's claim as your own finding.

Delegation Discipline

Purpose

Delegation multiplies throughput and divides accountability — unless discipline restores it. A subagent is a capable worker with zero context you didn't give it and outputs that are claims, not facts until checked. The two failure poles: trusting delegated output blindly (their confabulations become your confabulations, with your confidence attached), and delegating so vaguely the work comes back plausible-but-useless. This skill is the contract layer between you and your delegates.

When to use this skill

• Before spawning any subagent, background task, or parallel worker.
• When incorporating delegated results into your own deliverable — the verification half applies even if someone else did the delegating.
• When a task exceeds one context window or one attention span: broad searches, multi-file audits, independent parallel workstreams.

When NOT to use this skill

• Two-minute lookups you can do directly — delegation overhead (writing the brief, verifying the result) exceeds the task. Delegate work, not errands.
• Judgment calls that are the actual heart of the task (the architecture decision, the final recommendation). Delegate the inputs to judgment — research, enumeration, verification — not the judgment itself.

Operating procedure

1 — Decide whether to delegate. Delegate when: work is independent and parallelizable; it's context-heavy exploration whose conclusion you need but whose details you don't; it would flood your context with material you'd only skim. Keep when: it's tightly coupled to your working state; the brief would be longer than the task; verifying the result costs more than producing it.

2 — Write the brief as a contract. A subagent knows nothing you don't tell it. The brief includes:

• Goal and why (one line of mission prevents a page of misfire).
• Inputs: exact paths, links, constraints — not "the config file" but which one.
• Deliverable shape: exactly what to return (a list of file:line findings; a table of options with tradeoffs; a yes/no with evidence). Vague deliverable specs return essays.
• Done-criteria and boundaries: what NOT to do (don't edit, don't fix, report only), scope limits, effort cap.
• The authoritative evidence layer, when the delegate judges something: which source wins on conflict (the diff over the narration, the data over the summary, the code over the report). Delegates drift toward the easiest-to-read evidence unless told which layer is truth.

3 — Partition cleanly for parallel work. One owner per artifact — never two agents writing to the same file or answering the same question in overlapping ways you'll have to reconcile. Slice by file, by module, by sub-question. Shared read is fine; shared write is a collision.

4 — Verify delegated output like an external PR. Proportional to stakes (effort-calibration), but never zero:

• Spot-check claims against sources: pick 2–3 load-bearing claims and check them yourself (open the file, run the command, read the cited passage). Subagents confabulate exactly like you do — fluently.
• Check completeness against the brief: did it cover the whole scope or silently truncate? "Reviewed the module" may mean three files of nine.
• Cross-check overlaps: where two delegates' outputs touch, do they agree on interfaces, terminology, counts?
• A delegated claim you didn't verify gets verification-discipline labeling when you pass it on: "per the search agent (not independently verified)".

5 — Integrate deliberately. Reconcile naming and assumptions across workstreams; resolve conflicts by evidence, not by whichever report you read last. The synthesis is your work — the part that can't be delegated.

6 — Own the result. Accountability doesn't fan out. "The agent got it wrong" is not a defense the user should ever hear; the verification step was yours.

Quality bar

• Every brief specifies deliverable shape and boundaries — a stranger could execute it without asking questions.
• No delegated claim reached the user unverified and unlabeled.
• Parallel workers never collided on an artifact; integration reconciled their seams explicitly.
• Delegation net-saved effort — briefs and verification included.

Common failure modes

• Trust laundering: subagent guesses → your summary states them as facts → user relies on them. The chain looks rigorous; nothing in it was checked.
• The vague brief: "look into the auth system" returns ten minutes of prose about the wrong thing. Deliverable-shape specs are the cure.
• Judgment outsourcing: delegating "decide which approach is best" and pasting the verdict. The delegate lacked your context; you lacked their reasoning; nobody actually decided.
• Collision partitioning: two agents "fixing" the same file, last-write-wins destroying the first fix.
• Completeness assumption: treating "here's what I found" as "here's all there is." Ask what was not covered; silent truncation reads as full coverage.
• Errand delegation: spawning an agent to read one file. The overhead exceeded the task before the brief was done.

Example

Task: audit a 40-file module for uses of a deprecated API before removal. Brief per agent (files partitioned 10/10/10/10): "Goal: find every call site of legacyFetch() so removal can be planned. Search these 10 files only. Return: file:line, the call's purpose in ≤1 line, and whether a direct swap to fetchV2() looks safe (yes/no/unsure). Do not edit anything. Report files you could not check." Verification: spot-checked 3 reported call sites (all real), grepped one partition independently — agent's count matched. One agent reported 0 findings; independent grep of its partition confirmed (completeness check — 0 is the result most worth verifying). Integration: merged table, flagged the 4 "unsure" rows for human review, noted per-agent coverage. Total: 31 verified call sites; claim passed on as fact because it was checked.

Works with sibling skills

• deep-decomposition produces the partitions; this skill turns them into contracts.
• adversarial-verify and live-state-truth power step 4 — delegated output is exactly the "finished work" those skills attack and ground.
• verification-discipline labels whatever you pass on unverified; scope-fence boundaries go into the brief ("report, don't fix").
• effort-calibration sizes the verification depth per stakes.

Provenance and maintenance

Added 2026-07 in the expansion pass: agentic multi-worker execution is a first-class workflow with a first-class failure mode (unverified trust chains) that no core skill owned. No repo-specific claims. Re-verify by auditing a recent multi-agent task: pick two claims that came from delegates and trace whether anyone checked them before they reached the final output. If not, step 4 isn't biting.