---

name: multi-agent-delivery description: Use when the user wants a plan-first multi-agent coding workflow with parallel subagents, explicit reviews, and full verification before completion, especially for non-trivial implementations, refactors, audits, or warning-cleanup campaigns.

Multi-Agent Delivery

Overview

Use this skill when the task is large enough to benefit from structured planning, parallel implementation, explicit review, and a real verification pass before reporting completion.

Do not use this skill for tiny single-file edits where delegation overhead is larger than the task.

Workflow

1. Inspect before changing

• Read the relevant code paths before proposing edits.
• Identify the immediate blocker on the critical path.
• Distinguish blocking work from sidecar work that can run in parallel.

2. Write a short execution plan

• For non-trivial tasks, produce a concise plan before substantial edits.
• Keep exactly one step in progress at a time.
• Update the plan when scope changes or when moving from analysis to implementation to verification.

3. Split work into disjoint slices

• Keep the main thread responsible for integration, conflict resolution, and final verification.
• Use explorers for bounded codebase questions or hotspot discovery.
• Use workers for concrete implementation slices with explicit file ownership.
• Give each worker a disjoint write scope and tell it not to revert unrelated dirty worktree changes.
• Keep urgent critical-path work local when the next action depends on it immediately.

4. Delegate with clear ownership

Every worker prompt should include:

• The exact files or modules it owns
• The specific outcome expected
• A warning that other agents are editing the repo too
• Instructions not to touch files outside ownership
• A request for targeted verification and a changed-file summary

5. Review after implementation

• After code changes, run at least one review pass on the integrated result.
• Add a security-focused review for auth, input handling, RPC, payment, or transaction work.
• Add a Rust/Anchor review for smart-contract changes.
• Fix high-severity review findings before reporting completion.

6. Verify before calling it done

Run the strongest practical verification for the touched layers:

• Type-check
• Lint
• Tests
• Contract build/test when applicable

For broad cleanup campaigns, run targeted verification per slice first, then a full repo-level pass for the affected layers.

Never report "done" while required verification is still failing.

7. Report outcomes clearly

The final report should include:

• What changed at a high level
• What verification passed, with counts when available
• What debt or residual risks remain
• What was not run, if anything

Delegation Rules

• Prefer parallel agents only when their write scopes do not overlap.
• Do not duplicate work between the main thread and workers.
• Use wait_agent sparingly; keep doing useful local work while agents run.
• Close finished agents when they are no longer needed.

Suggested Pattern

For a typical non-trivial task:

1. Inspect and write a short plan.
2. Spawn 1 explorer if hotspot analysis is needed.
3. Spawn 1-3 workers on disjoint slices.
4. Continue local integration work while they run.
5. Integrate results and resolve conflicts locally.
6. Run review pass(es).
7. Run full verification.
8. Report results and remaining debt.