Comprehensive Task Module

A structured skill for task management within development workflows. Covers task decomposition, estimation, prioritization, tracking, and completion verification for software engineering tasks of any complexity.

When to Use This Skill

Choose this skill when:

• Breaking down large features into implementable tasks
• Estimating effort and prioritizing a task backlog
• Tracking progress on multi-step development tasks
• Creating task checklists for code reviews and releases
• Organizing sprint planning and work distribution

Consider alternatives when:

• Managing a project timeline → use a project management tool
• Tracking bugs specifically → use an issue tracker skill
• Planning architecture → use an architecture design skill
• Need automated CI/CD → use a DevOps skill

Quick Start

Copy
# Task Decomposition Template

## Feature: User Profile Page

### Epic Tasks (1-2 days each)
1. [ ] Build profile API endpoint
2. [ ] Create profile UI components
3. [ ] Implement profile edit flow
4. [ ] Add avatar upload

### Task 1: Build profile API endpoint
**Subtasks:**
- [ ] Define database schema for user profiles
- [ ] Create GET /api/users/:id endpoint
- [ ] Create PUT /api/users/:id endpoint
- [ ] Add input validation with Zod
- [ ] Write integration tests
- [ ] Add API documentation

**Definition of Done:**
- All tests passing
- API returns correct data shapes
- Validation rejects invalid inputs
- Documented in API reference

Core Concepts

Task Sizing Framework

Size	Effort	Description	Examples
XS	< 1 hour	Config change, typo fix	Update env var, fix import path
S	1-4 hours	Single component/function	Add a form field, new utility function
M	4-16 hours	Feature slice	New API endpoint with tests
L	2-5 days	Complete feature	User auth flow end-to-end
XL	1-2 weeks	Multi-component feature	Payment integration

Prioritization Matrix

Copy
# Eisenhower Matrix for Tasks

|               | Urgent        | Not Urgent     |
|---------------|---------------|----------------|
| Important     | DO FIRST      | SCHEDULE       |
|               | Production    | Tech debt      |
|               | bugs, security| refactoring,   |
|               | vulnerabilities| performance   |
| Not Important | DELEGATE      | ELIMINATE      |
|               | Minor UI      | Nice-to-have   |
|               | fixes,        | features,      |
|               | style tweaks  | gold plating   |

Task Tracking Pattern

Copy
interface Task {
  id: string;
  title: string;
  description: string;
  status: 'todo' | 'in-progress' | 'review' | 'done';
  size: 'XS' | 'S' | 'M' | 'L' | 'XL';
  priority: 'critical' | 'high' | 'medium' | 'low';
  assignee: string;
  subtasks: Task[];
  blockedBy: string[];  // IDs of blocking tasks
  definitionOfDone: string[];
}

// Completion verification
function isTaskComplete(task: Task): boolean {
  const subtasksComplete = task.subtasks.every(st => st.status === 'done');
  const dodMet = task.definitionOfDone.every(criterion =>
    verifyDODCriterion(criterion, task)
  );
  return subtasksComplete && dodMet;
}

Configuration

Parameter	Type	Default	Description
sizingScale	string	'XS-XL'	Sizing: XS-XL, story-points, or hours
priorityLevels	number	4	Number of priority levels
trackingTool	string	'markdown'	Tracking: markdown, github-issues, or jira
wipLimit	number	2	Max work-in-progress tasks
reviewRequired	boolean	true	Require code review before done
dodTemplate	string	'standard'	Definition of Done template

Best Practices

1. Every task must have a clear Definition of Done — "Done" means different things to different people. Explicit criteria (tests pass, reviewed, documented, deployed) eliminate ambiguity and prevent tasks from lingering in "almost done" status.

2. Limit work in progress to 2 tasks maximum — Context switching between many tasks reduces throughput. Focus on completing tasks rather than starting new ones. A finished task delivers value; an in-progress task delivers nothing.

3. Break tasks until each is completable in one session — If a task takes more than a day, it's too large to estimate accurately and too easy to get stuck on. Decompose until each subtask is achievable in 1-4 hours.

4. Front-load unknowns and risks — Tasks with unknown scope or technical risk should be tackled first. A spike (time-boxed investigation) resolves unknowns before committing to full implementation.

5. Track blocked tasks and resolve blockers actively — A task that says "blocked" without an action to unblock it will stay blocked forever. Each blocker should have an owner and a deadline for resolution.

Common Issues

Tasks keep growing in scope during implementation — This is scope creep at the task level. When you discover additional work, create a new task rather than expanding the current one. The original task should deliver its defined outcome.

Estimation consistently off by 2-3x — Teams underestimate consistently. Apply a multiplier based on historical data. Track actual vs estimated time to calibrate future estimates. Account for reviews, testing, and deployment — not just coding.

Tasks marked "done" but problems found later — The Definition of Done is incomplete. Add criteria: "All automated tests pass," "Reviewed by at least one team member," "No regression in existing tests," "Works in staging environment."