name: prd-taskmaster description: >- Smart PRD generator with TaskMaster integration. Detects existing PRDs and offers execute/update/replace options. Generates comprehensive technical PRDs optimized for task breakdown, validates with 13 automated checks, and optionally executes tasks autonomously with datetime tracking and rollback support. Use when user requests "PRD", "product requirements", or mentions task-driven development. Defaults to PRD generation with handoff to TaskMaster. Optionally supports autonomous execution with 4 modes. allowed-tools:

• Read
• Write
• Edit
• Grep
• Glob
• Bash
• AskUserQuestion

PRD Generator for TaskMaster v3.0

Smart PRD generation with deterministic operations handled by script.py. AI handles judgment (questions, content, decisions); script handles mechanics.

Script location: ~/.claude/skills/prd-taskmaster/script.py All script commands output JSON.

When to Use

Activate when user says: PRD, product requirements, taskmaster, task-driven development. Do NOT activate for: API docs, test specs, project timelines, PDF creation.

Core Principles

• Quality Over Speed: Planning is 95% of the work
• Taskmaster Required: Blocks if not detected
• Engineer-Focused: Technical depth, code examples, architecture
• Validation-Driven: 13 automated checks via script
• User Testing Checkpoints: Every 5 tasks

Workflow (12 Steps)

Step 1: Preflight & Resume Detection

python3 ~/.claude/skills/prd-taskmaster/script.py preflight

Returns JSON: has_taskmaster, prd_path, task_count, tasks_completed, tasks_pending, taskmaster_method, has_claude_md, has_crash_state, crash_state.

If has_crash_state is true: Present resume options to user:

1. Continue from last subtask
2. Restart current task
3. Resume from last checkpoint
4. Start fresh

Then proceed to Step 2.

Step 2: Detect Existing PRD

Use preflight JSON: if prd_path is not null and task_count > 0, an existing PRD is found.

If existing PRD found, use AskUserQuestion:

• Execute tasks from existing PRD (skip to Step 11)
• Update/refine existing PRD (edit and re-parse)
• Create new PRD (replace - backup first via script.py backup-prd --input <path>)
• Review existing PRD (display summary, then exit)

If no PRD found: Proceed to Step 3.

Step 3: Detect Taskmaster

Use preflight JSON field taskmaster_method: mcp, cli, or none.

If none: Block and show installation instructions:

• Option 1 (recommended): Install MCP Task-Master-AI
• Option 2: npm install -g task-master-ai
• Wait for user to install and confirm, then re-run: script.py detect-taskmaster

No proceeding without taskmaster detected.

Step 4: Discovery Questions

Ask detailed questions to build comprehensive PRD. Use AskUserQuestion for structured input.

Essential (5):

1. What problem does this solve? (user pain point, business impact)
2. Who is the target user/audience?
3. What is the proposed solution or feature?
4. What are the key success metrics?
5. What constraints exist? (technical, timeline, resources)

Technical (4): 6. Existing codebase or greenfield? 7. Tech stack? 8. Integration requirements? 9. Performance/scale requirements?

TaskMaster-specific (3): 10. Used taskmaster before? 11. Estimated complexity? (simple/typical/complex) 12. Timeline expectations?

Open-ended (1): 13. Anything else? (edge cases, constraints, context)

Smart defaults: If user provides minimal answers, use best guesses and document assumptions.

Step 5: Initialize Taskmaster

Only if .taskmaster/ doesn't exist (check preflight has_taskmaster).

python3 ~/.claude/skills/prd-taskmaster/script.py init-taskmaster --method <cli|mcp>

For MCP: use the returned params to call mcp__task-master-ai__initialize_project. For CLI: script runs taskmaster init directly.

Step 6: Generate PRD

Load template:

python3 ~/.claude/skills/prd-taskmaster/script.py load-template --type <comprehensive|minimal>

Returns JSON with content field containing the template.

AI judgment: Fill template with user's answers from Step 4:

• Replace placeholders with actual content
• Expand examples with project-specific details
• Add technical depth based on discovery answers

Write completed PRD to .taskmaster/docs/prd.md.

Step 7: Validate PRD Quality

python3 ~/.claude/skills/prd-taskmaster/script.py validate-prd --input .taskmaster/docs/prd.md

Returns JSON: score, max_score, grade, checks (13 items), warnings.

Grading: EXCELLENT (91%+), GOOD (83-90%), ACCEPTABLE (75-82%), NEEDS_WORK (<75%).

