create-tasks skill
✓ VerifiedDecomposes technical specifications into actionable, structured implementation tasks with metadata and dependencies.
- GitHub stars
- 45
- Files
- 4
- Last commit
- May 31, 2026
- License
- MIT
- Allowed tools
- 8
What does the create-tasks skill do?
create-tasks decomposes technical specifications into actionable, structured implementation tasks with metadata and dependencies.
Summary generated from the skill's SKILL.md.
About the create-tasks skill
Developers can transform technical specifications into structured implementation tasks using this skill. It is designed for engineers working within Claude Code who need to decompose complex requirements, such as PRDs or API specifications, into atomic, actionable units of work. The tool analyzes the depth of a specification—ranging from high-level summaries to full-tech documents with API endpoints—to determine the appropriate level of task granularity.
When an agent loads this skill, it uses tools like Read, Glob, and Grep to parse specification files and identify features, user stories, and technical constraints. It then utilizes TaskCreate and TaskUpdate to generate native tasks complete with metadata, including priority, complexity, and dependencies. The process includes a preview step where the user must approve the proposed task list via AskUserQuestion before any tasks are actually created in the system. This ensures that the resulting task graph accurately reflects the intended implementation phases and producer-consumer relationships.
What an agent can do with it
- 1Generate tasks for specific phasesCreate tasks only for specific implementation phases by using the phase argument.
- 2Automate dependency mappingIdentify and create blocking relationships between tasks based on the technical requirements in a spec.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the create-tasks skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the create-tasks skill in Plugin
/plugin marketplace add sequenzia/agent-alchemy /plugin install agent-alchemy-sdd-tools@agent-alchemy
Install the create-tasks skill in Claude Code
~/.claude/skills/create-tasks/SKILL.md
$ npx degit sequenzia/agent-alchemy/claude/sdd-tools/skills/create-tasks ~/.claude/skills/create-tasksInstall the create-tasks skill in Claude Code (project)
.claude/skills/create-tasks/SKILL.md
$ npx degit sequenzia/agent-alchemy/claude/sdd-tools/skills/create-tasks .claude/skills/create-tasksInstall the create-tasks skill in Codex
~/.agents/skills/create-tasks/SKILL.md
$ npx degit sequenzia/agent-alchemy/claude/sdd-tools/skills/create-tasks ~/.agents/skills/create-tasksInstall the create-tasks skill in Gemini CLI
~/.gemini/skills/create-tasks/SKILL.md
$ npx degit sequenzia/agent-alchemy/claude/sdd-tools/skills/create-tasks ~/.gemini/skills/create-tasksInstall the create-tasks skill in Claude.ai
npx degit sequenzia/agent-alchemy/claude/sdd-tools/skills/create-tasks create-tasks && zip -r create-tasks.zip create-tasks # claude.ai → Customize → Skills → + → Create skill → Upload a skill → create-tasks.zip
Automated checks
Ran Nov 16, 2026Full report →Passed our automated checks. That is not a security audit: read the scripts before you let an agent run them. How checks work · What to fix for more points
- Source repository linked and reachablesequenzia/agent-alchemy/claude/sdd-tools/skills/create-tasks is public and reachablegithub.com/sequenzia/agent-alchemy/tree/HEAD/claude/sdd-tool ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit 2026-05-31github.com/sequenzia/agent-alchemy/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/sequenzia/agent-alchemy/blob/HEAD/claude/sdd-tool ↗Pass
- Pre-approved tools are scopedPre-approved: AskUserQuestion, Read, Glob, Grep, TaskCreate, TaskUpdate, …github.com/sequenzia/agent-alchemy/blob/HEAD/claude/sdd-tool ↗Pass
- SKILL.md follows the Agent Skills formatSKILL.md is 947 lines; the spec suggests under 500github.com/sequenzia/agent-alchemy/blob/HEAD/claude/sdd-tool ↗Finding
SKILL.md
View on GitHubSpec to Tasks - Create Tasks Skill
You are an expert at transforming specifications into well-structured, actionable implementation tasks. You analyze specs, decompose features into atomic tasks, infer dependencies, and create Claude Code native Tasks with proper metadata and acceptance criteria.
Critical Rules
AskUserQuestion is MANDATORY
IMPORTANT: You MUST use the AskUserQuestion tool for ALL questions to the user. Never ask questions through regular text output.
- Confirmation questions → AskUserQuestion
- Preview approval → AskUserQuestion
- Merge mode decisions → AskUserQuestion
Text output should only be used for:
- Presenting task previews and summaries
- Reporting completion status
- Displaying analysis findings
Plan Mode Behavior
CRITICAL: This skill generates tasks, NOT an implementation plan. When invoked during Claude Code's plan mode:
- DO NOT create an implementation plan for how to build the spec's described features
- DO NOT defer task generation to an "execution phase"
- DO proceed with the full task generation workflow immediately
- DO create tasks using TaskCreate as normal
The tasks are planning artifacts themselves — generating them IS the planning activity.
Load Reference Skills
Before starting the workflow, load the Claude Code Tasks reference for tool parameters, conventions, and patterns:
Read ${CLAUDE_PLUGIN_ROOT}/../claude-tools/skills/claude-code-tasks/SKILL.md
This reference provides:
- TaskCreate, TaskGet, TaskUpdate, TaskList tool parameters and return values
- Status lifecycle and transition rules
- Naming conventions (imperative subject, present-continuous activeForm)
- Dependency management with DAG design (blockedBy, blocks)
- Standard metadata conventions (priority, complexity, task_group, task_uid)
The SDD-specific extensions to these conventions are documented in the "SDD Task Metadata Extensions" section below.
Workflow Overview
This workflow has ten phases:
- Validate & Load — Validate spec file, parse
--phaseargument, read content, check settings, load reference files - Detect Depth & Check Existing — Detect spec depth level, check for existing tasks with phase metadata
- Analyze Spec — Extract features, requirements, structure, and implementation phases from spec
- Select Phases — Interactive or CLI-driven phase selection for incremental generation
- Decompose Tasks — Phase-filtered hybrid decomposition from features and deliverables
- Infer Dependencies — Phase-aware blocking relationships with cross-phase handling
- Detect Producer-Consumer Relationships — Identify
produces_forrelationships between tasks - Preview & Confirm — Show phase-annotated summary, get user approval before creating
- Create Tasks — Create tasks via TaskCreate/TaskUpdate with
spec_phasemetadata (fresh or merge mode) - Error Handling — Handle spec parsing issues, circular deps, missing info, phase-related errors
Phase 1: Validate & Load
Parse Arguments
Before validating the spec file, parse the provided arguments:
- Extract spec path: The first positional argument is the spec file path
- Check for
--phaseflag: If--phaseis present, parse the comma-separated integers that follow (e.g.,--phase 1,2→[1, 2]) - Store as
selected_phases_cli(empty list if--phasenot provided)
Validate Spec File
Verify the spec file exists at the provided path.
If the file is not found:
- Check
.claude/agent-alchemy.local.mdfor a default spec directory or output path, and try resolving the spec path against it - Check if user provided a relative path
- Try common spec locations:
specs/SPEC-{name}.mddocs/SPEC-{name}.md{name}.mdin current directory
- Use Glob to search for similar filenames:
**/SPEC*.md**/*spec*.md**/*requirements*.md
- If multiple matches found, use AskUserQuestion to let user select
- If no matches found, inform user and ask for correct path
Read Spec Content
Read the entire spec file using the Read tool.
Check Settings
Check for optional settings at .claude/agent-alchemy.local.md:
- Author name (for attribution)
- Any custom preferences
This is optional — proceed without settings if not found.
Load Reference Files
Read the reference files for task decomposition patterns, dependency rules, and testing requirements:
references/decomposition-patterns.md— Feature decomposition patterns by typereferences/dependency-inference.md— Automatic dependency inference rulesreferences/testing-requirements.md— Test type mappings and acceptance criteria patterns
Phase 2: Detect Depth & Check Existing
Detect Depth Level
Analyze the spec content to detect its depth level:
Full-Tech Indicators (check first):
- Contains
API Specificationssection OR### 7.4 APIor similar - Contains API endpoint definitions (
POST /api/,GET /api/, etc.) - Contains
Testing Strategysection - Contains data model schemas with field definitions
- Contains code examples or schema definitions
Detailed Indicators:
- Uses numbered sections (
## 1.,### 2.1) - Contains
Technical ArchitectureorTechnical Considerationssection - Contains user stories (
**US-001**:or similar format) - Contains acceptance criteria (
- [ ]checkboxes) - Contains feature prioritization (P0, P1, P2, P3)
High-Level Indicators:
- Contains feature table with Priority column
- Executive summary focus (brief problem/solution)
- No user stories or acceptance criteria
- Shorter document (~50-100 lines)
- Minimal technical details
Detection Priority:
- If spec contains
**Spec Depth**:metadata field, use that value directly - Else if Full-Tech indicators found → Full-Tech
- Else if Detailed indicators found → Detailed
- Else if High-Level indicators found → High-Level
- Default → Detailed
Check for Existing Tasks
Use TaskList to check if there are existing tasks that reference this spec.
Look for tasks with metadata.spec_path matching the spec path.
If existing tasks found:
- Count them by status (pending, in_progress, completed)
- Note their task_uids for merge mode
- Extract
spec_phasemetadata from existing tasks to buildexisting_phases_map:{phase_number → {pending, in_progress, completed, total, phase_name}} - Inform user about merge behavior with phase-aware detail
Report to user:
Found {n} existing tasks for this spec:
• {pending} pending
• {in_progress} in progress
• {completed} completed
{If existing tasks have spec_phase metadata:}
Previously generated phases:
• Phase {N}: {phase_name} — {total} tasks ({completed} completed, {pending} pending)
• Phase {M}: {phase_name} — {total} tasks ({completed} completed, {pending} pending)
New tasks will be merged. Completed tasks will be preserved.
Phase 3: Analyze Spec
Extract Spec Name
Parse the spec title to extract the spec name for use as task_group:
- Look for
# {name} PRDtitle format on line 1 - Extract
{name}as the spec name (e.g.,# User Authentication PRD→User Authentication) - Convert to slug format for
task_group(e.g.,user-authentication) - If title does not match the PRD format, derive spec name from the filename: strip
SPEC-prefix, strip.mdextension, lowercase, replace spaces/underscores with hyphens (e.g.,SPEC-Payment-Flow.md→payment-flow)
Important: task_group MUST be set on every task. The execute-tasks skill relies on metadata.task_group for --task-group filtering and session ID generation. Tasks without task_group will be invisible to group-filtered execution runs.
Section Mapping
Extract information from each spec section:
| Spec Section | Extract |
|---|---|
| 1. Overview | Project name, description for task context |
| 5.x Functional Requirements | Features, priorities (P0-P3), user stories |
| 6.x Non-Functional Requirements | Constraints, performance requirements → Performance acceptance criteria |
| 7.x Technical Considerations | Tech stack, architecture decisions |
| 7.3 Data Models (Full-Tech) | Entity definitions → data model tasks |
| 7.4 API Specifications (Full-Tech) | Endpoints → API tasks |
| 8.x Testing Strategy | Test types, coverage targets → Testing Requirements section |
| 9.x Implementation Plan | Phases, deliverables, completion criteria, checkpoint gates → phase metadata and task decomposition input |
| 10.x Dependencies | Explicit dependencies → blockedBy relationships |
Feature Extraction
For each feature in Section 5.x:
- Note feature name and description
- Extract priority (P0/P1/P2/P3)
- List user stories (US-XXX)
- Collect acceptance criteria and categorize by type (Functional, Edge Cases, Error Handling, Performance)
- Identify implied sub-features
Testing Extraction
From Section 8.x (Testing Strategy) if present:
- Note test types specified (unit, integration, E2E)
- Extract coverage targets
- Identify critical paths requiring E2E tests
- Note any performance testing requirements
From Section 6.x (Non-Functional Requirements):
- Extract performance targets → Performance acceptance criteria
- Extract security requirements → Security testing requirements
- Extract reliability requirements → Integration test requirements
Depth-Based Granularity
Adjust task granularity based on depth level:
High-Level Spec:
- 1-2 tasks per feature
- Feature-level deliverables
- Example: "Implement user authentication"
Detailed Spec:
- 3-5 tasks per feature
- Functional decomposition
- Example: "Implement login endpoint", "Add password validation"
Full-Tech Spec:
- 5-10 tasks per feature
- Technical decomposition
- Example: "Create User model", "Implement POST /auth/login", "Add auth middleware"
Phase Extraction
Extract implementation phases from Section 9 if present:
- Detect Section 9: Look for
## 9. Implementation Planor## Implementation Phases - Extract phase headers: Pattern
### 9.N Phase N: {Name}(detailed/full-tech) or### Phase N: {Name}(high-level) - For each phase, extract:
number— Phase number (integer from9.NorPhase N)name— Phase name (text afterPhase N:)completion_criteria— Text after**Completion Criteria**:deliverables— Parsed table rows from the deliverable table (columns: Deliverable, Description, Dependencies; optionally Technical Tasks)checkpoint_gate— Items after**Checkpoint Gate**:(prose or checkbox list- [ ])
- Cross-reference deliverables to Section 5 features: Scan deliverable descriptions and technical tasks for feature name references. Build mapping:
{phase_number → [feature_names]} - If no Section 9 found, set
spec_phases = []
Store the extracted phases as spec_phases for use in Phase 4 (Select Phases) and Phase 5 (Decompose Tasks).
Phase 4: Select Phases
Select which implementation phases to generate tasks for. Three paths based on context:
Path A — --phase argument provided
Skip interactive selection. Validate that each phase number in selected_phases_cli exists in spec_phases. If any phase number is invalid, report the valid range and stop.
Path B — No --phase, spec has phases (2-3 phases)
Use a single AskUserQuestion with multiSelect:
questions:
- header: "Phases"
question: "Which implementation phases should I generate tasks for?"
options:
- label: "All phases (Recommended)"
description: "Generate tasks for all {N} phases at once"
- label: "Phase 1: {name}"
description: "{deliverable_count} deliverables — {completion_criteria_brief}"
- label: "Phase 2: {name}"
description: "{deliverable_count} deliverables — {completion_criteria_brief}"
- label: "Phase 3: {name}"
description: "{deliverable_count} deliverables — {completion_criteria_brief}"
multiSelect: true
If user selects "All phases", generate for all. Otherwise generate only for the selected phase(s).
Path C — No --phase, spec has 4+ phases
Two-step selection:
-
First ask "All phases or select specific?":
questions: - header: "Phases" question: "This spec has {N} implementation phases. Generate tasks for all or select specific phases?" options: - label: "All phases (Recommended)" description: "Generate tasks for all {N} phases" - label: "Select specific phases" description: "Choose which phases to generate tasks for" multiSelect: false -
If "Select specific phases", show multiSelect with individual phases (up to 4 per AskUserQuestion, paginate if needed).
Path D — No Section 9 / no phases
Skip selection entirely. Log: "No implementation phases found in spec. Generating tasks from features only."
Set selected_phases = [] (all features will be processed without phase assignment).
Path E — Merge mode with existing phases
When existing tasks with spec_phase metadata were found in Phase 2, show a specialized prompt:
questions:
- header: "Phases"
question: "Previously generated phases detected. Which phases should I generate tasks for?"
options:
- label: "Remaining phases only (Recommended)"
description: "Generate tasks for phases not yet created: {list of remaining phase names}"
- label: "All phases (merge)"
description: "Re-generate all phases, merging with existing tasks"
- label: "Select specific phases"
description: "Choose which phases to generate tasks for"
multiSelect: false
If "Select specific phases", follow Path B/C selection flow.
Phase 5: Decompose Tasks
Phase-Aware Feature Mapping
When spec_phases is non-empty and phases were selected in Phase 4:
- Map features to phases using the cross-reference from Phase Extraction:
- Features explicitly referenced in phase deliverables → map to that phase
- Features not referenced in any phase deliverable → assign to the earliest plausible phase (based on dependency layer: data models → Phase 1, UI → last phase)
- Filter to selected phases: Only decompose features mapping to selected phases
- Deliverables as additional input: For each selected phase, check if deliverables have technical tasks not covered by Section 5 feature decomposition. Create additional tasks from uncovered deliverables with
source_section: "9.{N}" - Assign phase metadata: Every task gets
spec_phase(integer) andspec_phase_name(string)
When spec_phases = [] (no Section 9 in spec): Current behavior unchanged — decompose all features without phase assignment. The spec_phase and spec_phase_name fields are omitted entirely (backward compatible).
Standard Layer Pattern
For each feature, apply the standard layer pattern:
1. Data Model Tasks
└─ "Create {Entity} data model"
2. API/Service Tasks
└─ "Implement {endpoint} endpoint"
3. Business Logic Tasks
└─ "Implement {feature} business logic"
4. UI/Frontend Tasks
└─ "Build {feature} UI component"
5. Test Tasks
└─ "Add tests for {feature}"
Task Structure
Follow the naming conventions from the claude-code-tasks reference (imperative subject, present-continuous activeForm). Each SDD task must include categorized acceptance criteria and testing requirements in its description:
subject: "Create User data model"
description: |
{What needs to be done}
{Technical details if applicable}
**Acceptance Criteria:**
_Functional:_
- [ ] Core behavior criterion
- [ ] Expected output criterion
_Edge Cases:_
- [ ] Boundary condition criterion
- [ ] Unusual scenario criterion
_Error Handling:_
- [ ] Error scenario criterion
- [ ] Recovery behavior criterion
_Performance:_ (include if applicable)
- [ ] Performance target criterion
**Testing Requirements:**
• {Inferred test type}: {What to test}
• {Spec-specified test}: {What to test}
Source: {spec_path} Section {number}
activeForm: "Creating User data model"
SDD Task Metadata Extensions
In addition to the standard metadata keys from the claude-code-tasks reference (priority, complexity, task_group, task_uid), SDD tasks use these spec-specific keys:
| Key | Type | Required | Description |
|---|---|---|---|
source_section |
string | Yes | Spec section reference (e.g., "7.3 Data Models") |
spec_path |
string | Yes | Path to the source spec file |
feature_name |
string | Yes | Parent feature name from spec |
task_uid |
string | Yes | Composite key for merge mode: {spec_path}:{feature}:{type}:{seq} |
task_group |
string | Yes | Slug derived from spec title — REQUIRED for run-tasks --task-group filtering |
spec_phase |
integer | Conditional | Phase number from Section 9 (omit if no phases) |
spec_phase_name |
string | Conditional | Phase name from Section 9 (omit if no phases) |
produces_for |
string[] | Optional | IDs of downstream tasks that consume this task's output |
produces_for Field:
The produces_for field is an optional array of task IDs identifying tasks that directly consume this task's output. The execute-tasks orchestrator uses this field to inject the producer's result file content into the dependent task's prompt, giving downstream agents richer context than wave-granular execution_context.md merging alone provides.
- Omit if the task has no direct producer-consumer relationship with other tasks
- Include when the task's deliverable (model, schema, config, etc.) is directly referenced in another task's description
- Values are task IDs (set during Phase 9 after all tasks are created and IDs are known)
Acceptance Criteria Categories
Group acceptance criteria into these categories:
| Category | What to Include |
|---|---|
| Functional | Core behavior, expected outputs, state changes |
| Edge Cases | Boundaries, empty/null, max values, concurrent operations |
| Error Handling | Invalid input, failures, timeouts, graceful degradation |
| Performance | Response times, throughput, resource limits (if applicable) |
Testing Requirements Generation
Generate testing requirements by combining:
-
Inferred from task type (see
references/testing-requirements.md):- Data Model → Unit + Integration tests
- API Endpoint → Integration + E2E tests
- UI Component → Component + E2E tests
- Business Logic → Unit + Integration tests
-
Extracted from spec (Section 8 or feature-specific):
- Explicit test types mentioned
- Coverage targets
- Critical path tests
Format as bullet points with test type and description:
**Testing Requirements:**
• Unit: Schema validation for all field types
• Integration: Database persistence and retrieval
• E2E: Complete login workflow (from spec 8.1)
Priority Mapping
| Spec | Task Priority |
|---|---|
| P0 (Critical) | critical |
| P1 (High) | high |
| P2 (Medium) | medium |
| P3 (Low) | low |
Complexity Estimation
| Size | Scope |
|---|---|
| XS | Single simple function (<20 lines) |
| S | Single file, straightforward (20-100 lines) |
| M | Multiple files, moderate logic (100-300 lines) |
| L | Multiple components, significant logic (300-800 lines) |
| XL | System-wide, complex integration (>800 lines) |
Task UID Format
Generate unique IDs for merge tracking:
{spec_path}:{feature_slug}:{task_type}:{sequence}
Examples:
- specs/SPEC-Auth.md:user-auth:model:001
- specs/SPEC-Auth.md:user-auth:api-login:001
- specs/SPEC-Auth.md:session-mgmt:test:001
Phase 6: Infer Dependencies
Apply automatic dependency rules:
Layer Dependencies
Data Model → API → UI → Tests
- API tasks depend on their data models
- UI tasks depend on their APIs
- Tests depend on their implementations
Within-phase layer dependencies work unchanged regardless of phase selection.
Phase Dependencies
When tasks have spec_phase metadata, apply cross-phase blocking based on three scenarios:
- Phase N-1 tasks exist in current generation: Normal
blockedBy— tasks in Phase N are blocked by Phase N-1 tasks - Phase N-1 tasks exist from prior generation (merge mode): Create
blockedByrelationships to existing Phase N-1 task IDs (found viaexisting_phases_mapfrom Phase 2) - Phase N-1 was NOT selected and no existing tasks found: Do NOT add
blockedByto non-existent tasks. Instead:- Add a "Prerequisites" note to task descriptions listing assumed-complete deliverables from the missing phase
- Emit a one-time warning: "Phase {N} tasks generated without Phase {N-1} predecessor tasks. Phase {N-1} deliverables are assumed complete."
Explicit Spec Dependencies
Map Section 10 dependencies:
- "requires X" → blockedBy X
- "prerequisite for Y" → blocks Y
Cross-Feature Dependencies
If features share:
- Data models: both depend on model creation
- Services: both depend on service implementation
- Auth: all protected features depend on auth setup
Phase 7: Detect Producer-Consumer Relationships
After inferring blockedBy dependencies, identify which tasks produce output that is directly consumed by other tasks. These relationships are emitted as the produces_for field on producer tasks, enabling the execute-tasks orchestrator to inject richer upstream context into dependent task prompts.
Detection Approach
Analyze the decomposed tasks and their blockedBy relationships to find producer-consumer pairs. A producer-consumer relationship exists when:
- Task B is blocked by Task A (
blockedBy), AND - Task A's deliverable is directly referenced in Task B's description — Task B cannot be implemented without the specific artifact Task A produces
Conservative principle: When uncertain whether a relationship is truly producer-consumer, omit produces_for. False positives add unnecessary context to dependent tasks; false negatives are harmless (the task still gets wave-granular context via execution_context.md).
Producer-Consumer Patterns
Detect these common patterns:
| Producer Task Type | Consumer Task Type | Signal |
|---|---|---|
| Data Model | API/Service that uses the model | Consumer description references entity name, fields, or schema defined by producer |
| Schema/Type Definition | Implementation that implements the schema | Consumer implements interfaces, types, or contracts defined by producer |
| Configuration/Infrastructure | Tasks that consume the config | Consumer reads config values, connects to services, or uses infrastructure set up by producer |
| Foundation/Framework | Tasks that build on the foundation | Consumer extends base classes, uses utilities, or follows patterns established by producer |
| API Endpoint | UI/Frontend that calls the endpoint | Consumer calls specific endpoints or uses response formats defined by producer |
| Migration/Setup | Tasks that require the setup | Consumer reads from tables, uses resources, or depends on state created by producer |
Files in this skill
4create-tasks skill questions
How do I install the create-tasks skill in Claude Code?
Run npx degit sequenzia/agent-alchemy/claude/sdd-tools/skills/create-tasks ~/.claude/skills/create-tasks. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the create-tasks skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.