User Input
$ARGUMENTS
You MUST consider the user input before proceeding (if not empty).
Pre-Execution Checks
Check for extension hooks (before tasks generation):
- Check if
.specify/extensions.yml exists in the project root.
- If it exists, read it and look for entries under the
hooks.before_tasks key
- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
- Filter out hooks where
enabled is explicitly false. Treat hooks without an enabled field as enabled by default.
- For each remaining hook, do not attempt to interpret or evaluate hook
condition expressions:
- If the hook has no
condition field, or it is null/empty, treat the hook as executable
- If the hook defines a non-empty
condition, skip the hook and leave condition evaluation to the HookExecutor implementation
- When constructing slash commands from hook command names, replace dots (
.) with hyphens (-). For example, speckit.git.commit → /speckit-git-commit.
- For each executable hook, output the following based on its
optional flag:
- Optional hook (
optional: true):## Extension Hooks
**Optional Pre-Hook**: {extension}
Command: `/{command}`
Description: {description}
Prompt: {prompt}
To execute: `/{command}`
- Mandatory hook (
optional: false):## Extension Hooks
**Automatic Pre-Hook**: {extension}
Executing: `/{command}`
EXECUTE_COMMAND: {command}
Wait for the result of the hook command before proceeding to the Outline.
- If no hooks are registered or
.specify/extensions.yml does not exist, skip silently
Outline
Setup: Run .specify/scripts/powershell/check-prerequisites.ps1 -Json from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'''m Groot' (or double-quote if possible: "I'm Groot").
Load design documents: Read from FEATURE_DIR:
- Required: plan.md (tech stack, libraries, structure), spec.md (user stories with priorities)
- Optional: data-model.md (entities), contracts/ (interface contracts), research.md (decisions), quickstart.md (test scenarios)
- Note: Not all projects have all documents. Generate tasks based on what's available.
Execute task generation workflow:
- Load plan.md and extract tech stack, libraries, project structure
- Load spec.md and extract user stories with their priorities (P1, P2, P3, etc.)
- If data-model.md exists: Extract entities and map to user stories
- If contracts/ exists: Map interface contracts to user stories
- If research.md exists: Extract decisions for setup tasks
- Generate tasks organized by user story (see Task Generation Rules below)
- Generate dependency graph showing user story completion order
- Create parallel execution examples per user story
- Validate task completeness (each user story has all needed tasks, independently testable)
Generate tasks.md: Use .specify/templates/tasks-template.md as structure, fill with:
- Correct feature name from plan.md
- Phase 1: Setup tasks (project initialization)
- Phase 2: Foundational tasks (blocking prerequisites for all user stories)
- Phase 3+: One phase per user story (in priority order from spec.md)
- Each phase includes: story goal, independent test criteria, tests (if requested), implementation tasks
- Final Phase: Polish & cross-cutting concerns
- All tasks must follow the strict checklist format (see Task Generation Rules below)
- Clear file paths for each task
- Dependencies section showing story completion order
- Parallel execution examples per story
- Implementation strategy section (MVP first, incremental delivery)
Report: Output path to generated tasks.md and summary:
- Total task count
- Task count per user story
- Parallel opportunities identified
- Independent test criteria for each story
- Suggested MVP scope (typically just User Story 1)
- Format validation: Confirm ALL tasks follow the checklist format (checkbox, ID, labels, file paths)
Check for extension hooks: After tasks.md is generated, check if .specify/extensions.yml exists in the project root.
- If it exists, read it and look for entries under the
hooks.after_tasks key
- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
- Filter out hooks where
enabled is explicitly false. Treat hooks without an enabled field as enabled by default.
- For each remaining hook, do not attempt to interpret or evaluate hook
condition expressions:
- If the hook has no
condition field, or it is null/empty, treat the hook as executable
- If the hook defines a non-empty
condition, skip the hook and leave condition evaluation to the HookExecutor implementation
- When constructing slash commands from hook command names, replace dots (
.) with hyphens (-). For example, speckit.git.commit → /speckit-git-commit.
- For each executable hook, output the following based on its
optional flag:
- Optional hook (
optional: true):## Extension Hooks
**Optional Hook**: {extension}
Command: `/{command}`
Description: {description}
Prompt: {prompt}
To execute: `/{command}`
- Mandatory hook (
optional: false):## Extension Hooks
**Automatic Hook**: {extension}
Executing: `/{command}`
EXECUTE_COMMAND: {command}
- If no hooks are registered or
.specify/extensions.yml does not exist, skip silently
Context for task generation: $ARGUMENTS
The tasks.md should be immediately executable - each task must be specific enough that an LLM can complete it without additional context.
Task Generation Rules
CRITICAL: Tasks MUST be organized by user story to enable independent implementation and testing.
Tests are OPTIONAL: Only generate test tasks if explicitly requested in the feature specification or if user requests TDD approach.
Checklist Format (REQUIRED)
Every task MUST strictly follow this format:
- [ ] [TaskID] [P?] [Story?] Description with file path
Format Components:
- Checkbox: ALWAYS start with
- [ ] (markdown checkbox)
- Task ID: Sequential number (T001, T002, T003...) in execution order
- [P] marker: Include ONLY if task is parallelizable (different files, no dependencies on incomplete tasks)
- [Story] label: REQUIRED for user story phase tasks only
- Format: [US1], [US2], [US3], etc. (maps to user stories from spec.md)
- Setup phase: NO story label
- Foundational phase: NO story label
- User Story phases: MUST have story label
- Polish phase: NO story label
- Description: Clear action with exact file path
Examples:
- ✅ CORRECT:
- [ ] T001 Create project structure per implementation plan
- ✅ CORRECT:
- [ ] T005 [P] Implement authentication middleware in src/middleware/auth.py
- ✅ CORRECT:
- [ ] T012 [P] [US1] Create User model in src/models/user.py
- ✅ CORRECT:
- [ ] T014 [US1] Implement UserService in src/services/user_service.py
- ❌ WRONG:
- [ ] Create User model (missing ID and Story label)
- ❌ WRONG:
T001 [US1] Create model (missing checkbox)
- ❌ WRONG:
- [ ] [US1] Create User model (missing Task ID)
- ❌ WRONG:
- [ ] T001 [US1] Create model (missing file path)
Task Organization
From User Stories (spec.md) - PRIMARY ORGANIZATION:
- Each user story (P1, P2, P3...) gets its own phase
- Map all related components to their story:
- Models needed for that story
- Services needed for that story
- Interfaces/UI needed for that story
- If tests requested: Tests specific to that story
- Mark story dependencies (most stories should be independent)
From Contracts:
- Map each interface contract → to the user story it serves
- If tests requested: Each interface contract → contract test task [P] before implementation in that story's phase
From Data Model:
- Map each entity to the user story(ies) that need it
- If entity serves multiple stories: Put in earliest story or Setup phase
- Relationships → service layer tasks in appropriate story phase
From Setup/Infrastructure:
- Shared infrastructure → Setup phase (Phase 1)
- Foundational/blocking tasks → Foundational phase (Phase 2)
- Story-specific setup → within that story's phase
Phase Structure
- Phase 1: Setup (project initialization)
- Phase 2: Foundational (blocking prerequisites - MUST complete before user stories)
- Phase 3+: User Stories in priority order (P1, P2, P3...)
- Within each story: Tests (if requested) → Models → Services → Endpoints → Integration
- Each phase should be a complete, independently testable increment
- Final Phase: Polish & Cross-Cutting Concerns
1---
2name: "speckit-tasks"
3description: "Generate an actionable, dependency-ordered tasks.md for the feature based on available design artifacts."
4argument-hint: "Optional task generation constraints"
5compatibility: "Requires spec-kit project structure with .specify/ directory"
6metadata:
7 author: "github-spec-kit"
8 source: https://skillmd.com/skills/unoplatform/speckit-tasks
9 upstream: "templates/commands/tasks.md"
10user-invocable: true
11disable-model-invocation: false
12---
13
14
15## User Input
16
17```text
18$ARGUMENTS
19```
20
21You **MUST** consider the user input before proceeding (if not empty).
22
23## Pre-Execution Checks
24
25**Check for extension hooks (before tasks generation)**:
26- Check if `.specify/extensions.yml` exists in the project root.
27- If it exists, read it and look for entries under the `hooks.before_tasks` key
28- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
29- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
30- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
31 - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
32 - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
33- When constructing slash commands from hook command names, replace dots (`.`) with hyphens (`-`). For example, `speckit.git.commit` → `/speckit-git-commit`.
34- For each executable hook, output the following based on its `optional` flag:
35 - **Optional hook** (`optional: true`):
36 ```
37 ## Extension Hooks
38
39 **Optional Pre-Hook**: {extension}
40 Command: `/{command}`
41 Description: {description}
42
43 Prompt: {prompt}
44 To execute: `/{command}`
45 ```
46 - **Mandatory hook** (`optional: false`):
47 ```
48 ## Extension Hooks
49
50 **Automatic Pre-Hook**: {extension}
51 Executing: `/{command}`
52 EXECUTE_COMMAND: {command}
53
54 Wait for the result of the hook command before proceeding to the Outline.
55 ```
56- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
57
58## Outline
59
601. **Setup**: Run `.specify/scripts/powershell/check-prerequisites.ps1 -Json` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'''m Groot' (or double-quote if possible: "I'm Groot").
61
622. **Load design documents**: Read from FEATURE_DIR:
63 - **Required**: plan.md (tech stack, libraries, structure), spec.md (user stories with priorities)
64 - **Optional**: data-model.md (entities), contracts/ (interface contracts), research.md (decisions), quickstart.md (test scenarios)
65 - Note: Not all projects have all documents. Generate tasks based on what's available.
66
673. **Execute task generation workflow**:
68 - Load plan.md and extract tech stack, libraries, project structure
69 - Load spec.md and extract user stories with their priorities (P1, P2, P3, etc.)
70 - If data-model.md exists: Extract entities and map to user stories
71 - If contracts/ exists: Map interface contracts to user stories
72 - If research.md exists: Extract decisions for setup tasks
73 - Generate tasks organized by user story (see Task Generation Rules below)
74 - Generate dependency graph showing user story completion order
75 - Create parallel execution examples per user story
76 - Validate task completeness (each user story has all needed tasks, independently testable)
77
784. **Generate tasks.md**: Use `.specify/templates/tasks-template.md` as structure, fill with:
79 - Correct feature name from plan.md
80 - Phase 1: Setup tasks (project initialization)
81 - Phase 2: Foundational tasks (blocking prerequisites for all user stories)
82 - Phase 3+: One phase per user story (in priority order from spec.md)
83 - Each phase includes: story goal, independent test criteria, tests (if requested), implementation tasks
84 - Final Phase: Polish & cross-cutting concerns
85 - All tasks must follow the strict checklist format (see Task Generation Rules below)
86 - Clear file paths for each task
87 - Dependencies section showing story completion order
88 - Parallel execution examples per story
89 - Implementation strategy section (MVP first, incremental delivery)
90
915. **Report**: Output path to generated tasks.md and summary:
92 - Total task count
93 - Task count per user story
94 - Parallel opportunities identified
95 - Independent test criteria for each story
96 - Suggested MVP scope (typically just User Story 1)
97 - Format validation: Confirm ALL tasks follow the checklist format (checkbox, ID, labels, file paths)
98
996. **Check for extension hooks**: After tasks.md is generated, check if `.specify/extensions.yml` exists in the project root.
100 - If it exists, read it and look for entries under the `hooks.after_tasks` key
101 - If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
102 - Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
103 - For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
104 - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
105 - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
106 - When constructing slash commands from hook command names, replace dots (`.`) with hyphens (`-`). For example, `speckit.git.commit` → `/speckit-git-commit`.
107 - For each executable hook, output the following based on its `optional` flag:
108 - **Optional hook** (`optional: true`):
109 ```
110 ## Extension Hooks
111
112 **Optional Hook**: {extension}
113 Command: `/{command}`
114 Description: {description}
115
116 Prompt: {prompt}
117 To execute: `/{command}`
118 ```
119 - **Mandatory hook** (`optional: false`):
120 ```
121 ## Extension Hooks
122
123 **Automatic Hook**: {extension}
124 Executing: `/{command}`
125 EXECUTE_COMMAND: {command}
126 ```
127 - If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
128
129Context for task generation: $ARGUMENTS
130
131The tasks.md should be immediately executable - each task must be specific enough that an LLM can complete it without additional context.
132
133## Task Generation Rules
134
135**CRITICAL**: Tasks MUST be organized by user story to enable independent implementation and testing.
136
137**Tests are OPTIONAL**: Only generate test tasks if explicitly requested in the feature specification or if user requests TDD approach.
138
139### Checklist Format (REQUIRED)
140
141Every task MUST strictly follow this format:
142
143```text
144- [ ] [TaskID] [P?] [Story?] Description with file path
145```
146
147**Format Components**:
148
1491. **Checkbox**: ALWAYS start with `- [ ]` (markdown checkbox)
1502. **Task ID**: Sequential number (T001, T002, T003...) in execution order
1513. **[P] marker**: Include ONLY if task is parallelizable (different files, no dependencies on incomplete tasks)
1524. **[Story] label**: REQUIRED for user story phase tasks only
153 - Format: [US1], [US2], [US3], etc. (maps to user stories from spec.md)
154 - Setup phase: NO story label
155 - Foundational phase: NO story label
156 - User Story phases: MUST have story label
157 - Polish phase: NO story label
1585. **Description**: Clear action with exact file path
159
160**Examples**:
161
162- ✅ CORRECT: `- [ ] T001 Create project structure per implementation plan`
163- ✅ CORRECT: `- [ ] T005 [P] Implement authentication middleware in src/middleware/auth.py`
164- ✅ CORRECT: `- [ ] T012 [P] [US1] Create User model in src/models/user.py`
165- ✅ CORRECT: `- [ ] T014 [US1] Implement UserService in src/services/user_service.py`
166- ❌ WRONG: `- [ ] Create User model` (missing ID and Story label)
167- ❌ WRONG: `T001 [US1] Create model` (missing checkbox)
168- ❌ WRONG: `- [ ] [US1] Create User model` (missing Task ID)
169- ❌ WRONG: `- [ ] T001 [US1] Create model` (missing file path)
170
171### Task Organization
172
1731. **From User Stories (spec.md)** - PRIMARY ORGANIZATION:
174 - Each user story (P1, P2, P3...) gets its own phase
175 - Map all related components to their story:
176 - Models needed for that story
177 - Services needed for that story
178 - Interfaces/UI needed for that story
179 - If tests requested: Tests specific to that story
180 - Mark story dependencies (most stories should be independent)
181
1822. **From Contracts**:
183 - Map each interface contract → to the user story it serves
184 - If tests requested: Each interface contract → contract test task [P] before implementation in that story's phase
185
1863. **From Data Model**:
187 - Map each entity to the user story(ies) that need it
188 - If entity serves multiple stories: Put in earliest story or Setup phase
189 - Relationships → service layer tasks in appropriate story phase
190
1914. **From Setup/Infrastructure**:
192 - Shared infrastructure → Setup phase (Phase 1)
193 - Foundational/blocking tasks → Foundational phase (Phase 2)
194 - Story-specific setup → within that story's phase
195
196### Phase Structure
197
198- **Phase 1**: Setup (project initialization)
199- **Phase 2**: Foundational (blocking prerequisites - MUST complete before user stories)
200- **Phase 3+**: User Stories in priority order (P1, P2, P3...)
201 - Within each story: Tests (if requested) → Models → Services → Endpoints → Integration
202 - Each phase should be a complete, independently testable increment
203- **Final Phase**: Polish & Cross-Cutting Concerns