AI judgment: If warnings exist, offer user three options:

1. Proceed with current PRD
2. Auto-fix warnings
3. Review and fix manually

If grade is NEEDS_WORK, strongly recommend fixing before proceeding.

Step 8: Parse & Expand Tasks

Calculate task count:

python3 ~/.claude/skills/prd-taskmaster/script.py calc-tasks --requirements <count>

Returns recommended task count.

For MCP:

mcp__task-master-ai__parse_prd: input=".taskmaster/docs/prd.md", numTasks=<recommended>, research=true
mcp__task-master-ai__expand_all: research=true

For CLI:

taskmaster parse-prd --input .taskmaster/docs/prd.md --research --num-tasks <recommended>
taskmaster expand-all --research

Step 9: Insert User Test Tasks

python3 ~/.claude/skills/prd-taskmaster/script.py gen-test-tasks --total <task_count>

Returns array of USER-TEST task definitions with title, description, dependencies, template.

For each task in the array:

• MCP: mcp__task-master-ai__add_task with title, description, details=template, dependencies, priority=high
• CLI: taskmaster add-task --title="..." --description="..." --dependencies="..." --priority=high

Step 10: Setup Tracking Scripts

python3 ~/.claude/skills/prd-taskmaster/script.py gen-scripts --output-dir .taskmaster/scripts

Creates 5 scripts: track-time.py, rollback.sh, learn-accuracy.py, security-audit.py, execution-state.py.

Step 10.5: Generate CLAUDE.md

Pre-check: Use Glob to check if ./CLAUDE.md exists. If it exists, skip.

If generating:

1. Load template: script.py load-template won't work here -- use Read tool on ~/.claude/skills/prd-taskmaster/templates/CLAUDE.md.template
2. AI judgment: Replace placeholders with project-specific values from discovery:
   • {{PROJECT_NAME}}, {{TECH_STACK}}, {{ARCHITECTURE_OVERVIEW}}
   • {{KEY_DEPENDENCIES}}, {{TESTING_FRAMEWORK}}, {{DEV_ENVIRONMENT}}, {{TEST_COMMAND}}
3. Write to ./CLAUDE.md
4. Ask if user uses Codex -- if yes and no codex.md, write identical copy

Step 11: Choose Next Action

Use AskUserQuestion:

Question: "PRD and tasks ready. How to proceed?"

• Show TaskMaster Commands (default): Display command reference, then exit skill
• Autonomous Execution: Ask follow-up for execution mode

If Autonomous Execution selected, ask execution mode:

• Sequential to Checkpoint (recommended): Tasks one-by-one until next USER-TEST
• Parallel to Checkpoint: Independent tasks in parallel until USER-TEST
• Full Autonomous: All tasks parallel, skip user validation
• Manual Control: User decides each task

AI judgment: Recommend mode based on context:

• First-time/critical: Sequential
• Experienced/non-critical: Parallel
• Trusted/time-critical: Full Autonomous
• Complex/learning: Manual

Step 12: Summary & Start

If Handoff: Display PRD location, task counts, key requirements, validation score, task phases, user test checkpoints, and TaskMaster commands. Then exit skill.

If Autonomous: Display same summary plus execution mode, then begin execution using the selected mode's rules.

Execution Mode Rules

All Modes Include

• DateTime tracking: python3 .taskmaster/scripts/track-time.py start|complete <task_id> [subtask_id]
• Progress logging: python3 ~/.claude/skills/prd-taskmaster/script.py log-progress --task-id <id> --title "..." --duration "..." --subtasks "..." --tests "..." --issues "..."
• Git policy: Branch per task (task-{id}-{slug}), sub-branch per subtask, merge to main with checkpoint tag
• Rollback: If user says "rollback to task X", run bash .taskmaster/scripts/rollback.sh X
• State tracking: python3 .taskmaster/scripts/execution-state.py start|complete|checkpoint <task_id>

Sequential to Checkpoint

Execute tasks one-by-one. For each task:

1. Start time tracking
2. Create feature branch
3. For each subtask: create sub-branch, implement, test, commit, merge to task branch
4. Complete time tracking
5. Log progress
6. Merge to main, create checkpoint tag
7. Stop at next USER-TEST for user validation

Parallel to Checkpoint

Same as sequential but launch up to 3 concurrent independent tasks. Handle merge conflicts automatically. Stop at USER-TEST.

Full Autonomous

Maximum parallelization (up to 5 concurrent). Auto-complete USER-TEST tasks. Only stop when ALL tasks complete.

