Section 2
Specification Plan: Task Implementation
Take a well-defined specification and translate it into actionable, atomic tasks — systematic, traceable, and ready for implementation.
"A spec that cannot generate a task list is not executable — it is a wish.
Overview
Section 2 begins after the Clarification Gate passes. A clarified requirements.md becomes an ordered tasks.md via the /create-tasks command — breaking features into the smallest verifiable units of work.
Prerequisite: Clarified Specification
Zero open items in requirements.md. User roles, data lifecycle, and error behaviours defined. Do not run /create-tasks until the gate passes.
Review Clarification Gate →Key Concepts
Gate before tasks
Clarified Specification
Before /create-tasks runs, requirements.md must be fully clarified — zero open items, user roles defined, data lifecycle and error behaviours documented.
Spec → tasks.md
/create-tasks
Converts clarified specifications into an ordered tasks.md file — with dependency groups, requirement links, and verification steps per task.
Smallest verifiable units
Atomic Decomposition
Split features into the smallest units that can be reviewed, tested, and implemented in isolation — reducing errors and ambiguity.
Version-controlled task file
tasks.md Structure
Groups by dependency, links every task to a requirement ID, and includes verification checkboxes — all committed to the repo.
Example Specification
Feature: Send messages between users
User roles
Sender composes and sends; receiver reads incoming messages
Data lifecycle
Stored on send; soft-deleted by sender; hard-deleted after 30 days
Error behaviour
Failed send shows retry UI; not persisted until delivery confirmed
Example — Messaging App Tasks
After clarifying the send-message spec, /create-tasks produces atomic, dependency-ordered tasks linked to requirements.
A — Data Foundation
Task 1: Design the message data structure
Requirement
REQ-002 — Data lifecycle
Depends on
—
Define message schema: id, senderId, receiverId, body, status, createdAt, deletedAt
Verification
Risk Planning Matrix
During the Plan stage, identify what can go wrong, how to detect it, and how to mitigate — before tasks become code.
| What can go wrong? | How do we detect it? | Mitigation Strategy |
|---|---|---|
| Database failure | Metrics / Alerts | Rollback migration |
| Latency spike | Monitoring signals | Disable via flag |
| API misuse | Logs | Rate limit |
Include a risk matrix in your plan alongside tasks — especially for features touching databases, APIs, or external services.
Practical Takeaways
- 1Gate before tasks. Never /create-tasks on an unclear spec.
- 2Atomic wins. Smallest verifiable unit — not 'build the feature.'
- 3Trace everything. Every task links to a requirement ID.
- 4Verify each task. Checkboxes, not vibes.
- 5Dependency order matters. Foundation before logic before tests.
- 6Plan for failure. Document risks, detection signals, and mitigations before coding.
- 7tasks.md lives in the repo. Version-controlled like requirements.md.