task-generation
Generate a detailed task list from a PRP. Use after a PRP is created and ready for implementation planning.
Best use case
task-generation is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Generate a detailed task list from a PRP. Use after a PRP is created and ready for implementation planning.
Teams using task-generation should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/task-generation/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How task-generation Compares
| Feature / Agent | task-generation | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Generate a detailed task list from a PRP. Use after a PRP is created and ready for implementation planning.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Task Generation
Generate a detailed, step-by-step task list in Markdown format based on an existing Product Requirements Prompt (PRP).
## When to Use This Skill
Use this skill when:
- A PRP exists at `.ai/[feature-name]/prp.md`
- You need to break down the feature into implementable tasks
- Planning how a junior developer will implement the feature
## Input
- `feature_name` - Locates the PRP at `.ai/[feature-name]/prp.md`
## Process
1. **Receive PRP Reference**: The user points to a specific PRP file
2. **Analyze PRP**: Read and analyze the functional requirements, user stories, and other sections
3. **Clarify Open Questions**: If there are still any open questions, ask the user for clarification and amend the PRP accordingly before proceeding
4. **Phase 1: Generate Parent Tasks**: Based on the PRP analysis, create the main high-level tasks (3-8 parent tasks). Present these to the user in the specified format (without sub-tasks yet). Inform: "I have generated the high-level tasks. Ready to generate sub-tasks? Respond with 'go' to proceed."
5. **Wait for Confirmation**: Pause and wait for the user to respond with "go"
6. **Phase 2: Generate Sub-Tasks**: Once confirmed, break down each parent task into smaller, actionable sub-tasks
7. **Identify Relevant Files**: Based on tasks and PRP, identify potential files that need creation or modification
8. **Generate Final Output**: Combine parent tasks, sub-tasks, relevant files, and notes
9. **Save Task List**: Save to `.ai/[feature-name]/tasks.md`
10. **Commit Task List**: Stage and commit the new task list
## Commit Message Template
```
feat: add .ai/[feature-name]/tasks.md
Generate tasks according to .ai/[feature-name]/prp.md
```
## Output Format
The `tasks.md` file _must_ follow this structure:
```markdown
# Context
See [prp.md][./prp.md] for the corresponding Product Requirements Prompt.
# Relevant Files
- `path/to/file1.ts` - Brief description of why this file is relevant
- `path/to/file1.test.ts` - Unit tests for `file1.ts`
- `path/to/another/file.tsx` - Brief description
- `path/to/another/file.test.tsx` - Unit tests for `another/file.tsx`
- `lib/utils/helpers.ts` - Utility functions needed for calculations
- `lib/utils/helpers.test.ts` - Unit tests for helpers.ts
# Tasks
- [ ] 1. Parent Task Title
- [ ] 1.1. Sub-task description 1.1
- [ ] 1.2. Sub-task description 1.2
- [ ] 2. Parent Task Title
- [ ] 2.1. Sub-task description 2.1
- [ ] 3. Parent Task Title (may not require sub-tasks)
```
## Target Audience
Assume the primary reader is a **junior developer** who will implement the feature.
Tasks should be clear, actionable, and provide enough context for someone less
familiar with the codebase to complete them.
## Interaction Model
The process explicitly requires a pause after generating parent tasks to get
user confirmation ("Go") before proceeding to generate detailed sub-tasks.
This ensures the high-level plan aligns with user expectations.Related Skills
task-orchestration
Orchestrate the complete development workflow for implementing sub-tasks from a task list. Use for end-to-end feature implementation with quality controls.
task-implementation
Implement a single sub-task from a task list. Use when working on feature development with existing task lists.
prp-generation
Generate a Product Requirements Prompt (PRP) from a feature description. Use when starting work on a new feature.
xlsx-to-csv
Convert XLSX spreadsheets (single or multi-sheet) to CSV files you can read and grep. Use whenever you need to process an .xlsx report from Xero, Cryptio, bank exports, or any tool that delivers spreadsheet output.
xero-mcp
Use the Xero MCP server — obtain/refresh OAuth2 bearer tokens, troubleshoot authentication, and pick up other operational notes for working with Xero MCP tools. Use when Xero MCP tools fail with authentication errors, when the bearer token has expired (tokens last ~30 min), before starting any Xero workflow, or for general guidance on Xero MCP usage.
xero-browser
General Xero browser automation notes. Use when automating any Xero page with agent-browser — covers non-standard UI patterns, waiting, and dropdown menus.
test-running
Run tests according to repository guidelines. Use after linting passes, before staging changes.
subagent-authoring
Create subagent definitions for Claude Code and OpenCode that delegate to skills. Use when creating new subagents or refactoring existing ones to follow the delegation pattern.
slow-command-running
Pipe long running commands through tee(1) to allow watching output and repeated analyses without rerunning
skill-authoring
Create and maintain Claude Code skills following Anthropic best practices. Use when building new skills, refactoring existing ones, or ensuring skills follow official guidelines for structure, naming, progressive disclosure, and testing.
safe-rm
Safely delete files / directories without asking for permission
project-initialization
Initialize a project with AI agent rules and documentation. Use when setting up a new repository for AI agent collaboration.