task-development

task-development transforms skill plans into actionable task lists with time estimates, dependencies, and optimal sequencing. It bridges the gap between high-level planning (from planning-architect) and actual implementation.

Purpose: Convert skill plans into concrete, executable tasks that can be tracked and completed systematically.

Value: Prevents missed work, ensures realistic scheduling, identifies blockers early, and enables efficient parallel work.

When to Use:

• After completing skill plan with planning-architect
• When breaking down complex skill implementations
• When coordinating work across multiple developers
• When estimating detailed implementation timelines
• When identifying critical path and parallel opportunities

Before breaking down tasks, you need:

1. Completed Skill Plan: Full skill plan from planning-architect with:

- Requirements analysis

- Pattern selection

- File structure plan

- Complexity estimate

- Dependencies identified

- Validation criteria

1. Understanding of Skill Pattern: Know which organizational pattern was chosen

1. Familiarity with Skill-Builder: Understanding of skill development process

Step 1: Analyze Skill Plan

Objective: Thoroughly understand the skill plan before breaking it down

Process:

1. Read Complete Plan

- Review all 6 sections from planning-architect

- Understand requirements and scope

- Note pattern selection and justification

- Review file structure plan

- Check dependency requirements

1. Identify High-Level Phases

- Initialization phase (directory setup)

- Content development phase (SKILL.md + references)

- Automation phase (scripts/templates)

- Validation phase (testing)

- Documentation phase (README, finalization)

1. Note Critical Constraints

- Hard dependencies (must-have prerequisites)

- Sequencing requirements (what must come first)

- Resource constraints (tools, knowledge, time)

- Validation requirements (how to verify)

1. Understand Success Criteria

- What does "done" look like?

- What are validation gates?

- What's the minimum viable version?

Output: Clear understanding of entire scope

Example:

```

Analyzing task-development plan:

• Pattern: Workflow-based (6 sequential steps)
• Files: SKILL.md + 3 references + 1 script
• Estimate: 12-15 hours
• Critical: Depends on planning-architect being complete
• Success: Can break down skill plans into tasks

```

---

Step 2: Identify Major Components

Objective: Break skill into major building blocks

Process:

1. Extract Components from Structure Plan

From the file structure plan, identify:

- SKILL.md (always a component)

- Each reference file (separate component)

- Each script (separate component)

- Each template (separate component)

- README/documentation (component)

- Validation (component)

1. Group Related Work

Combine when appropriate:

- Multiple small references → single "references" component

- Related scripts → grouped component

- Setup tasks → "initialization" component

1. Identify Cross-Cutting Concerns

Tasks that span components:

- Research (may inform multiple components)

- Design decisions (impact multiple files)

- Integration work (connecting pieces)

- Testing (validates multiple components)

1. List All Components

Create comprehensive list:

```

Major Components:

1. Initialization & Setup

2. SKILL.md Development

3. Reference Files Development

4. Script Development

5. Template Development (if applicable)

6. Documentation (README)

7. Validation & Testing

```

Output: Complete list of major components (typically 5-10)

Example (for task-development itself):

```

Major Components:

1. Initialization (directory setup)
2. SKILL.md (6-step workflow)
3. references/task-breakdown-patterns.md
4. references/estimation-techniques.md
5. references/dependency-management.md
6. scripts/break-down-tasks.py
7. README.md
8. Validation & Testing

```

See Also: [references/task-breakdown-patterns.md](references/task-breakdown-patterns.md) for component identification patterns by skill type

---

Step 3: Break Down Components into Tasks

Objective: Decompose each component into concrete, actionable tasks

Granularity Guidelines:

Task Size: Each task should be:

• Completable in 30 minutes to 4 hours
• Have clear start and end points
• Produce tangible output
• Be independently testable

Too Large: "Build all references" (break down further)

Good: "Write task-breakdown-patterns.md sections 1-3"

Too Small: "Write one paragraph" (combine with others)

Process:

For each major component:

1. SKILL.md Breakdown

