Subagent Delegation Patterns

Leverage native parallel subagent dispatch and 200k+ context windows where available.

Activation Conditions

Use symptom -> action triggers: when one matches, apply this skill and verify with the protocol below.

Activate this skill when:

Creating repetitive code structures or boilerplate
Performing data transformation tasks
Analyzing codebase for patterns or information
Generating documentation from existing code
Creating simple utility functions
Breaking down complex features into manageable subtasks

Core Delegation Patterns

See Delegation Patterns for detailed examples of:

Boilerplate generation (API routes, CRUD operations, component structures)
Data transformations between formats
File analysis and pattern extraction
Documentation generation from code
Utility function creation

Cross-Client Portability

This skill is written to stay usable across GitHub Copilot, Claude Code, and Codex.

GitHub Copilot: keep the folder in a Copilot-visible skill path or wrap the workflow in project instructions when folder discovery is unavailable.
Claude Code: keep the folder in a local skills directory or a compatible plugin source.
Codex: install or sync the folder into $CODEX_HOME/skills/subagent-delegation and restart Codex after major changes.

MCP Availability And Fallback

Preferred MCP Server: None required

Fallback prompt: "Use the Subagent Delegation Patterns skill without MCP. Rely on its local instructions, bundled resources, standard shell or editor tools, and direct verification. Show the evidence used before concluding."
Do not claim an MCP operation was used when the active host does not expose it.
Treat local files, tests, rendered outputs, logs, or screenshots as the fallback evidence path.

Anti-Patterns

Delegating or evaluating without a scoped success condition: The output becomes hard to review and easy to overbuild.
Skipping the evidence step: A workflow that cannot be re-checked quickly is not ready for handoff.
Bundling unrelated subtasks together: It creates noisy prompts, weaker ownership, and avoidable integration risk.

Verification Protocol

Before claiming "skill applied successfully":

Pass/fail: The Subagent Delegation workflow names the agent boundary, delegated scope, and expected return artifact.
Pass/fail: Context passed to helpers is minimal, task-local, and free of hidden expected answers.
Pass/fail: Results are integrated only after evidence, diffs, or citations are checked by the controller.
Pressure-test scenario: Run the workflow on two similar tasks that must not share assumptions or leaked context.
Success metric: Zero context leakage; every delegated output is independently reviewable.

Examples & Scripts

Delegation Pattern Examples — Code examples of common delegation patterns
Delegation Template — JavaScript template for structuring delegation calls

Self-Verification Phase-Gate Questions

Before you mark delegated work complete, the coordinating agent must ask:

Did the subagent receive a scoped task, owned files or responsibilities, and a clear definition of done?
Did I review the returned output for correctness, integration fit, and missing edge cases instead of forwarding it blindly?
Did I preserve the evidence trail showing what was delegated, what changed, and what still needs local ownership?
Are any follow-up fixes, risks, or unresolved assumptions now explicit to the next reviewer?

Integration Workflow

For delegating tasks to subagents, follow this 5-step process:

Step 1: Plan - Analyze problem, design solution, identify routine subtasks
Step 2: Delegate - Use runSubagent for routine or repetitive work
Step 3: Review - Check output for correctness, completeness, integration compatibility
Step 4: Integrate - Incorporate output into codebase, handle conflicts
Step 5: Validate - Test integrated code, debug issues, ensure quality

Quality Control

Before integrating subagent results, verify:

Code follows project conventions (style, naming, structure)
Matches specified interfaces and contracts
Includes necessary error handling
Has appropriate comments/documentation
No security vulnerabilities or obvious performance issues
Compatible with existing codebase (imports, dependencies)

Combining with Sequential Thinking

For complex tasks, use Sequential Thinking first to plan architecture, then delegate routine parts:

// Use Sequential Thinking to plan
mcp_sequentialthi_sequentialthinking({
  thought: "Breaking down feature...identifying repetitive CRUD for delegation",
  thoughtNumber: 1,
  totalThoughts: 5,
  nextThoughtNeeded: true
})

// Then delegate boilerplate
runSubagent({
  description: "Generate CRUD API",
  prompt: "Create CRUD functions matching data model..."
})

// Main agent implements core logic

Related Skills

agent-task-mapping: Use it when the workflow also needs task-to-agent routing decisions.
custom-agent-usage: Use it when the workflow also needs loading and invoking custom agent definitions safely.
subagent-driven-development: Use it when the workflow also needs plan-driven implementation with reviewer loops.
agentic-eval: Use it when the workflow also needs rubric-driven evaluation loops.

subagent-delegation