PRD to td — Requirements Decomposition for td Task Management

Transform product requirements documents into a fully populated td backlog with epics, features, tasks, priorities, and dependency tracking.

When to Use This Skill

Use when:

• You have a PRD, concept brief, feature spec, RFC, or architecture doc

• You need to populate td with structured work items

• You're starting a new project or major feature and need a task breakdown

• You want to convert informal requirements into actionable tracked work

Process Overview

PRD/Brief/Spec │ ▼ ┌─────────────┐ │ 1. PARSE │ Extract vision, features, constraints, dependencies └──────┬──────┘ │ ▼ ┌─────────────┐ │ 2. CLASSIFY │ Assign priorities (P0-P3), identify scope boundaries └──────┬──────┘ │ ▼ ┌─────────────┐ │ 3. DECOMPOSE│ Epic → Feature → Task hierarchy (tasks ≤ 8 hours) └──────┬──────┘ │ ▼ ┌─────────────┐ │ 4. MAP DEPS │ Identify blockers, critical path, execution order └──────┬──────┘ │ ▼ ┌─────────────┐ │ 5. CREATE │ td create for each issue, log dependencies └──────┬──────┘ │ ▼ ┌─────────────┐ │ 6. PLAN │ Write plan file with dependency graph + critical path └─────────────┘

Outputs

Output Location Purpose

td issues .todos/ (via td create ) Trackable work items

Plan file ~/.claude/plans/<repo>-plan.md

Dependency graph, critical path, architecture notes

Summary stdout Counts, critical path, recommended first actions

Quick Start

Input: Give the skill a document

Any of these work:

• A file path: Analyze /path/to/prd.md and create td issues

• Pasted text: Here's our PRD: [content]

• A description: We're building X with these features...

The skill then:

• Reads and analyzes the document

• Asks clarifying questions if critical gaps exist (max 3-5 questions)

• Creates the full td backlog

• Writes the plan file

• Reports what was created and recommends where to start

Step 1: Parse the Document

Extract these elements from any input format:

Element What to Find Required?

Vision Why build this? Problem solved? Yes

Users Who uses it? Personas? Yes

Features What does it do? Yes

Scope What's included/excluded? Recommended

Tech stack Languages, frameworks, infrastructure If specified

Constraints Timeline, budget, team size If specified

Dependencies External systems, APIs, teams If specified

Success metrics How measured? If specified

Document Types Handled

Type Approach

Formal PRD Direct extraction — sections map cleanly

Concept brief Infer details, flag assumptions, ask questions

Feature spec Technical → functional mapping, reverse-engineer user needs

Architecture doc Extract components as epics, interfaces as features

Informal description Structure it, propose scope, validate with user

Gap Detection

Flag missing information rather than assuming:

GAPS IDENTIFIED:

• No success metrics defined
• Authentication method unspecified (SSO? OAuth? Email/password?)
• Mobile behavior not addressed
• Data retention policy unclear

ASSUMPTIONS MADE (flag for user validation):

• English-only (i18n not mentioned)
• Web-only (mobile not specified)