```

Component: SKILL.md

Tasks:

- Create SKILL.md with YAML frontmatter (30 min)

- Write Overview section (1 hour)

- Write Prerequisites section (30 min)

- Write Step 1: [Action] (1-2 hours)

- Write Step 2: [Action] (1-2 hours)

- Write Step 3: [Action] (1-2 hours)

- Write Step 4: [Action] (1-2 hours)

- Write Step 5: [Action] (1-2 hours)

- Write Step 6: [Action] (1-2 hours)

- Write Quick Start section (1 hour)

- Write Examples section (1-2 hours)

- Add references links (30 min)

```

1. Reference Files Breakdown

```

Component: references/file-name.md

Tasks:

- Research topic (if needed) (1-3 hours)

- Create file with structure (30 min)

- Write main sections (2-4 hours per reference)

- Add examples (1-2 hours)

- Add cross-references (30 min)

```

1. Script Breakdown

```

Component: scripts/script-name.py

Tasks:

- Design script architecture (1 hour)

- Implement core functionality (2-4 hours)

- Add error handling (1 hour)

- Add --help documentation (30 min)

- Test script with examples (1 hour)

- Make executable (5 min)

```

1. Documentation Breakdown

```

Component: README.md

Tasks:

- Write overview and purpose (30 min)

- Document file structure (30 min)

- Add usage examples (30 min)

- Document dependencies (30 min)

```

1. Validation Breakdown

```

Component: Validation

Tasks:

- Run structure validation (10 min)

- Review content for completeness (30 min)

- Test all examples (1 hour)

- Fix any issues found (variable)

```

Task Template:

```

Task: [Action verb] [specific output]

Estimated Time: [X hours/minutes]

Prerequisites: [What must be done first]

Output: [What gets produced]

Validation: [How to verify complete]

```

Output: Complete task list with 15-40 tasks (depending on skill size)

Example (sample from task-development):

```

Tasks:

1. Create task-development directory structure (15 min)
2. Create SKILL.md with YAML frontmatter (30 min)
3. Write SKILL.md Overview section (1h)
4. Write SKILL.md Prerequisites section (30 min)
5. Write SKILL.md Step 1: Analyze Skill Plan (1.5h)
6. Write SKILL.md Step 2: Identify Major Components (1h)
7. Write SKILL.md Step 3: Break Down Components (2h)
8. Write SKILL.md Step 4: Estimate Each Task (1.5h)
9. Write SKILL.md Step 5: Identify Dependencies (1h)
10. Write SKILL.md Step 6: Sequence Tasks (1h)
11. Write SKILL.md Quick Start section (1h)
12. Write SKILL.md Examples section (1.5h)
13. Create references/task-breakdown-patterns.md (3h)
14. Create references/estimation-techniques.md (2.5h)
15. Create references/dependency-management.md (2h)
16. Create scripts/break-down-tasks.py (3h)
17. Create README.md (1h)
18. Validate with validate-skill.py (15 min)
19. Test with real skill plan (1h)

```

See Also: [references/task-breakdown-patterns.md](references/task-breakdown-patterns.md) for pattern-specific breakdown strategies

---

Step 4: Estimate Each Task

Objective: Assign realistic time estimates to each task

Estimation Techniques:

#### Technique 1: Historical Data

Use actual time from similar tasks:

```

Previous: "Write SKILL.md Overview" took 45 min

Current: "Write SKILL.md Overview" → estimate 45 min

```

When to Use: When you have historical data

Accuracy: High (if similar context)

---

#### Technique 2: Comparison

Compare to known reference points:

```

"Write Step 1" is similar to "Write Overview" but 2x longer

Overview = 1h → Step 1 = 2h

```

When to Use: When similar tasks exist

Accuracy: Medium-High

---

#### Technique 3: Bottom-Up

Break task further and sum:

```

"Write Step 3: Break Down Components"

• Write process description: 30 min
• Write granularity guidelines: 30 min
• Write breakdown by component: 45 min
• Add examples: 30 min
• Add templates: 15 min

Total: 2h 30min

```

When to Use: For complex or uncertain tasks

