Task Development

Overview

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

Prerequisites

Before breaking down tasks, you need:

Completed Skill Plan: Full skill plan from planning-architect with:
- Requirements analysis
- Pattern selection
- File structure plan
- Complexity estimate
- Dependencies identified
- Validation criteria
Understanding of Skill Pattern: Know which organizational pattern was chosen
Familiarity with Skill-Builder: Understanding of skill development process

Task Development Workflow

Step 1: Analyze Skill Plan

Objective: Thoroughly understand the skill plan before breaking it down

Process:

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
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)
Note Critical Constraints
- Hard dependencies (must-have prerequisites)
- Sequencing requirements (what must come first)
- Resource constraints (tools, knowledge, time)
- Validation requirements (how to verify)
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:

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)
Group Related Work

Combine when appropriate:
- Multiple small references → single "references" component
- Related scripts → grouped component
- Setup tasks → "initialization" component
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)

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 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:

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)

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)

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)

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)

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 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:

Start with Raw Estimate
- Use one of the techniques above
- Don't add buffer yet
Consider Complexity Factors
- Familiar work: 1.0x
- Some learning: 1.3x
- Significant new concepts: 1.5-2.0x
Add Task-Level Buffer
- Simple task: 10% buffer
- Medium complexity: 15% buffer
- Complex/uncertain: 25% buffer
Round to Reasonable Increments
- Under 1 hour: 15-min increments
- 1-4 hours: 30-min increments
- Over 4 hours: 1-hour increments
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 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:

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?
What tasks produce those prerequisites?
- Identify the tasks that create needed inputs
Are dependencies hard or soft?
- Hard: Cannot start without it
- Soft: Easier with it, but can proceed
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 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:

Create Phases

Phase 1: Initialization (setup tasks)
Phase 2: Core Development (main content)
Phase 3: Enhancement (references, scripts)
Phase 4: Finalization (docs, validation)

Within Each Phase, Order by:
- Dependencies (must-do-first)
- Risk (high-risk early)
- Logic (related tasks together)
- Parallelization (independent tasks marked)

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)

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

MILESTONE: Core workflow complete

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

PHASE 3: REFERENCES (Parallel: 3h if parallel, 7.5h if serial)
13. ║ Create task-breakdown-patterns.md [3h] → depends on 2
14. ║ Create estimation-techniques.md [2.5h] → depends on 2
15. ║ Create dependency-management.md [2h] → depends on 2

MILESTONE: Documentation complete

PHASE 4: AUTOMATION (3h)
16. Create break-down-tasks.py [3h] → depends on 2, 13-15

PHASE 5: FINALIZATION (2.25h)
17. Create README.md [1h] → depends on all above
18. Validate with validate-skill.py [15 min] → depends on 17
19. 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%)

Quick Start: Break Down a Skill in 30 Minutes

Prerequisites

Completed skill plan from planning-architect
30 minutes available

Rapid Breakdown Process

10 minutes: Analyze & Identify

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

15 minutes: Break Down & Estimate 3. For each component, list 2-5 tasks (10 min) 4. Add rough time estimates (5 min)

5 minutes: Dependencies & Sequence 5. Mark obvious dependencies (3 min) 6. 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):

Create directory [10 min]
SKILL.md: Frontmatter + overview [30 min]
SKILL.md: Operations section [1h]
SKILL.md: Examples [30 min]
README.md [30 min]
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.

Examples

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:

SKILL.md (task-based format)
references/advanced-troubleshooting.md
README.md
Validation

Tasks (18 total):

PHASE 1: SETUP (15 min)
1. Create directory structure [15 min]

PHASE 2: SKILL.MD (4.5h)
2. Create SKILL.md frontmatter [30 min]
3. Write Overview [30 min]
4. Write Error 1: [Name] [30 min]
5. Write Error 2: [Name] [30 min]
6. Write Error 3: [Name] [30 min]
7. Write Error 4: [Name] [30 min]
8. Write Error 5: [Name] [30 min]
9. Write Error 6: [Name] [30 min]
10. Write Error 7: [Name] [30 min]
11. Write Error 8: [Name] [30 min]
12. Write Quick Start [30 min]

PHASE 3: REFERENCES (2h)
13. Create advanced-troubleshooting.md [2h]

PHASE 4: FINALIZATION (1.25h)
14. Create README.md [45 min]
15. Validate structure [15 min]
16. 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:

SKILL.md (4-step workflow)
references/authentication-guide.md
references/endpoints-guide.md
references/error-handling-guide.md
scripts/test-api.py
README.md
Validation

Tasks (22 total):

PHASE 1: SETUP (15 min)
1. Create directory structure [15 min]

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

MILESTONE: Core workflow done