If gaps are critical (can't decompose without answers), ask the user before proceeding. Non-critical gaps get logged as notes in the plan file.

Step 2: Classify and Prioritize

Priority Levels

Priority Meaning Criteria

P0 Must have Product doesn't work without it. Launch blocker.

P1 Should have Significant user value. Not blocking but important.

P2 Nice to have Improves experience, not critical. Future iteration candidate.

P3 Out of scope Explicitly excluded or deferred. Don't create td issues.

Classification Rules

• If the PRD says "must have" or "required" → P0

• If it says "should" or "important" → P1

• If it says "nice to have" or "future" → P2

• If it says "out of scope" or "not included" → P3 (skip)

• When unclear, default to P1 and flag for user validation

Step 3: Decompose into Hierarchy

td Issue Type Mapping

PRD Feature Area → td epic (--type epic) User Capability → td feature (--type feature) Implementation → td task (--type task) Bug/Fix → td bug (--type bug)

Hierarchy Rules

Level td type Scope Duration Target

Epic epic

Large feature area 1-4 weeks

Feature feature

User-facing capability 1-5 days

Task task

Implementable unit 1-8 hours

Naming Conventions

Use these prefixes in td issue titles for scannability:

Epics: "E001: User Authentication" Features: "User registration with email/password" Tasks: "Create users table schema"

Epic IDs (E001, E002, ...) go in the title. Features and tasks reference their parent epic in the description.

Decomposition Process

• Identify epics from major feature areas in the PRD

• Break each epic into user-facing features (INVEST criteria: Independent, Negotiable, Valuable, Estimable, Small, Testable)

• Break large features into tasks if they exceed 5 days

• Tag everything with type and priority

Size Limits

If estimated at... Action

4 weeks Split into multiple epics

5 days (feature) Split into smaller features or break into tasks

8 hours (task) Split into smaller tasks

Step 4: Map Dependencies

Dependency Tracking in td

td has flat issues with a block command that sets status. It does NOT have built-in dependency relationships. Dependencies are tracked in TWO places:

• Issue descriptions: Each issue's description lists what it blocks and what blocks it

• Plan file: The plan file contains the full dependency graph and critical path

Dependency Template for Issue Descriptions

Dependencies

• Blocks: [list of issue IDs this enables]
• Blocked by: [list of issue IDs that must complete first]
• Related: [list of related but non-blocking issues]

Critical Path

Identify the longest chain of dependent work — this determines minimum project duration.

Example: DB Schema (2h) → Data Model (3h) → API Layer (8h) → Integration Tests (4h) Total critical path: 17h minimum

Record the critical path in the plan file.

Step 5: Create td Issues

Creation Order

• Create epics first (they're referenced by features/tasks)

• Create features in dependency order

• Create tasks in dependency order

• Log the mapping of td IDs to plan IDs

td Commands Used

Create an epic

td create "E001: User Authentication" --type epic --priority P0

Create a feature under an epic

td create "User registration with email/password" --type feature --priority P0

Create a task

td create "Create users table schema" --type task --priority P0

Log dependency info (since td doesn't have native dep tracking)

td log "Blocked by: td-XXXX (DB schema). Blocks: td-YYYY (API layer)."

Description Template

Every created issue gets a structured description:

[One-line summary of what this delivers]

Parent Epic

E001: [Epic name]

Acceptance Criteria

• [Criterion 1]
• [Criterion 2]

Dependencies

• Blocks: [issue IDs]
• Blocked by: [issue IDs]

Technical Notes

[Implementation hints, constraints, key files]

Estimate

[X hours/days]

Batch Creation

When creating many issues, use a work session:

td ws start "PRD breakdown: [project name]"

... create all issues ...

td ws log "Created N epics, M features, K tasks from PRD" td ws handoff

Step 6: Write Plan File

Location

~/.claude/plans/<repo-name>-plan.md

If a plan file already exists, append a new section rather than overwriting.

Plan File Template

[Project Name] — Implementation Plan

Source: [PRD filename or "user description"] Created: [date] Epics: [count] Features: [count] Tasks: [count] Estimated effort: [total hours/days]

Epic Overview

Dependency Graph

E001: DB Foundation └── td-XXXX: Create schema ──→ td-YYYY: Data model ──→ td-ZZZZ: API layer E002: Authentication └── td-AAAA: Auth service (blocked by E001) ──→ td-BBBB: Login UI

Critical Path

[Longest dependency chain with total duration]

Execution Order

Recommended order for starting work:

1. Start immediately (no blockers):

   • td-XXXX: [title]
   • td-YYYY: [title]

2. After phase 1:

   • td-ZZZZ: [title] (blocked by td-XXXX)

3. After phase 2:

   • td-AAAA: [title] (blocked by td-ZZZZ)

Open Questions

• [Questions flagged during analysis]

Assumptions

• [Assumptions made during decomposition]

Anti-Patterns

Anti-Pattern Problem What to Do Instead

Creating 100+ flat tasks Unmanageable backlog Group under epics, keep features at 5-day max

Everything is P0 No real prioritization Force-rank: only 30% should be P0

Vague task titles "Work on auth" — what specifically? Specific deliverables: "Create JWT token service"

Skipping dependency mapping Work gets blocked unexpectedly Always identify what blocks what

Assuming instead of asking Build wrong thing Flag gaps, ask 3-5 clarifying questions

Giant tasks (> 8h) Can't track progress Split until each piece is ≤ 8 hours

No plan file Dependencies live only in your head Always write the plan file

Worked Example

Input

"We need a REST API for a bookstore. Users can browse books, search by title/author/genre, add to cart, and checkout. Admin can manage inventory. We're using Python/FastAPI with PostgreSQL."

Output

Epics

td create "E001: Book Catalog & Search" --type epic --priority P0 td create "E002: Shopping Cart" --type epic --priority P0 td create "E003: Checkout & Orders" --type epic --priority P0 td create "E004: Admin Inventory Management" --type epic --priority P1

E001 Features

td create "Browse books with pagination" --type feature --priority P0 td create "Search books by title, author, genre" --type feature --priority P0 td create "Book detail view with metadata" --type feature --priority P1

E001 Tasks (for search feature)

td create "Design books table schema" --type task --priority P0 td create "Implement full-text search with pg_trgm" --type task --priority P0 td create "Create /books/search endpoint with filters" --type task --priority P0

... continue for all epics

Plan file written to ~/.claude/plans/bookstore-api-plan.md with dependency graph and critical path.

References

• references/td-mapping.md — Detailed mapping from PRD structures to td issue types

• references/analysis-guide.md — Document parsing methodology and gap detection