Accuracy: High (but time-consuming)

---

#### Technique 4: Three-Point Estimation

Estimate optimistic, most likely, pessimistic:

```

"Create script"

Optimistic: 2h (everything goes smoothly)

Most Likely: 3h (typical case)

Pessimistic: 5h (debugging issues)

Formula: (O + 4M + P) / 6

Estimate: (2 + 12 + 5) / 6 = 3.2h

```

When to Use: For uncertain or risky tasks

Accuracy: Good for risky tasks

---

#### Technique 5: Expert Judgment

Use experience and intuition:

```

"This feels like a 2-hour task based on my experience"

```

When to Use: When other methods not applicable

Accuracy: Variable (improves with experience)

---

Estimation Guidelines:

1. Start with Raw Estimate

- Use one of the techniques above

- Don't add buffer yet

1. Consider Complexity Factors

- Familiar work: 1.0x

- Some learning: 1.3x

- Significant new concepts: 1.5-2.0x

1. Add Task-Level Buffer

- Simple task: 10% buffer

- Medium complexity: 15% buffer

- Complex/uncertain: 25% buffer

1. Round to Reasonable Increments

- Under 1 hour: 15-min increments

- 1-4 hours: 30-min increments

- Over 4 hours: 1-hour increments

1. Validate Total

- Sum all task estimates

- Compare to planning-architect estimate

- Should be within 10-20% of plan estimate

- If significantly different, review

Output: Each task has time estimate

Example:

```

1. Create directory structure: 15 min
2. Create SKILL.md frontmatter: 30 min
3. Write Overview: 1h
4. Write Prerequisites: 30 min
5. Write Step 1: 1.5h
6. Write Step 2: 1h
7. Write Step 3: 2h

...

Total: 14.5 hours (within 12-15h plan estimate ✓)

```

See Also: [references/estimation-techniques.md](references/estimation-techniques.md) for comprehensive estimation methods

---

Step 5: Identify Dependencies

Objective: Determine which tasks must be completed before others can start

Dependency Types:

#### Type 1: Hard Dependencies (Blocking)

Task B cannot start until Task A is complete:

```

Task A: Create SKILL.md structure

Task B: Write Step 1 in SKILL.md

Dependency: B depends on A (hard)

```

Indicators:

• Task B needs output from Task A
• Task B operates on files created by Task A
• Task B builds on concepts from Task A

---

#### Type 2: Soft Dependencies (Helpful)

Task B is easier if Task A is done, but not required:

```

Task A: Write SKILL.md workflow

Task B: Write reference guides

Dependency: B benefits from A (soft)

Reason: Seeing SKILL.md helps write consistent references

```

Indicators:

• Task B references Task A's output
• Task B is easier with Task A's context
• Task B may need minor updates after Task A

---

#### Type 3: No Dependency (Parallel)

Tasks can be done in any order:

```

Task A: Write reference-1.md

Task B: Write reference-2.md

Dependency: None (parallel)

```

Indicators:

• Tasks operate on different files
• Tasks have no shared dependencies
• Tasks don't reference each other

---

Process:

For each task, ask:

1. What must exist before I start this task?

- Files: Which files must be created first?

- Content: What content must be written first?

- Decisions: What must be decided first?

1. What tasks produce those prerequisites?

- Identify the tasks that create needed inputs

1. Are dependencies hard or soft?

- Hard: Cannot start without it

- Soft: Easier with it, but can proceed

1. Can this task be parallelized?

- If no dependencies, can be done anytime

- Enables parallel work

Dependency Notation:

```

Task ID | Task Name | Dependencies

--------|-----------|-------------

1 | Create dir| (none)

2 | SKILL.md | 1

3 | Overview | 2

4 | Step 1 | 2, 3

5 | Ref-1 | 2 (soft)

6 | Ref-2 | 2 (soft)

7 | Script | 2, 5, 6

8 | README | 2-7

9 | Validate | 8

```

Output: Dependency map showing task relationships

Example (task-development):

