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

markdown

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

Clear Objective: What specific code to write/modify
Implementation Details: Files, components, functions
Requirements Reference: Which requirements this implements
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:

markdown

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

markdown

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.

markdown

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.

markdown

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.

markdown

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

markdown

- [ ] 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

markdown

- [ ] 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

markdown

- [ ] 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

markdown

- [ ] 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

markdown

- [ ] 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

markdown

- [ ] 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

markdown

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

Task Scope Guidelines

Appropriate: 2-4 hours of focused work

Too Large:

markdown

- [ ] 1.1 Implement complete user management system

Too Small:

markdown

- [ ] 1.1 Add semicolon to line 42

Just Right:

markdown

- [ ] 1.1 Create User model with validation methods

Dependency Management

Types of Dependencies

Technical Dependencies:

markdown

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

markdown

- [ ] 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 UserService

Solution - Interface Extraction:

markdown

- [ ] 1.1 Create IUserService and IAuthService interfaces
- [ ] 1.2 Implement UserService using IAuthService
- [ ] 1.3 Implement AuthService using IUserService
- [ ] 1.4 Wire up dependency injection

Complete Example

markdown

# Implementation Plan: User Authentication

- [ ] 1. Set up authentication foundation
- [ ] 1.1 Create project structure and interfaces
  - Set up directory structure for auth, models, API
  - Define TypeScript interfaces for User, Session, AuthRequest
  - Configure Jest for testing
  - _Requirements: 1.1_

- [ ] 1.2 Set up database and migrations
  - Configure database connection
  - Create user and session tables
  - Set up test database
  - _Requirements: 1.1, 2.1_

- [ ] 2. Implement core data models
- [ ] 2.1 Create User model with validation
  - Implement User class with email, password, profile fields
  - Add email format validation
  - Add password strength validation (8+ chars)
  - Write unit tests for all validation rules
  - _Requirements: 1.2, 2.1_

- [ ] 2.2 Create Session model
  - Implement Session class with token, expiration
  - Add session validation logic
  - Write unit tests for session management
  - _Requirements: 1.2, 4.1_

- [ ] 3. Create authentication services
- [ ] 3.1 Implement registration service
  - Create UserService with register method
  - Add password hashing with bcrypt
  - Implement duplicate email checking
  - Write unit tests for registration
  - _Requirements: 1.2_

- [ ] 3.2 Implement login service
  - Add login method with password verification
  - Implement JWT token generation
  - Create refresh token rotation
  - Write unit tests for login flow
  - _Requirements: 1.2, 4.1_

- [ ] 4. Create API endpoints
- [ ] 4.1 Implement registration endpoint
  - Create POST /auth/register endpoint
  - Add request validation middleware
  - Implement error responses
  - Write integration tests
  - _Requirements: 1.2, 2.3_

- [ ] 4.2 Implement login endpoint
  - Create POST /auth/login endpoint
  - Add authentication middleware
  - Implement logout functionality
  - Write integration tests
  - _Requirements: 1.2, 4.1_

- [ ] 5. Integration and security
- [ ] 5.1 Add security middleware
  - Implement rate limiting
  - Add CORS configuration
  - Create JWT validation middleware
  - Write security tests
  - _Requirements: 4.1, 2.3_

- [ ] 5.2 End-to-end testing
  - Create complete auth flow tests
  - Test error scenarios
  - Validate security measures
  - _Requirements: 1.2, 4.1_

Quality Checklist

Before finalizing tasks:

Completeness:

All design components have tasks
All requirements are addressed
Testing tasks included throughout
Integration tasks connect components

Clarity:

Each task has specific objective
Files/components specified
Requirements referenced
Completion criteria clear

Sequencing:

Dependencies respected
Foundation before features
Core before optional
Integration after components

Feasibility:

Tasks are 2-4 hours each
Can be completed independently
No external blockers
Complexity increases gradually

Common Pitfalls

Tasks too abstract: "Implement user management" vs specific actions
Missing dependencies: Tasks that can't be completed in sequence
Non-coding tasks: Include only implementation activities
Monolithic tasks: Break into 2-4 hour increments
Missing tests: Include testing in each task

Task Execution Tips

Before starting a task:

Read task details thoroughly
Review referenced requirements
Check dependencies are complete
Plan implementation approach

During implementation:

Mark task as in-progress
Write tests alongside code
Test continuously
Document as you go

Before marking complete:

All tests pass
Requirements validated
Code reviewed
Documentation updated

Next Steps

After completing task breakdown:

Review task list with team
Assign tasks to developers
Begin implementation in sequence
Track progress by marking tasks complete
Update tasks if implementation reveals gaps

task-breakdown

NPX Install

Tags

SKILL.md Content

Task Breakdown

When to Use This Skill

Task Structure

Two-Level Hierarchy

Task Specification Elements

Step-by-Step Process

Step 1: Analyze Design Components

Step 2: Identify Dependencies

Step 3: Sequence Tasks

Step 4: Write Task Descriptions

Sequencing Strategies

Strategy 1: Foundation-First

Strategy 2: Feature-Slice (Vertical)

Strategy 3: Risk-First

Strategy 4: Hybrid (Recommended)

Task Categories

Foundation Tasks

Data Layer Tasks

Business Logic Tasks

API Tasks

Integration Tasks

Writing Effective Tasks

Good Task Example

Poor Task Example

Task Scope Guidelines

Dependency Management

Types of Dependencies

Handling Circular Dependencies

Complete Example

Quality Checklist

Common Pitfalls

Task Execution Tips

Next Steps