PHASE 3: REFERENCES (5h - can be parallel)
10. ║ Create authentication-guide.md [2h]
11. ║ Create endpoints-guide.md [1.5h]
12. ║ Create error-handling-guide.md [1.5h]

PHASE 4: AUTOMATION (2h)
13. Design test-api.py [30 min]
14. Implement core functionality [1h]
15. Add error handling [30 min]
16. Make executable + test [15 min]

PHASE 5: FINALIZATION (1.75h)
17. Create README.md [1h]
18. Validate structure [15 min]
19. Test workflow with real API [1h]
20. 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:

SKILL.md (capabilities structure)
references/unit-testing-guide.md
references/integration-testing-guide.md
references/e2e-testing-guide.md
references/test-data-guide.md
references/ci-integration-guide.md
scripts/init-tests.py
scripts/run-tests.py
scripts/generate-report.py
README.md
Validation

Tasks (35+ total):

PHASE 1: SETUP (20 min)
1. Create directory structure [20 min]

PHASE 2: SKILL.MD (10h)
2. Create frontmatter + overview [1.5h]
3. Write Capability 1: Unit Testing [2h]
4. Write Capability 2: Integration Testing [2h]
5. Write Capability 3: E2E Testing [2h]
6. Write Integration Patterns [1.5h]
7. Write Quick Start [1h]
8. Write Examples [2h]

PHASE 3: REFERENCES (10h - parallel)
9.  ║ unit-testing-guide.md [2.5h]
10. ║ integration-testing-guide.md [2.5h]
11. ║ e2e-testing-guide.md [3h]
12. ║ test-data-guide.md [1.5h]
13. ║ ci-integration-guide.md [1.5h]

PHASE 4: SCRIPTS (7h - can be parallel)
14. ║ init-tests.py [2h]
15. ║ run-tests.py [3h]
16. ║ generate-report.py [2h]

PHASE 5: FINALIZATION (2h)
17. Create README.md [1h]
18. Validate structure [15 min]
19. Integration testing [1.5h]
20. Fix issues [variable]

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

Task List Output Format

Recommended Format

# Task List: [skill-name]

**Generated**: [date]
**Based on**: [skill-name]-plan.md
**Total Estimate**: [X-Y hours]

---

## Summary

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

---

## Task List

### 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...]

---

## Milestones

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

---

## Critical Path

Tasks that must be done sequentially (longest chain):

1 → 2 → 3 → 6 → 9 → 12 → 15 Duration: [X hours]


---

## Parallel Opportunities

**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%])

---

## Notes

[Any special notes, risks, or considerations]

Best Practices

Task Breakdown Best Practices

Right Granularity
- Tasks should be 30 min to 4 hours
- Too large = hard to estimate and track
- Too small = overhead and micro-management
Clear Outputs
- Each task produces tangible output
- Output should be verifiable
- "Done" should be unambiguous
Realistic Estimates
- Use historical data when available
- Add appropriate buffers
- Sum should match plan estimate (±20%)
Dependencies Matter
- Identify all hard dependencies
- Note soft dependencies for context
- Enable parallelization opportunities
Sequencing for Success
- Dependencies first (always)
- High-risk tasks early (de-risk)
- Quick wins included (momentum)
- Logical grouping (efficiency)

Common Mistakes

Too Granular
- Problem: 100+ micro-tasks
- Fix: Combine related tasks
Too Coarse
- Problem: "Build entire skill" (1 task)
- Fix: Break down to component level
Ignoring Dependencies
- Problem: Parallel schedule for sequential work
- Fix: Careful dependency analysis
Optimistic Estimates
- Problem: No buffers, ideal-case thinking
- Fix: Use buffers, three-point estimation
No Validation Tasks
- Problem: "Done" but untested
- Fix: Include validation tasks explicitly

References

Comprehensive guides for each task development step:

Task Breakdown Patterns - Component identification patterns for each skill pattern type, granularity guidelines, breakdown templates, and common patterns by domain.
Estimation Techniques - Detailed estimation methods (historical, comparison, bottom-up, three-point, expert judgment), calibration techniques, accuracy improvement, and estimation worksheets.
Dependency Management - Dependency type identification, critical path analysis, parallel optimization strategies, circular dependency resolution, and dependency visualization techniques.

Automation

Use the task breakdown automation script:

# 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:

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

Success Criteria

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

Next Steps

After completing task breakdown:

Review Task List
- Validate completeness
- Check estimates seem reasonable
- Verify dependencies are correct
Feed to todo-management
- Use task list to create todos
- Track progress as you work
- Update estimates based on actuals
Begin Implementation
- Start with Phase 1
- Complete tasks in sequence
- Mark tasks complete as you go
Track & Adjust
- Compare actual vs estimated time
- Adjust remaining estimates if needed
- Learn for better estimation next time

Quick Reference

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

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.