```

Dependencies:

• Tasks 1-2: Sequential (create → scaffold)
• Tasks 3-12: Sequential (SKILL.md sections in order)
• Tasks 13-15: Parallel (references independent)
• Task 16: Depends on 13-15 (script uses reference patterns)
• Task 17: Depends on 2-16 (README describes everything)
• Task 18-19: Depends on 17 (validate complete skill)

```

Critical Path: Longest chain of dependent tasks

```

1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 10 → 11 → 12 → 17 → 18 → 19

(14.5 hours on critical path)

```

Parallel Opportunities:

```

Tasks 13, 14, 15 can be done in parallel (7.5h total)

If serial: 7.5h

If parallel: 3h (taking longest reference)

Savings: 4.5h with parallel work!

```

See Also: [references/dependency-management.md](references/dependency-management.md) for advanced dependency analysis

---

Step 6: Sequence Tasks Optimally

Objective: Arrange tasks in optimal execution order

Sequencing Strategies:

#### Strategy 1: Dependency-Driven (Primary)

Rule: Always complete dependencies before dependent tasks

```

If Task B depends on Task A:

Sequence: A → B (not B → A)

If Task C depends on A and B:

Sequence: A → B → C (both A and B before C)

```

---

#### Strategy 2: Parallel Optimization

Rule: Execute independent tasks in parallel when possible

```

Tasks with no dependencies:

Execute: Simultaneously (if resources available)

Example:

Task A: Write reference-1.md (3h)

Task B: Write reference-2.md (2.5h)

Task C: Write reference-3.md (2h)

Serial: 7.5h

Parallel: 3h (longest task duration)

```

---

#### Strategy 3: Risk-First

Rule: Handle high-risk tasks early

```

High-risk tasks:

• New technology/unfamiliar domain
• Complex algorithms
• External dependencies
• Uncertain estimates

Sequence: Do these first to:

• Identify blockers early
• Adjust plan if needed
• Reduce late-stage surprises

```

---

#### Strategy 4: Quick Wins

Rule: Include some easy wins early

```

Benefits:

• Build momentum
• Provide early progress
• Boost confidence

Balance with risk-first approach

```

---

#### Strategy 5: Logical Grouping

Rule: Group related tasks together

```

Group by:

• Component (all SKILL.md tasks together)
• Type (all writing together, all coding together)
• Context (related functionality)

Benefits:

• Reduced context switching
• Better flow
• More efficient work

```

---

Sequencing Process:

1. Create Phases

```

Phase 1: Initialization (setup tasks)

Phase 2: Core Development (main content)

Phase 3: Enhancement (references, scripts)

Phase 4: Finalization (docs, validation)

```

1. Within Each Phase, Order by:

- Dependencies (must-do-first)

- Risk (high-risk early)

- Logic (related tasks together)

- Parallelization (independent tasks marked)

1. Mark Parallel Opportunities

```

Task 13 ║ Write reference-1.md (3h)

Task 14 ║ Write reference-2.md (2.5h) } Parallel

Task 15 ║ Write reference-3.md (2h)

```

1. Identify Milestones

```

Milestone 1: SKILL.md complete

Milestone 2: All references complete

Milestone 3: Scripts complete

Milestone 4: Validated and ready

```

Output: Sequenced task list with phases and parallel markers

Example (task-development sequenced):