Manual Control

Wait for user commands: "next task", "task {id}", "status", "parallel {id1,id2}".

Tips

• More detail in discovery = better PRD
• Quantify goals: not "improve UX" but "increase NPS from 45 to 60"
• USER-TEST checkpoints catch issues early
• Git checkpoints allow easy rollback
• Use script.py validate-prd at any time to re-check PRD quality

PRD-Taskmaster: AI-Generated Product Requirements Documents

Comprehensive PRD generation optimized for AI-assisted development workflows

Install

curl -fsSL https://raw.githubusercontent.com/anombyte93/prd-taskmaster/master/install.sh | bash

This installs the skill to ~/.claude/skills/prd-taskmaster/. Run the same command to upgrade -- the installer checks for updates and only overwrites when there are changes.

Check for updates:

bash ~/.claude/skills/prd-taskmaster/install.sh --check-update

What is This?

A Claude Code skill that generates detailed, engineer-focused Product Requirements Documents (PRDs) designed to work seamlessly with AI task breakdown tools like Taskmaster.

Think of it as your AI product manager that asks the right questions, writes comprehensive specs, and sets you up for successful implementation.

Why You Might Want This

The Problem

You have an idea for a feature or product, but:

• Writing comprehensive PRDs takes hours
• You're not sure what details to include
• You want to use AI task breakdown tools (like Taskmaster) but they need detailed requirements
• Vague specs lead to vague tasks, which lead to poor implementations

The Solution

This skill:

1. Asks 12+ detailed questions to extract everything from your brain
2. Generates a comprehensive PRD with all the sections engineers need
3. Sets up taskmaster integration with proper directory structure
4. Validates quality with automated checks (13 different validations)
5. Suggests task breakdowns with complexity estimates and dependencies

Result: You go from "I have an idea" to "I have a complete, validated PRD ready for AI task generation" in minutes.

Installation

This skill works with Claude Code CLI and Codex (VS Code extension). Choose your tool below:

Option A: One-Liner (Recommended)

curl -fsSL https://raw.githubusercontent.com/anombyte93/prd-taskmaster/master/install.sh | bash

The installer handles everything: cloning, updating, and placing files in ~/.claude/skills/prd-taskmaster/.

Option B: Manual Clone

cd ~/.claude/skills
git clone https://github.com/anombyte93/prd-taskmaster.git

Option C: Codex (Untested)

Prerequisites:

• Codex (see)
• Git

Install the skill:

# Clone to where you want to run codex
cd ~/<wherever>
git clone https://github.com/anombyte93/prd-taskmaster.git
cd prd-taskmaster

Configure Codex to find the skill:

1. Run Codex in the prd-taskmaster directory
2. Initialize Codex: /init
3. Codex will read SKILL.md and understand how to generate PRDs

Using the generated codex.md:

When the skill generates a PRD for your project, it will ask if you're using Codex:

• If yes: Creates both CLAUDE.md and codex.md in your project root
• If no: Creates only CLAUDE.md

The codex.md file guides Codex to follow TDD workflow, use agents, and maintain quality gates throughout development.

Verify installation:

# Start Claude Code in any project
claude

# In the chat, type:
# "I want a PRD for adding dark mode"

Claude Code should recognize the skill and activate it automatically.

Troubleshooting:

• If skill doesn't activate, check it's in ~/.claude/skills/prd-taskmaster/
• Verify SKILL.md exists in that directory
• Try restarting Claude Code

Quick Start Guide

Basic Usage

Once installed, just tell Claude/Codex you want a PRD:

"I want a PRD for [your feature/product]"

Activation phrases:

• "I want a PRD for adding two-factor authentication"
• "Create product requirements for a user dashboard"
• "Write a PRD for integrating with Stripe payments"
• "Generate requirements for building a dark mode feature"

What Happens Next

The skill runs a 12-step workflow:

1. Checks for existing work - Detects previous PRDs and crash state for auto-resume
2. Offers options - Execute, update, replace, or review existing PRDs
3. Detects Taskmaster - MCP or CLI, blocks if neither is installed
4. Asks 12+ detailed questions - Problem, users, metrics, tech stack, constraints
5. Initializes Taskmaster - Sets up .taskmaster/ directory structure
6. Generates a comprehensive PRD - From templates, filled with your answers
7. Validates quality - 13 automated checks with a letter grade
8. Parses and expands tasks - Breaks PRD into actionable tasks with subtasks
9. Inserts user test checkpoints - Every 5 tasks, a manual validation point
10. Sets up tracking scripts - 5 scripts for time tracking, rollback, accuracy learning, security audit, and execution state
11. Generates CLAUDE.md - TDD workflow guide for your project (if one doesn't exist)
12. Hands off or executes - Your choice: command reference or autonomous execution in 4 modes

First-Time Tips

Be detailed in your answers! The more context you provide, the better the PRD.

Example good answer:

"We need 2FA because we're seeing 150 security incidents per month from compromised accounts. Target users are enterprise customers who require SOC2 compliance. Success = reduce incidents to <10/month and meet SOC2 requirements."

Example too-vague answer:

"We need 2FA for security."

Don't worry about perfect answers - the skill will ask follow-ups if needed!

What You Get

Comprehensive PRD

A complete product requirements document with:

• Executive Summary - Quick overview
• Problem Statement - User pain points & business impact
• Goals & Metrics - SMART success criteria
• User Stories - With acceptance criteria
• Functional Requirements - Detailed, testable specs
• Technical Considerations - Architecture, data models, APIs
• Task Breakdown Hints - For AI task generation
• Dependencies - What depends on what
• Out of Scope - What you're NOT building

Taskmaster Integration

Automatically sets up:

.taskmaster/
├── docs/
│   ├── prd.md              # Your generated PRD
│   └── architecture.md     # Placeholder for architecture docs
├── tasks/
│   └── .gitkeep
├── scripts/
│   ├── track-time.py       # DateTime tracking per task
│   ├── rollback.sh         # Rollback to any checkpoint
│   ├── learn-accuracy.py   # Estimate vs actual analysis
│   ├── security-audit.py   # Auto-generated security checks
│   └── execution-state.py  # Crash recovery state
├── notes/
│   └── .gitkeep
└── .gitignore              # Updated to exclude taskmaster artifacts

CLAUDE.md / codex.md - TDD Workflow Guide

Generates a comprehensive workflow file in your project root that guides Claude Code/Codex to:

• Follow TDD by default - Write tests first, then implementation
• Use blind-validator agent - Validate against PRD without seeing code
• Execute parallel tasks - Run independent tasks simultaneously
• Leverage agents - For validation, exploration, and context optimization
• Enforce quality gates - Automated validation before marking tasks complete
• Follow taskmaster best practices - Optimal workflow for AI-assisted development

File naming:

• Claude Code: Creates CLAUDE.md (read automatically by Claude Code)
• Codex: Creates codex.md (read by Codex when initialized with /init)
• The skill will ask which tool you're using and create the appropriate file(s)

Quality Validation

13 automated checks ensure:

• All required sections are present
• Requirements are testable (not vague)
• Success metrics are SMART
• Technical considerations address architecture
• Task breakdown hints are included
• Dependencies are mapped

Grading scale: EXCELLENT (91%+), GOOD (83-90%), ACCEPTABLE (75-82%), NEEDS_WORK (<75%).

Example Output

PRD Created: .taskmaster/docs/prd.md
CLAUDE.md Generated: Project root (TDD workflow guide)

Overview:
  - Feature: Two-Factor Authentication
  - Complexity: Medium
  - Estimated Effort: 26 tasks, ~119 hours
  - Key Goal: Reduce security incidents from 150/month to <10/month

Key Requirements:
  1. REQ-001: TOTP/SMS 2FA support
  2. REQ-002: Backup codes for recovery
  3. REQ-003: Login flow integration

Technical Highlights:
  - Architecture: Auth service + Redis for sessions
  - Integration: Twilio for SMS delivery
  - Database: 2 new tables (user_2fa, backup_codes)

Quality Validation: 58/60 (EXCELLENT)
  - All required elements present
  - 1 minor warning (REQ-007 has vague language)

Suggested Task Breakdown:
  - Phase 1: 3 tasks (foundation)
  - Phase 2: 8 tasks (core features)
  - Phase 3: 5 tasks (testing)

Next Steps:
  1. Review PRD: .taskmaster/docs/prd.md
  2. Generate tasks: taskmaster generate
  3. Begin implementation: taskmaster next-task

Who Is This For?

Perfect For You If:

• You use AI-assisted development workflows (Claude, Cursor, etc.)
• You want to use Taskmaster or similar task breakdown tools
• You're building features/products and need comprehensive specs
• You prefer detailed planning before coding
• You're tired of writing PRDs manually

Maybe Not For You If:

• You prefer writing PRDs entirely yourself