Create Task Files Skill

Export planning tasks into structured, trackable markdown files organized by type (epic, user-story, bug, issue) in a tasks/ directory. Integrates with git-based workflows for team collaboration.

When to Use This Skill

Use this skill when:

• User wants to export TodoWrite tasks to files

• After completing /plan-feature and user wants task tracking

• User mentions "create tasks", "export tasks", "epic", "user story"

• Setting up project tracking in markdown files

• Need to track bugs or issues in files

Task Types

This skill supports four task types:

Type Purpose Example

epic Large feature or initiative spanning multiple stories "User Authentication System"

user-story Single deliverable piece of functionality "User can login with email/password"

bug Defect or issue to fix "Login form doesn't validate email format"

issue General task, chore, or technical debt "Refactor authentication controller"

Instructions

Follow these steps when creating task files:

Step 1: Determine Task Source

Check if there are active TodoWrite tasks:

• Ask the user: "I can create task files from your current todo list or from a feature description. Which would you prefer?"

• If using todo list, analyze the current tasks

• If using feature description, ask for the feature details

Step 2: Gather Task Configuration

Use AskUserQuestion to ask:

Question 1: Task Types

• Which task types to create?

• Options: "All types (epic + stories)", "User stories only", "Custom selection"

Question 2: Grouping Strategy

• How to group tasks?

• Options: "By implementation layer (DB, Logic, UI, Tests)", "By feature area", "Chronological order"

Question 3: Metadata

• What additional metadata?

• Options: "Priority + Labels", "Just basics", "Full metadata (assignee, estimates)"

Step 3: Create Tasks Directory

Create the directory structure:

mkdir -p tasks

Check if tasks/README.md exists. If not, create it with:

Project Tasks

This directory contains structured task tracking files for features, bugs, and issues.

Task Types

• epic-XXX: Large features or initiatives
• story-XXX: User stories and deliverable functionality
• bug-XXX: Defects and issues to fix
• issue-XXX: General tasks, chores, technical debt

Workflow

1. Tasks are created from feature planning
2. Update task status as work progresses
3. Check off acceptance criteria when complete
4. Link related tasks using task IDs

Status Values

• todo: Not started
• in-progress: Currently being worked on
• blocked: Waiting on dependency
• review: Ready for review
• done: Completed

File Naming

Format: {type}-{number}-{slug}.md

Examples:

• epic-001-user-authentication.md
• story-001-login-form.md
• bug-001-email-validation.md

Step 4: Analyze and Structure Tasks

Based on the source (TodoWrite or description):

• Identify the Epic: The main feature/initiative

• Break into User Stories: Discrete deliverable pieces

• Identify Dependencies: Which tasks block others

• Assign Priorities: Based on dependencies and importance

Example breakdown:

Epic: Blog Post Commenting System ├── Story 1: Comment model and database ├── Story 2: Comment controller and routes ├── Story 3: Comment form UI with Turbo ├── Story 4: Comment listing with nested replies └── Story 5: Email notifications for replies

Step 5: Generate Task Files

Create files using the templates (see templates/ directory).

Naming convention: {type}-{number}-{slug}.md

Numbering:

• Check existing tasks: ls tasks/{type}-* 2>/dev/null | wc -l

• Increment from highest existing number

• Pad with zeros: 001 , 002 , etc.

Slug generation:

• Lowercase title

• Replace spaces with hyphens

• Remove special characters

• Max 50 characters

Step 6: Create Task Files

For each task, create a markdown file using the templates in the templates/ directory.

Available templates:

• templates/epic.md - For large features/initiatives

• templates/user-story.md - For deliverable functionality

• templates/bug.md - For defects and bugs

• templates/issue.md - For chores and technical debt

Template usage:

• Read the appropriate template file from templates/ directory

• Replace placeholder values: {number} , {Epic Title} , {YYYY-MM-DD} , etc.

• Use Write tool to create the task file in tasks/ directory

For full template details, see the files in templates/ directory.

Step 7: Create Task Index

After creating all task files, update or create tasks/INDEX.md :

Task Index

Generated: {YYYY-MM-DD HH:MM}

Epics

• epic-001 - {Title} [status]

User Stories

• story-001 - {Title} [status] (epic-001)
• story-002 - {Title} [status] (epic-001)

Bugs

• bug-001 - {Title} [status]

Issues

• issue-001 - {Title} [status]

By Status

Todo

• story-001, bug-001

In Progress

• story-002

Done

• issue-001

Step 8: Present Summary

Show the user what was created:

Task Files Created

Created {N} task files in tasks/ directory:

Epic

• tasks/epic-001-feature-name.md

User Stories (5)

• tasks/story-001-database-setup.md
• tasks/story-002-business-logic.md
• tasks/story-003-ui-implementation.md
• tasks/story-004-testing.md
• tasks/story-005-polish.md

Structure

tasks/ ├── README.md ├── INDEX.md ├── epic-001-feature-name.md └── story-001-database-setup.md

Next Steps

1. Review task files and update priorities
2. Assign tasks to team members (update frontmatter)
3. Start with: tasks/story-001-database-setup.md
4. Update status as work progresses
5. Commit to git: git add tasks/ && git commit -m "Add tasks for {feature}"

Tasks are now tracked in markdown files and can be committed to version control.

Best Practices

Do:

• ✅ Create one epic per feature/initiative

• ✅ Break epics into 3-7 user stories

• ✅ Use clear, actionable titles

• ✅ Include acceptance criteria

• ✅ Link related tasks with IDs

• ✅ Update task status as work progresses

• ✅ Commit task files to git

Don't:

• ❌ Create too many task types (keep it simple)

• ❌ Make user stories too large (split them)

• ❌ Skip acceptance criteria

• ❌ Forget to update task status

• ❌ Duplicate tasks between TodoWrite and files

• ❌ Create tasks without clear ownership

Integration

With plan-feature skill: After /plan-feature completes, it will suggest running this skill to export tasks to files.

With TodoWrite: Can read current TodoWrite tasks and convert them to structured files.

With Git: Task files are designed to be committed to version control for team collaboration.

File Structure

tasks/ ├── README.md # Overview of task system ├── INDEX.md # Auto-generated index of all tasks ├── epic-001-user-auth.md # Epic for authentication ├── story-001-login-model.md # User story for login model ├── story-002-login-controller.md # User story for login controller ├── story-003-login-ui.md # User story for login UI ├── bug-001-email-validation.md # Bug fix task └── issue-001-refactor-auth.md # Technical debt task

Example Usage

Scenario 1: After planning

/plan-feature "Add user authentication"

... planning completes ...

/create-task-files

Creates epic + 5 user stories in tasks/

Scenario 2: Standalone

/create-task-files

Asks: "Create tasks from todo list or feature description?"

Creates structured task files based on input

Scenario 3: Bug tracking

/create-task-files

Select: "Bug only"

Creates bug-001-description.md with proper template

Output

Creates structured markdown files in tasks/ directory with:

• Proper frontmatter (YAML)

• Consistent formatting

• Clear acceptance criteria

• Dependency tracking

• Status management

• Git-friendly format

This enables team collaboration, progress tracking, and version-controlled project management.