```

PHASE 1: INITIALIZATION (15 min)

1. Create task-development directory structure [15 min]

PHASE 2: SKILL.MD CORE (9.5h)

1. Create SKILL.md with YAML frontmatter [30 min] → depends on 1
2. Write Overview section [1h] → depends on 2
3. Write Prerequisites section [30 min] → depends on 2
4. Write Step 1: Analyze Skill Plan [1.5h] → depends on 2
5. Write Step 2: Identify Components [1h] → depends on 5
6. Write Step 3: Break Down Tasks [2h] → depends on 6
7. Write Step 4: Estimate Tasks [1.5h] → depends on 7
8. Write Step 5: Identify Dependencies [1h] → depends on 8
9. Write Step 6: Sequence Tasks [1h] → depends on 9

MILESTONE: Core workflow complete

1. Write Quick Start section [1h] → depends on 2-10
2. Write Examples section [1.5h] → depends on 2-10

PHASE 3: REFERENCES (Parallel: 3h if parallel, 7.5h if serial)

1. ║ Create task-breakdown-patterns.md [3h] → depends on 2
2. ║ Create estimation-techniques.md [2.5h] → depends on 2
3. ║ Create dependency-management.md [2h] → depends on 2

MILESTONE: Documentation complete

PHASE 4: AUTOMATION (3h)

1. Create break-down-tasks.py [3h] → depends on 2, 13-15

PHASE 5: FINALIZATION (2.25h)

1. Create README.md [1h] → depends on all above
2. Validate with validate-skill.py [15 min] → depends on 17
3. Test with real skill plan [1h] → depends on 18

MILESTONE: Skill complete and validated

TOTAL TIME:

Serial: 14.5 hours

Optimal (with parallel refs): 11.5 hours

Savings: 3 hours (21%)

```

---

Prerequisites

• Completed skill plan from planning-architect
• 30 minutes available

Rapid Breakdown Process

10 minutes: Analyze & Identify

1. Read skill plan quickly (5 min)
2. List major components from structure plan (5 min)

15 minutes: Break Down & Estimate

1. For each component, list 2-5 tasks (10 min)
2. Add rough time estimates (5 min)

5 minutes: Dependencies & Sequence

1. Mark obvious dependencies (3 min)
2. Put tasks in logical order (2 min)

Result: Actionable task list ready for implementation

Example: 30-Minute Breakdown

Skill: simple-calculator

Components (2 min):

• SKILL.md
• README.md
• Validation

Tasks (10 min):

1. Create directory [10 min]
2. SKILL.md: Frontmatter + overview [30 min]
3. SKILL.md: Operations section [1h]
4. SKILL.md: Examples [30 min]
5. README.md [30 min]
6. Validate [15 min]

Dependencies (3 min):

• 2 depends on 1
• 3-4 depend on 2
• 5 depends on 2-4
• 6 depends on 5

Sequence (2 min):

1 → 2 → 3 → 4 → 5 → 6

Total: ~3 hours

Done! Ready to implement.

---

Example 1: Simple Skill Breakdown

Skill: troubleshooting-guide (task-based, 8 errors)

Plan Summary:

• Pattern: Task-based
• Files: SKILL.md + 1 reference
• Estimate: 8 hours

Components:

1. SKILL.md (task-based format)
2. references/advanced-troubleshooting.md
3. README.md
4. Validation

Tasks (18 total):

```

PHASE 1: SETUP (15 min)

1. Create directory structure [15 min]

PHASE 2: SKILL.MD (4.5h)

1. Create SKILL.md frontmatter [30 min]
2. Write Overview [30 min]
3. Write Error 1: [Name] [30 min]
4. Write Error 2: [Name] [30 min]
5. Write Error 3: [Name] [30 min]
6. Write Error 4: [Name] [30 min]
7. Write Error 5: [Name] [30 min]
8. Write Error 6: [Name] [30 min]
9. Write Error 7: [Name] [30 min]
10. Write Error 8: [Name] [30 min]
11. Write Quick Start [30 min]

PHASE 3: REFERENCES (2h)

1. Create advanced-troubleshooting.md [2h]

PHASE 4: FINALIZATION (1.25h)

1. Create README.md [45 min]
2. Validate structure [15 min]
3. Test all error cases [30 min]

Total: 8 hours ✓ (matches estimate)

```

Dependencies:

• Sequential: 1 → 2 → 3-12 → 13 → 14 → 15 → 16
• Parallel: Tasks 4-11 (8 error sections) could be parallel

---

Example 2: Medium Skill Breakdown

Skill: api-integration (workflow-based)

Plan Summary:

• Pattern: Workflow-based (4 steps)
• Files: SKILL.md + 3 references + 1 script
• Estimate: 15 hours

Components:

1. SKILL.md (4-step workflow)
2. references/authentication-guide.md
3. references/endpoints-guide.md
4. references/error-handling-guide.md
5. scripts/test-api.py
6. README.md
7. Validation

Tasks (22 total):

```

PHASE 1: SETUP (15 min)

1. Create directory structure [15 min]

PHASE 2: SKILL.MD (6h)

1. Create frontmatter + overview [1h]
2. Write Prerequisites [30 min]
3. Write Step 1: Authentication [1.5h]
4. Write Step 2: Fetch Data [1h]
5. Write Step 3: Process Response [1h]
6. Write Step 4: Error Handling [1h]
7. Write Quick Start [1h]
8. Write Examples [1.5h]

MILESTONE: Core workflow done

PHASE 3: REFERENCES (5h - can be parallel)

1. ║ Create authentication-guide.md [2h]
2. ║ Create endpoints-guide.md [1.5h]
3. ║ Create error-handling-guide.md [1.5h]

PHASE 4: AUTOMATION (2h)

1. Design test-api.py [30 min]
2. Implement core functionality [1h]
3. Add error handling [30 min]
4. Make executable + test [15 min]

PHASE 5: FINALIZATION (1.75h)

1. Create README.md [1h]
2. Validate structure [15 min]
3. Test workflow with real API [1h]
4. Fix any issues [variable]

Total: 15 hours ✓

With parallel refs: 12.5 hours (2.5h savings)

```

---

Example 3: Complex Skill Breakdown

Skill: testing-framework (capabilities-based)

Plan Summary:

• Pattern: Capabilities-based (3 capabilities)
• Files: SKILL.md + 5 references + 3 scripts
• Estimate: 28 hours

Components:

1. SKILL.md (capabilities structure)
2. references/unit-testing-guide.md
3. references/integration-testing-guide.md
4. references/e2e-testing-guide.md
5. references/test-data-guide.md
6. references/ci-integration-guide.md
7. scripts/init-tests.py
8. scripts/run-tests.py
9. scripts/generate-report.py
10. README.md
11. Validation

Tasks (35+ total):

```

PHASE 1: SETUP (20 min)

1. Create directory structure [20 min]

PHASE 2: SKILL.MD (10h)

1. Create frontmatter + overview [1.5h]
2. Write Capability 1: Unit Testing [2h]
3. Write Capability 2: Integration Testing [2h]
4. Write Capability 3: E2E Testing [2h]
5. Write Integration Patterns [1.5h]
6. Write Quick Start [1h]
7. Write Examples [2h]

PHASE 3: REFERENCES (10h - parallel)

1. ║ unit-testing-guide.md [2.5h]
2. ║ integration-testing-guide.md [2.5h]
3. ║ e2e-testing-guide.md [3h]
4. ║ test-data-guide.md [1.5h]
5. ║ ci-integration-guide.md [1.5h]

PHASE 4: SCRIPTS (7h - can be parallel)

1. ║ init-tests.py [2h]
2. ║ run-tests.py [3h]
3. ║ generate-report.py [2h]

PHASE 5: FINALIZATION (2h)

1. Create README.md [1h]
2. Validate structure [15 min]
3. Integration testing [1.5h]
4. Fix issues [variable]

Total: 29 hours

With optimal parallelization: 20 hours (9h savings!)

```

---

Recommended Format

```markdown

# Task List: [skill-name]

Generated: [date]

Based on: [skill-name]-plan.md

Total Estimate: [X-Y hours]

---

• Total Tasks: [N]
• Serial Time: [X hours]
• Parallel Time: [Y hours] (if applicable)
• Estimated Savings: [Z hours] with parallelization

---

Phase 1: [Phase Name]

Duration: [X hours]

| # | Task | Time | Dependencies | Status |

|---|------|------|--------------|--------|

| 1 | [Task description] | [Xh] | (none) | ⬜ |

| 2 | [Task description] | [Xh] | 1 | ⬜ |

Phase 2: [Phase Name]

Duration: [X hours]

| # | Task | Time | Dependencies | Status |

|---|------|------|--------------|--------|

| 3 | [Task description] | [Xh] | 2 | ⬜ |

| 4 ║ [Task description] | [Xh] | 2 | ⬜ |

| 5 ║ [Task description] | [Xh] | 2 | ⬜ |

Note: Tasks 4-5 can be done in parallel (║ marker)

[Continue for all phases...]

---

• [ ] Milestone 1: [Description] (after task X)
• [ ] Milestone 2: [Description] (after task Y)
• [ ] Milestone 3: [Description] (after task Z)

---

Tasks that must be done sequentially (longest chain):

```

