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