Task Delegation

Task Delegation Skill

Delegation Pattern

Plan → Create Task → Design Approach → Delegate → Review → Commit

Main Thread (You): Planning, architecture, coordination, review, user communication Subagents: Execution of well-defined work items with clear outputs

When to Delegate

✅ Always delegate:

• Execution work taking >5 minutes of focused effort
• Writing, research, analysis with defined scope
• Work that can run in parallel with other tasks
• Repetitive mechanical tasks (formatting, compilation, migration)
• Well-defined scope with clear output format

✅ Benefits:

• Parallel execution across independent tasks
• Better planning with full project context
• Focused execution produces higher quality
• Cost optimization through model assignment

When NOT to Delegate

❌ Never delegate:

• Task creation or search (use MCP tools directly in main thread)
• Planning and architectural decisions (requires full context)
• Editorial judgment (requires project continuity)
• Answering user questions (requires conversation flow)
• Dependency modeling (requires cross-task analysis)
• Work taking <5 minutes (delegation overhead exceeds execution time)

Model Assignment Strategy

Choose model based on task complexity and cost optimization:

Cost Optimization Principle: Use smallest model capable of task with Skills active. Skills elevate Haiku/Sonnet to achieve quality standards previously requiring larger models.

How to Assign:

• Check task's assignee field in Backlog (if project uses task assignment)
• Specify model explicitly when delegating: model='haiku' or model='opus'
• Default to Sonnet for general-purpose work if uncertain

Task Description for Skill Activation

Skills activate automatically when task description contains trigger keywords.

Pattern: [Action] + [Skill Trigger] + [Context]

Examples:

# Activates essay-research-compilation skill
"Compile comprehensive research for Essay 11 (Step 1)"

# Activates essay-first-draft skill
"Write first draft for Essay 11 based on research.md (Step 2)"

# Activates essay-critique skill
"Create comprehensive critique for Essay 11 draft (Step 3)"

Trigger Keywords by Skill Type:

• Research: "research compilation", "Step 1", "gather sources", "compile research"
• Drafting: "first draft", "Step 2", "write draft"
• Critique: "comprehensive critique", "Step 3", "analyze draft"
• Final drafts: "final draft", "Step 4", "expand to 10,000 words"

Best Practices:

• Include step number if workflow uses numbered steps
• Reference input files explicitly ("based on research.md")
• State output format ("produce draft-1.md")
• Keep description concise but keyword-rich for matching

Verifying Skill Activation

After delegating, check subagent's initial response for Skill confirmation.

Positive Confirmation:

"Using essay-research-compilation Skill to guide research compilation..."
"Activating essay-first-draft Skill for structured writing..."

If Skill Did NOT Activate:

1. Check task description for missing trigger keywords
2. Redelegate with clearer keywords: "research compilation (Step 1)" not just "gather data"
3. Confirm Skill exists in .claude/skills/ directory
4. Verify Skill's trigger patterns in SKILL.md frontmatter

Why Activation Matters: Skills provide comprehensive templates, examples, and verification checklists. Without activation, subagent lacks guidance that prevents common errors.

Delegation Workflow

1. Plan in Main Thread

• Understand full scope and dependencies
• Break work into independent subtasks if possible
• Identify which subtasks can run in parallel
• Design approach and output format

2. Create Tasks (if using Backlog)

# Create parent task
task_create(title, description, acceptanceCriteria, assignee=['model-name'])

# Create subtasks with dependencies
task_create(title, description, parentTaskId='parent-id', assignee=['haiku'])

3. Delegate to Subagent

# Single delegation
Task tool with:
  - Clear description (triggers Skills)
  - Model specification (haiku/sonnet/opus)
  - Reference to input files
  - Expected output format

# Parallel delegation (independent tasks)
Multiple Task tool calls in single message:
  - Task 1: "Research Essay 3 (Step 1)" → haiku
  - Task 2: "Research Essay 5 (Step 1)" → haiku
  - Task 3: "Research Essay 10 (Step 1)" → haiku

4. Review Output

• Check against task acceptance criteria
• Verify Skill guidelines followed (see Skill's verification checklist)
• Confirm output format matches expectations
• Test for scope creep (output should match defined scope, nothing more)

5. Commit and Document

git commit -m "[task-id] Brief description

Detailed explanation of what was completed."

Update task with commit reference:

task_edit(id='task-id', notesAppend=['Completed in commit abc123'])

Parallel Execution

Pattern: Launch multiple subagents for independent tasks in single message.

When to Use:

• Tasks have no dependencies between them
• Different essays at same workflow step
• Different sections of large document
• Independent research compilations

Example:

# Single message with 3 parallel Task tool calls:
Task 1: "Research Essay 3 Data Readiness (Step 1)" model=haiku
Task 2: "Research Essay 5 Technical Debt (Step 1)" model=haiku
Task 3: "Research Essay 10 Infrastructure (Step 1)" model=haiku

Benefits:

• Maximize throughput (3 tasks complete in parallel vs sequential)
• Efficient use of session time
• No coordination overhead (tasks are independent)

Dependency Modeling: If Task B depends on Task A output, run sequentially:

1. Delegate Task A, wait for completion
2. Review Task A output
3. Delegate Task B with reference to Task A output

Reviewing Subagent Output

Verification Checklist:

1. Completeness:

   • All acceptance criteria met?
   • Output file exists at expected path?
   • Required sections present?

2. Skill Adherence:

   • Check against Skill's verification checklist (in SKILL.md)
   • Example: essay-research-compilation requires 100% citation completeness
   • Example: essay-first-draft requires minimum 5 human experience paragraphs

3. Format:

   • Matches expected structure?
   • File naming correct?
   • No unexpected additions?

4. Scope:

   • Output matches defined scope (no scope creep)?
   • Subagent didn't make editorial decisions requiring main thread judgment?

If Quality Insufficient:

• Provide specific feedback referencing Skill section
• Example: "Section 2 needs causal analysis per essay-first-draft guidelines"
• Redelegate with clarification, not vague "improve this"

Handling Subagent Failures

Common Issues and Fixes:

Escalation Pattern:

1. First attempt: Redelegate with clarification
2. Second attempt: Provide Skill excerpt as context
3. Third attempt: Break into smaller subtasks or execute in main thread

Success Criteria

Well-delegated task produces:

• ✅ Output matching acceptance criteria exactly
• ✅ Skill guidelines followed (verified via checklist)
• ✅ No scope creep (output ≤ defined scope)
• ✅ Correct format and location
• ✅ Can commit immediately without revision

Signs of poor delegation:

• ❌ Multiple revision rounds needed
• ❌ Subagent made editorial decisions
• ❌ Output contains work outside defined scope
• ❌ Missing required sections
• ❌ Skill didn't activate (preventable with better description)

Quick Reference

Delegation Decision Tree:

Is this execution work >5 min? → NO → Do in main thread
  ↓ YES
Is scope well-defined? → NO → Plan first, then delegate
  ↓ YES
Can it run in parallel? → YES → Launch multiple subagents
  ↓ NO
Does it depend on other work? → YES → Wait for dependency
  ↓ NO
Delegate with:
  - Clear description (trigger Skills)
  - Model assignment (haiku/sonnet/opus)
  - Input files referenced
  - Output format specified

Model Selection:

• Mechanical/research → Haiku
• Structured writing → Sonnet
• Complex synthesis → Opus
• When uncertain → Sonnet (balanced default)

Parallel Pattern:

• Independent tasks → Single message, multiple Task calls
• Dependent tasks → Sequential delegation

Review Pattern:

• Check acceptance criteria
• Verify Skill checklist
• Confirm format
• Test scope