1 → 2 → 3 → 6 → 9 → 12 → 15

Duration: [X hours]

```

---

Opportunity 1: Tasks 4-5 (Phase 2)

• Serial: [X hours]
• Parallel: [Y hours]
• Savings: [Z hours]

Opportunity 2: Tasks 10-12 (Phase 3)

• Serial: [X hours]
• Parallel: [Y hours]
• Savings: [Z hours]

Total Parallelization Savings: [Z hours] ([N%])

---

[Any special notes, risks, or considerations]

```

---

Task Breakdown Best Practices

1. Right Granularity

- Tasks should be 30 min to 4 hours

- Too large = hard to estimate and track

- Too small = overhead and micro-management

1. Clear Outputs

- Each task produces tangible output

- Output should be verifiable

- "Done" should be unambiguous

1. Realistic Estimates

- Use historical data when available

- Add appropriate buffers

- Sum should match plan estimate (±20%)

1. Dependencies Matter

- Identify all hard dependencies

- Note soft dependencies for context

- Enable parallelization opportunities

1. Sequencing for Success

- Dependencies first (always)

- High-risk tasks early (de-risk)

- Quick wins included (momentum)

- Logical grouping (efficiency)

Common Mistakes

1. Too Granular

- Problem: 100+ micro-tasks

- Fix: Combine related tasks

1. Too Coarse

- Problem: "Build entire skill" (1 task)

- Fix: Break down to component level

1. Ignoring Dependencies

- Problem: Parallel schedule for sequential work

- Fix: Careful dependency analysis

1. Optimistic Estimates

- Problem: No buffers, ideal-case thinking

- Fix: Use buffers, three-point estimation

1. No Validation Tasks

- Problem: "Done" but untested

- Fix: Include validation tasks explicitly

---

Comprehensive guides for each task development step:

• [Task Breakdown Patterns](references/task-breakdown-patterns.md) - Component identification patterns for each skill pattern type, granularity guidelines, breakdown templates, and common patterns by domain.

• [Estimation Techniques](references/estimation-techniques.md) - Detailed estimation methods (historical, comparison, bottom-up, three-point, expert judgment), calibration techniques, accuracy improvement, and estimation worksheets.

• [Dependency Management](references/dependency-management.md) - Dependency type identification, critical path analysis, parallel optimization strategies, circular dependency resolution, and dependency visualization techniques.

---

Use the task breakdown automation script:

```bash

# Break down skill from plan file

python scripts/break-down-tasks.py skill-plan.md

# Interactive mode

python scripts/break-down-tasks.py --interactive

# Specify output file

python scripts/break-down-tasks.py skill-plan.md --output tasks.md

```

See script help:

```bash

python scripts/break-down-tasks.py --help

```

---

A successful task breakdown includes:

✅ Complete Task List

• All components from plan broken down
• 15-40 tasks (typical range)
• Tasks are right granularity (30min-4h)

✅ Accurate Estimates

• Each task has time estimate
• Total matches plan estimate (±20%)
• Buffers included appropriately

✅ Clear Dependencies

• All hard dependencies identified
• Dependencies enable sequencing
• Parallel opportunities noted

✅ Optimal Sequence

• Dependencies respected
• Logical phases defined
• Milestones identified
• Critical path clear

✅ Actionable Output

• Task list ready for todo-management
• Each task is concrete and clear
• Verification criteria defined

---

After completing task breakdown:

1. Review Task List

- Validate completeness

- Check estimates seem reasonable

