Analyzes PRD documents, concept briefs, or feature specs and creates structured implementation plans with visual kanban tracking. Breaks requirements into epics, stories, and tasks with dependencies and estimates. Outputs to `.claude/` folder for integration with project-harness and other skills. Generates PROJECT.md for shared project context.
Analyzes PRD documents and creates structured implementation plans with task breakdowns and kanban tracking.
/plugin marketplace add srstomp/pokayokay/plugin install srstomp-pokayokay@srstomp/pokayokayThis skill inherits all available tools. When active, it can use any tool Claude has access to.
references/kanban-setup.mdreferences/prd-analysis.mdreferences/skill-routing.mdreferences/task-breakdown.mdtemplates/kanban.htmlTransform product requirements into actionable implementation plans with visual kanban tracking.
Integrates with:
product-manager — Audits completeness, adds remediation tasksproject-harness — Reads PROJECT.md, manages work sessionsux-design, api-design, etc. — Assigned to specific featuresPRD/Brief → Analysis → Task Breakdown → .claude/ Output
│ │ │ │
Upload Extract Epic → PROJECT.md
doc scope & Story → tasks.db
features Task features.json
kanban.html
All outputs go to .claude/ folder in the project root:
.claude/
├── PROJECT.md ← Project context (all skills read this)
├── tasks.db ← SQLite database (source of truth)
├── features.json ← Feature definitions with skill assignments
├── kanban.html ← Interactive board
├── progress.md ← Session progress tracking
└── implementation-plan.md ← Markdown summary
When given a PRD or concept brief:
1. Read the entire document
2. Extract: Goals, Features, Constraints, Dependencies
3. Identify scope boundaries (in/out)
4. Note technical requirements and assumptions
5. Assign skills to features based on type
Structure work hierarchically:
Epic (large feature area)
├── Story (user-facing capability)
│ ├── Task (implementable unit, 1-8 hours)
│ ├── Task
│ └── Task
└── Story
└── Tasks...
Create all files in .claude/:
PROJECT.md — Shared context for all skillstasks.db — SQLite database with full task structurefeatures.json — Feature list with metadatakanban.html — Interactive board (open in browser)The most important output — shared context for all skills.
# Project: [Name]
## Overview
[1-2 sentence description from PRD]
## Status
- **Phase**: Planning | Design | Implementation | Polish | Launch
- **Created**: [Date]
- **Last Updated**: [Date]
- **Overall Progress**: 0/[N] stories complete
## Metrics
| Metric | Count |
|--------|-------|
| Epics | [N] |
| Stories | [N] |
| Estimated Hours | [N] |
| Estimated Days | [N] |
## Tech Stack
- **Frontend**: [Framework]
- **Backend**: [Framework]
- **Database**: [Database]
- **Hosting**: [Platform]
## Feature Overview
| ID | Feature | Priority | Skill | Status |
|----|---------|----------|-------|--------|
| F001 | [Name] | P0 | [skill] | planned |
| F002 | [Name] | P0 | [skill] | planned |
| ... | ... | ... | ... | ... |
## Skill Assignments
| Skill | Features | Status |
|-------|----------|--------|
| ux-design | F001, F005, F012 | pending |
| api-design | F002, F003, F007 | pending |
| aesthetic-ui-designer | F001, F005 | blocked by ux-design |
## Current Gaps
[Updated by product-manager after audit]
## Next Actions
1. [First recommended action]
2. [Second recommended action]
## Key Files
- PRD: [path or "uploaded"]
- Tasks DB: `.claude/tasks.db`
- Kanban: `.claude/kanban.html`
## Session Log
| Date | Session | Completed | Notes |
|------|---------|-----------|-------|
| [Date] | prd-analyzer | PROJECT.md, tasks.db | Initial setup |
Assign skills to features based on their nature.
| Feature Type | Primary Skill | Secondary Skills |
|---|---|---|
| User flows, wireframes | ux-design | persona-creation |
| REST/GraphQL APIs | api-design | api-testing |
| UI implementation | aesthetic-ui-designer | frontend-design |
| SDK/library creation | sdk-development | — |
| Data visualization | ux-design | aesthetic-ui-designer |
| Authentication/Security | api-design | — |
| Mobile screens | ux-design | aesthetic-ui-designer |
| Integrations (Slack, etc.) | api-design | — |
| Accessibility review | accessibility-auditor | — |
ux-design firstapi-design firstproduct-manager auditaccessibility-auditor{
"features": [
{
"id": "F001",
"title": "Survey Studio",
"priority": "P0",
"assigned_skills": ["ux-design", "aesthetic-ui-designer"],
"skill_order": ["ux-design", "aesthetic-ui-designer"],
"current_skill": null,
"audit_level": 0,
"stories": ["story-001-01", "story-001-02", ...]
}
]
}
Extract these elements from any PRD/brief:
| Element | What to Find | Output |
|---|---|---|
| Vision | Why build this? Problem solved? | 1-2 sentence summary |
| Users | Who uses it? Personas? | User types list |
| Features | What does it do? | Feature list with priority |
| Scope | What's included/excluded? | In/Out lists |
| Constraints | Tech stack, timeline, budget? | Constraint list |
| Dependencies | External systems, APIs, teams? | Dependency map |
| Success Metrics | How measured? | KPI list |
| Risks | What could go wrong? | Risk register |
For each feature, classify:
P0 - Must Have (MVP, launch blocker)
P1 - Should Have (important, not blocking)
P2 - Nice to Have (future iteration)
P3 - Out of Scope (explicitly excluded)
Flag unclear requirements:
## Ambiguities Identified
1. **User authentication** — SSO required? Which providers?
2. **Data export** — Format not specified (CSV? JSON? Excel?)
3. **Mobile support** — Responsive web or native apps?
Recommend: Clarify before implementation planning.
-- Enable foreign keys
PRAGMA foreign_keys = ON;
-- Projects table
CREATE TABLE IF NOT EXISTS projects (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
description TEXT,
phase TEXT DEFAULT 'planning'
CHECK(phase IN ('planning', 'design', 'implementation', 'polish', 'launch')),
tech_stack TEXT, -- JSON: {frontend, backend, database, hosting}
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
-- Epics: Large feature areas
CREATE TABLE IF NOT EXISTS epics (
id TEXT PRIMARY KEY,
project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
title TEXT NOT NULL,
description TEXT,
priority TEXT CHECK(priority IN ('P0', 'P1', 'P2', 'P3')) DEFAULT 'P1',
status TEXT CHECK(status IN ('planned', 'in_progress', 'completed', 'cancelled')) DEFAULT 'planned',
-- Skill assignment
assigned_skills TEXT, -- JSON array: ["ux-design", "api-design"]
skill_order TEXT, -- JSON array: order to run skills
current_skill TEXT, -- Currently active skill
-- Audit fields (updated by product-manager)
audit_level INTEGER DEFAULT 0
CHECK(audit_level BETWEEN 0 AND 5),
audit_date TEXT,
audit_gaps TEXT, -- JSON array: ["no_frontend", "no_navigation"]
color TEXT,
sort_order INTEGER DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
-- Stories: User-facing capabilities
CREATE TABLE IF NOT EXISTS stories (
id TEXT PRIMARY KEY,
epic_id TEXT REFERENCES epics(id) ON DELETE CASCADE,
title TEXT NOT NULL,
description TEXT,
user_story TEXT,
acceptance_criteria TEXT,
estimate_days REAL,
status TEXT CHECK(status IN ('backlog', 'ready', 'in_progress', 'review', 'done')) DEFAULT 'backlog',
assigned_skill TEXT, -- Which skill handles this story
sort_order INTEGER DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
-- Tasks: Implementable units
CREATE TABLE IF NOT EXISTS tasks (
id TEXT PRIMARY KEY,
story_id TEXT REFERENCES stories(id) ON DELETE CASCADE,
title TEXT NOT NULL,
description TEXT,
task_type TEXT CHECK(task_type IN ('frontend', 'backend', 'database', 'design', 'devops', 'qa', 'documentation', 'other')) DEFAULT 'other',
estimate_hours REAL,
status TEXT DEFAULT 'todo'
CHECK(status IN ('todo', 'in_progress', 'review', 'done', 'blocked')),
assignee TEXT,
column_id TEXT DEFAULT 'todo',
sort_order INTEGER DEFAULT 0,
blocked_reason TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
started_at TIMESTAMP,
completed_at TIMESTAMP
);
-- Dependencies between tasks
CREATE TABLE IF NOT EXISTS dependencies (
id INTEGER PRIMARY KEY AUTOINCREMENT,
blocker_task_id TEXT REFERENCES tasks(id) ON DELETE CASCADE,
blocked_task_id TEXT REFERENCES tasks(id) ON DELETE CASCADE,
dependency_type TEXT CHECK(dependency_type IN ('blocks', 'related')) DEFAULT 'blocks',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UNIQUE(blocker_task_id, blocked_task_id)
);
-- Session log (for project-harness integration)
CREATE TABLE IF NOT EXISTS sessions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
session_id TEXT UNIQUE NOT NULL,
skill_used TEXT,
started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
completed_at TIMESTAMP,
stories_completed TEXT, -- JSON array of story IDs
notes TEXT
);
-- Indexes
CREATE INDEX IF NOT EXISTS idx_epics_priority ON epics(priority);
CREATE INDEX IF NOT EXISTS idx_epics_audit ON epics(audit_level);
CREATE INDEX IF NOT EXISTS idx_stories_epic ON stories(epic_id);
CREATE INDEX IF NOT EXISTS idx_stories_status ON stories(status);
CREATE INDEX IF NOT EXISTS idx_tasks_story ON tasks(story_id);
CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
-- Useful views
CREATE VIEW IF NOT EXISTS v_epic_progress AS
SELECT
e.id,
e.title,
e.priority,
e.audit_level,
e.assigned_skills,
COUNT(s.id) as total_stories,
SUM(CASE WHEN s.status = 'done' THEN 1 ELSE 0 END) as done_stories,
ROUND(100.0 * SUM(CASE WHEN s.status = 'done' THEN 1 ELSE 0 END) / COUNT(s.id), 1) as progress_pct
FROM epics e
LEFT JOIN stories s ON s.epic_id = e.id
GROUP BY e.id;
CREATE VIEW IF NOT EXISTS v_skill_workload AS
SELECT
e.assigned_skills,
COUNT(DISTINCT e.id) as epic_count,
COUNT(s.id) as story_count,
SUM(CASE WHEN s.status != 'done' THEN 1 ELSE 0 END) as pending_stories
FROM epics e
LEFT JOIN stories s ON s.epic_id = e.id
GROUP BY e.assigned_skills;
Epics are large feature areas (1-4 weeks of work):
## Epic: User Authentication
**ID**: epic-001 (or F001)
**Priority**: P0
**Assigned Skills**: ["api-design", "ux-design", "aesthetic-ui-designer"]
**Skill Order**: api-design → ux-design → aesthetic-ui-designer
**Goal**: Users can create accounts and log in securely
**Scope**: Email/password, OAuth (Google, GitHub), password reset
**Out of Scope**: SSO, 2FA (P2)
**Dependencies**: Email service, OAuth provider setup
**Estimate**: 2 weeks
Stories are user-facing capabilities (1-5 days):
### Story: Email/Password Registration
**ID**: story-001-01
**Epic**: epic-001
**Assigned Skill**: api-design (backend-heavy story)
**As a** new user
**I want to** create an account with email and password
**So that** I can access the application
**Acceptance Criteria**:
- [ ] Email validation (format, uniqueness)
- [ ] Password requirements (8+ chars, complexity)
- [ ] Email verification flow
- [ ] Error handling for duplicates
**Estimate**: 3 days
Tasks are implementable units (1-8 hours):
#### Task: Create registration form component
**ID**: task-001-01-01
**Story**: story-001-01
**Type**: Frontend
**Estimate**: 4h
**Description**:
- Email input with validation
- Password input with strength indicator
- Confirm password field
- Submit button with loading state
**Acceptance**: Form validates and submits to API
**Blocked By**: None
**Blocks**: Registration API integration
Receive PRD/Brief
Create Analysis Summary
Break Down Tasks
Generate Outputs to .claude/
Deliver Files
.claude/ folder{
"project": {
"name": "VoiceForm AI",
"description": "AI-powered voice survey platform",
"created_at": "2026-01-10T10:00:00Z"
},
"summary": {
"total_epics": 30,
"total_stories": 150,
"total_hours": 1972,
"by_priority": {
"P0": 5,
"P1": 12,
"P2": 10,
"P3": 3
}
},
"features": [
{
"id": "F001",
"epic_id": "epic-001",
"title": "Survey Studio",
"description": "Create and configure surveys with AI assistance",
"priority": "P0",
"assigned_skills": ["ux-design", "aesthetic-ui-designer"],
"skill_order": ["ux-design", "aesthetic-ui-designer"],
"dependencies": [],
"audit_level": 0,
"stories": ["story-001-01", "story-001-02", "story-001-03", "story-001-04", "story-001-05"]
},
{
"id": "F002",
"epic_id": "epic-002",
"title": "RAG Pipeline",
"description": "Document processing and semantic search",
"priority": "P0",
"assigned_skills": ["api-design"],
"skill_order": ["api-design"],
"dependencies": ["F001"],
"audit_level": 0,
"stories": ["story-002-01", "story-002-02", "story-002-03", "story-002-04", "story-002-05"]
}
],
"skill_summary": {
"ux-design": ["F001", "F003", "F011"],
"api-design": ["F002", "F007", "F008"],
"aesthetic-ui-designer": ["F001", "F003", "F011"],
"accessibility-auditor": ["F001", "F003"]
}
}
After implementation, product-manager:
tasks.db and features.jsonaudit_level and audit_gaps in epics tabletasks.dbPROJECT.md with current gapsProject-harness:
PROJECT.md for contexttasks.db for next worksessions tableprogress.md after each sessionSkills like ux-design, api-design:
PROJECT.md for contextfeatures.json for assigned workassigned_skills containing their name| Anti-Pattern | Problem | Fix |
|---|---|---|
| Accepting vague requirements | Builds wrong thing | Flag ambiguities, ask questions |
| Scope creep in breakdown | Adds unspecified work | Stick to documented requirements |
| Ignoring constraints | Infeasible plan | Check tech stack, timeline, budget |
| Missing dependencies | Blocked work | Map all external dependencies |
| No skill assignment | Work not routed | Assign skills to every feature |
| Anti-Pattern | Problem | Fix |
|---|---|---|
| Tasks > 8 hours | Too vague to estimate | Split into smaller tasks |
| No acceptance criteria | Unclear "done" | Define measurable criteria |
| Missing task types | Can't assign properly | Tag: frontend, backend, design, etc. |
| Circular dependencies | Deadlock | Identify and break cycles |
| Everything P0 | No prioritization | Force-rank priorities |
| Anti-Pattern | Problem | Fix |
|---|---|---|
| Output to random location | Skills can't find | Always use .claude/ |
| No PROJECT.md | No shared context | Always generate PROJECT.md |
| No skill assignments | Manual routing needed | Assign skills during analysis |
| Missing features.json | No machine-readable list | Always generate features.json |
.claude/ folder createdActivates when the user asks about AI prompts, needs prompt templates, wants to search for prompts, or mentions prompts.chat. Use for discovering, retrieving, and improving prompts.
Activates when the user asks about Agent Skills, wants to find reusable AI capabilities, needs to install skills, or mentions skills for Claude. Use for discovering, retrieving, and installing skills.
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.