/task-breakdown

name: task-breakdown
description: Convert technical designs into actionable, sequenced implementation tasks. Create clear coding tasks that enable incremental progress, respect dependencies, and provide a roadmap for systematic feature development.
license: MIT
compatibility: Claude Code, Cursor, VS Code, Windsurf
metadata:
  category: methodology
  complexity: intermediate
  author: Kiro Team
  version: "1.0.0"

Task Breakdown

Transform designs into actionable implementation plans. This skill teaches how to create well-structured task lists that enable efficient, systematic development.

When to Use This Skill

Use task breakdown when:

• Design phase is complete and approved
• Ready to begin implementation
• Need to coordinate work across developers
• Want to track incremental progress
• Planning sprints or work assignments

Task Structure

Two-Level Hierarchy

- [ ] 1. [Epic/Major Component]
- [ ] 1.1 [Specific implementation task]
  - [Implementation details]
  - [Files/components to create]
  - _Requirements: [Requirement references]_
- [ ] 1.2 [Next specific task]
  - [Details]
  - _Requirements: [References]_

- [ ] 2. [Next Epic/Major Component]
- [ ] 2.1 [Specific task]

Task Specification Elements

Each task should include: 1. **Clear Objective:** What specific code to write/modify 2. **Implementation Details:** Files, components, functions 3. **Requirements Reference:** Which requirements this implements 4. **Completion Criteria:** How to know the task is done

Step-by-Step Process

Step 1: Analyze Design Components

Identify all implementation needs:

• Data models and validation
• Services and business logic
• API endpoints and handlers
• UI components
• Tests for each layer
• Integration points

Step 2: Identify Dependencies

Map what needs to be built first:

• **Technical:** Code dependencies (models before services)
• **Logical:** Feature dependencies (login before profile)
• **Data:** What data must exist first

Step 3: Sequence Tasks

Order tasks to:

• Respect dependencies
• Enable early validation
• Allow incremental testing
• Minimize blocking between tasks

Step 4: Write Task Descriptions

For each task, specify:

- [ ] X.Y [Task Title]
  - [What to implement]
  - [Files to create/modify]
  - [Key functionality]
  - [Tests to write]
  - _Requirements: [Req-1, Req-2]_

Sequencing Strategies

Strategy 1: Foundation-First

Build core infrastructure before features.

1. Project setup and core interfaces
2. Data models and validation
3. Data access layer
4. Business logic services
5. API endpoints
6. Integration and wiring

**Best for:** New projects, complex systems

Strategy 2: Feature-Slice (Vertical)

Build complete features end-to-end.

1. User registration (complete flow)
2. User authentication (complete flow)
3. User profile management (complete flow)
4. Advanced features

**Best for:** MVP development, early validation

Strategy 3: Risk-First

Tackle uncertain areas early.

1. Most complex/uncertain components
2. External integrations
3. Core business logic
4. User interface
5. Polish and optimization

**Best for:** High uncertainty, proof-of-concepts

Strategy 4: Hybrid (Recommended)

Combine approaches pragmatically.

1. Minimal foundation (core interfaces)
2. High-risk/high-value feature slice
3. Expand foundation as needed
4. Additional feature slices
5. Integration and polish

Task Categories

Foundation Tasks

- [ ] 1. Set up project foundation
- [ ] 1.1 Create project structure and interfaces
  - Set up directory structure
  - Define TypeScript interfaces for core types
  - Configure testing framework
  - _Requirements: 1.1_

Data Layer Tasks

- [ ] 2. Implement data layer
- [ ] 2.1 Create core data models
  - Implement User model with validation
  - Add database migrations
  - Write unit tests for validation
  - _Requirements: 2.1, 2.2_

Business Logic Tasks

- [ ] 3. Implement business logic
- [ ] 3.1 Create authentication service
  - Implement registration logic
  - Add password hashing
  - Create session management
  - Write unit tests
  - _Requirements: 1.2, 4.1_

API Tasks

- [ ] 4. Implement API layer
- [ ] 4.1 Create user endpoints
  - Implement POST /users endpoint
  - Add request validation
  - Write integration tests
  - _Requirements: 1.2, 2.3_

Integration Tasks

- [ ] 5. Integration and testing
- [ ] 5.1 Wire up components
  - Connect services to API layer
  - Implement middleware
  - Add end-to-end tests
  - _Requirements: 5.1_

Writing Effective Tasks

Good Task Example

- [ ] 2.1 Create User model with validation
  - Implement User class with email, password, name fields
  - Add email validation (RFC 5322 format)
  - Add password validation (8+ chars, mixed case, numbers)
  - Write unit tests for valid/invalid scenarios
  - _Requirements: 1.2, 2.1_

Poor Task Example

- [ ] 2.1 Build user stuff
  - Make user things work
  - _Requirements: 1.2_

Task Scope Guidelines

**Appropriate:** 2-4 hours of focused work

**Too Large:**

- [ ] 1.1 Implement complete user management system

**Too Small:**

- [ ] 1.1 Add semicolon to line 42

**Just Right:**

- [ ] 1.1 Create User model with validation methods

Dependency Management

Types of Dependencies

**Technical Dependencies:**

- [ ] 1.1 Create database connection ← Foundation
- [ ] 2.1 Create User model ← Depends on 1.1
- [ ] 3.1 Create UserService ← Depends on 2.1

**Logical Dependencies:**

- [ ] 1.1 User registration ← Must exist first
- [ ] 2.1 User login ← Depends on 1.1
- [ ] 3.1 Password reset ← Depends on 2.1

Handling Circular Dependencies

**Problem:**

UserService needs AuthService
AuthService needs UserS