- Verify dependencies are correct

1. Feed to todo-management

- Use task list to create todos

- Track progress as you work

- Update estimates based on actuals

1. Begin Implementation

- Start with Phase 1

- Complete tasks in sequence

- Mark tasks complete as you go

1. Track & Adjust

- Compare actual vs estimated time

- Adjust remaining estimates if needed

- Learn for better estimation next time

---

The 5-Step Task Breakdown Process

| Step | Focus | Key Output | Time |

|------|-------|------------|------|

| 1. Analyze Plan | Understand structure, complexity, scope | Component understanding | 15-30m |

| 2. Identify Components | List all deliverables from plan | Component list | 20-40m |

| 3. Break Into Tasks | Granular tasks (30min-4h each) | Task list with estimates | 45-90m |

| 4. Sequence & Dependencies | Order tasks, identify parallel work | Sequenced task list | 30-45m |

| 5. Create Task Document | Consolidated breakdown | Complete task document | 20-30m |

Total Task Breakdown Time: 2-4 hours

Task Granularity Guidelines

| Too Small | Just Right | Too Large |

|-----------|------------|-----------|

| <30 min | 30min - 4h | >4 hours |

| Micro-tasks | Focused work | Needs breakdown |

| High overhead | Trackable | Hard to estimate |

Sweet Spot: 1-2 hour tasks (most trackable and estimable)

Phase Organization Patterns

| Pattern | When to Use | Example |

|---------|-------------|---------|

| By File | Many independent files | Phase 1: SKILL.md, Phase 2: References, Phase 3: Scripts |

| By Layer | Architectural layers | Phase 1: Foundation, Phase 2: Core, Phase 3: Advanced |

| By Feature | Feature-based development | Phase 1: Auth, Phase 2: Data, Phase 3: UI |

| Sequential | Strong dependencies | Phase 1→2→3 (each builds on previous) |

Dependency Types

| Type | Meaning | Example | Impact |

|------|---------|---------|--------|

| Hard | B cannot start until A done | Structure before content | Serial work |

| Soft | B easier if A done first | Having plan helps writing | Preference |

| Parallel | A and B independent | Separate files | Time savings |

Estimation Quick Tips

• Historical: Use past similar tasks for estimates
• Bottom-up: Sum component estimates (detailed but time-consuming)
• Comparison: Compare to known reference tasks
• Buffer: Add 15-20% for unknowns
• Three-Point: (Optimistic + 4×Likely + Pessimistic) / 6

Common Task Patterns

Foundation Phase (Always first):

• Create directory structure
• Write YAML frontmatter
• Set up skeleton

Core Content Phase (Main work):

• Write each section/step/operation
• Build references
• Create examples

Enhancement Phase (Polish):

• Add best practices
• Write troubleshooting
• Create quick reference

Finalization Phase (Always last):

• Validation
• Testing
• Documentation

Complexity Indicators

Simple (15-25 tasks, 8-12h):

• Single SKILL.md or 1-2 references
• Few dependencies
• Clear requirements

Medium (25-35 tasks, 15-25h):

• Multiple references
• Some automation scripts
• Moderate complexity

Complex (35-50+ tasks, 30-50h):

• Extensive references (5-10 files)
• Multiple automation scripts
• High complexity, many dependencies

Quick Breakdown Checklist

• [ ] All plan components identified
• [ ] Tasks 30min-4h each (right granularity)
• [ ] 15-50 tasks total (typical range)
• [ ] Each task has estimate
• [ ] Total estimate ±20% of plan estimate
• [ ] All dependencies identified
• [ ] Sequence respects dependencies
• [ ] Parallel opportunities noted
• [ ] Phases logically organized
• [ ] Validation tasks included

For More Information

• Breakdown patterns: references/task-breakdown-patterns.md
• Estimation techniques: references/estimation-techniques.md
• Dependency management: references/dependency-management.md
• Automation: scripts/break-down-tasks.py --help

---

task-development is the bridge between planning and implementation. Use it to transform skill plans into concrete, executable tasks that lead to successful skill development.