microtask-decomposition

name: microtask-decomposition description: Level 2+ task decomposition. Use when a single task from tasks.md is STILL too complex (affects 3+ files or requires multiple logic blocks). Breaks tasks into MICROTASKS (1 file/function each) for granular implementation. NOT for initial task breakdown - OpenSpec already does that. license: MIT metadata: author: AC Framework version: "1.0"

Microtask Decomposition

Level 2+ Decomposition: From Tasks to Microtasks

Divide complex tasks from tasks.md into atomic, single-file microtasks for granular tracking and implementation.

⚠️ CRITICAL: When to Use This Skill

Use microtask-decomposition when:

A single task from tasks.md affects 3+ files
A task requires multiple distinct logic blocks
You need to parallelize sub-task execution
A task is estimated at >2 hours of work
The task has internal dependencies that can be sequenced

Do NOT use when:

Creating initial tasks (use openspec-new-change or openspec-ff-change)
Task affects only 1-2 files (implement directly)
Task is simple and straightforward

The Hierarchy:

Change (openspec-new-change)
  └─> Tasks (tasks.md) - Level 1
      └─> Microtasks (this skill) - Level 2+
          └─> Implementation

Instructions

Step 1: Identify the Complex Task

Select ONE task from tasks.md that meets decomposition criteria:

Affects 3+ files
Contains multiple distinct operations
Estimated effort >2 hours
Has internal sequential dependencies

Example complex task:

- [ ] Implement user authentication with login, signup, password reset, and email verification

→ This affects multiple files and operations = DECOMPOSE

Step 2: Analyze Task Components

Break down the task into its atomic operations:

List all files touched
List all functions/methods needed
Identify data flow between components
Mark dependencies (what must happen before what)

Step 3: Create Microtasks

Each microtask must be:

Single file (or 1-2 closely related files)
Single purpose (one function or cohesive set)
Independently testable
< 1 hour estimated effort
Clear completion criteria

Microtask format:

microtask:
  id: "mt-[number]"
  parent_task: "task-id-from-tasks.md"
  name: "Brief descriptive name"
  description: "What this microtask accomplishes"
  files:
    - path/to/single-file.ext
  dependencies:
    - "mt-[prerequisite]"
  estimated_time: "30min"
  acceptance_criteria:
    - "Criterion 1"
    - "Criterion 2"

Step 4: Map Dependencies

Create a dependency graph:

mt-1: Database schema
  └─> mt-2: User model
      ├─> mt-3: Login endpoint
      ├─> mt-4: Signup endpoint
      └─> mt-5: Password reset service
          └─> mt-6: Email verification
              └─> mt-7: Integration tests

Step 5: Assign Execution Order

Group microtasks into execution phases:

Phase 1 (Foundation - Sequential):

mt-1, mt-2

Phase 2 (Core Features - Parallel):

mt-3, mt-4 (both depend on Phase 1)

Phase 3 (Extended Features - Sequential):

mt-5 (depends on Phase 2)

Phase 4 (Integration):

mt-6, mt-7 (depends on Phase 3)

Output Format

## Microtask Decomposition Summary

**Parent Task**: [task description from tasks.md]
**Task ID**: [task identifier]
**Total Microtasks**: [N]
**Estimated Total Time**: [X hours]
**Execution Phases**: [N phases]

---

### Microtask List

#### Phase 1: Foundation

**mt-1: [Name]**
- **Files**: `file.ext`
- **Description**: What to implement
- **Dependencies**: None
- **Estimated**: 30min
- **Acceptance Criteria**:
  - [ ] Criterion 1
  - [ ] Criterion 2

**mt-2: [Name]**
- **Files**: `file.ext`
- **Description**: What to implement
- **Dependencies**: mt-1
- **Estimated**: 45min
- **Acceptance Criteria**:
  - [ ] Criterion 1

#### Phase 2: Core Features (Parallel)

**mt-3: [Name]**
- **Files**: `file.ext`
- **Description**: What to implement
- **Dependencies**: mt-2
- **Estimated**: 30min
- **Acceptance Criteria**:
  - [ ] Criterion 1

[Continue for all phases...]

---

### Dependency Graph

[ASCII art showing dependency relationships]


---

### Execution Plan

**Phase 1** (Foundation - Do first):
- [ ] mt-1
- [ ] mt-2

**Phase 2** (Core - Parallelizable):
- [ ] mt-3 (depends: mt-2)
- [ ] mt-4 (depends: mt-2)

**Phase 3** (Extended - Sequential):
- [ ] mt-5 (depends: mt-3, mt-4)

**Phase 4** (Final):
- [ ] mt-6 (depends: mt-5)
- [ ] mt-7 (depends: mt-6)

---

### Parent Task Update

After decomposition, update the parent task in `tasks.md`:

```markdown
- [ ] Implement user authentication [DECOMPOSED INTO MICROTASKS]
  - [ ] Phase 1: Foundation
    - [ ] mt-1: Database schema
    - [ ] mt-2: User model
  - [ ] Phase 2: Core Features
    - [ ] mt-3: Login endpoint
    - [ ] mt-4: Signup endpoint
  - [ ] Phase 3: Extended Features
    - [ ] mt-5: Password reset service
    - [ ] mt-6: Email verification
  - [ ] Phase 4: Integration
    - [ ] mt-7: Integration tests


---

## Example

### Parent Task (from tasks.md):
```markdown
- [ ] Build complete authentication system with login, signup, password reset, email verification, and session management