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:

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

   • Requirements analysis
   • Pattern selection
   • File structure plan
   • Complexity estimate
   • Dependencies identified
   • Validation criteria

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

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

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

2. 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)

3. Note Critical Constraints

   • Hard dependencies (must-have prerequisites)
   • Sequencing requirements (what must come first)
   • Resource constraints (tools, knowledge, time)
   • Validation requirements (how to verify)

4. 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)

2. Group Related Work

   Combine when appropriate:

   • Multiple small references → single "references" component
   • Related scripts → grouped component
   • Setup tasks → "initialization" component

3. 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)

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

1. SKILL.md Breakdown

   Component: SKILL.md
   
   Tasks:
   - Create SKILL.md with YAML frontmatter (30 min)
   - Write Overview section (1 hour
   

...