Product Team · Claude Code Skills · 2026

A complete workflow system for product teams

Structured skills, commands, and context files that turn Claude Code into a context-aware partner for Product Managers and Product Designers — personalized to your product, enforced by policy.

16
PM Skills (10 + 6 shared)
15
Designer Skills (9 + 6 shared)
4
Chain Commands
4
Context Layers

Not prompts. A workflow system.

Prompts are single-use instructions. This package installs a full context system — skills, commands, rules, and project-specific knowledge — that Claude loads on every session, so you never have to re-explain your product.

Policy Layer

Skills & Commands

Skill files define how Claude works. Command files chain skills into workflows. Rules enforce boundaries. Output styles standardize responses. These are identical for everyone.

Dynamic Layer

Your Product Context

Generated once from an interview (PM) or from Figma directly (Designer). Contains your product's specific decisions, design system, component inventory, and team conventions. Never committed to the policy layer.

Personal Layer

Private & gitignored

CLAUDE.local.md and settings.local.json are gitignored. Personal notes, preferences, and local overrides never leave your machine.

The key principle: Claude Code reads CLAUDE.md automatically on every session. That file contains your product context. Skills read their companion context.md files for deeper knowledge. No re-explaining. No copy-pasting. Context is always loaded.

4-Layer Context Assembly

Every Claude request draws from four layers, merged in order. The deeper the layer, the more specific to your product.

Layer 1 · Policy
Skills, commands, rules, output styles
~/.claude/ and claude-workflow/policy/ — updated via claude-pm update
Identical for all users npm update
Layer 2 · Interview
PM: 647-line interview · Designer: Figma-based automated onboarding
Run once. Generates all context files in Layer 3.
Run once /start-interview
Layer 3 · Dynamic
CLAUDE.md + context.md files + agent definitions
PM: 14 files · Designer: 11 files · Unique per user and product
Generated · never overwritten
Layer 4 · Personal
CLAUDE.local.md + settings.local.json
Gitignored · never committed · private notes and local overrides
Gitignored · private

6 Phases · 3 Zones · Collaboration Points

The PM and Designer work in parallel across 6 phases. Skills are mapped to the phase where they're most useful. Tech provides input and receives handoffs at defined collaboration points.

PM Zone (Blue)
Phase 1 · Discovery & Scoping
problem-framing feature-prioritization decision-logger
Phase 2 · Refinement & Edge Cases
edge-case-finder scope-check feature-dependency
Phase 3 · Design Execution
PM monitors — Design leads
Phase 4 · Spec & Handoff
requirement-writer feature-spec release-impact
Phase 5 · Implementation
qa-guide release-impact
Phase 6 · Post-Release
decision-logger qa-guide
Designer Zone (Purple)
Phase 1 · Discovery & Scoping
design-system-check (shared)
Phase 2 · Refinement
vuetify-constraint-check design-research
Phase 3 · Design Execution
design-policy-review microcopy-writer wireframe-generator
Phase 4 · Spec & Handoff
design-qa design-handoff figma-to-code
Phase 5 · Implementation
implementation-review design-qa
Phase 6 · Post-Release
design-policy-review policy updates
Tech Zone
Ph.1
Sprint planning, backlog input
Ph.2
Feasibility input
Ph.3
Parallel dev work
Ph.4
Receives handoffs
Ph.5
Implements, fixes
Ph.6
Monitoring, incidents
Collaboration Points
Phase 1→2: PM hands problem framing to Designer for design-system-check
Phase 2→3: Designer gets edge cases from PM to inform state coverage
Phase 3→4: PM runs /new-feature while Designer runs /design-review
Phase 4→5: requirement-writer + design-handoff go to Tech simultaneously
Phase 5: implementation-review connects Designer to built component
Phase 6: decision-logger captures post-release learnings for future features

Identified gaps: brief format requests (task-writer handles this), design review feedback loops (decision-logger captures design decisions), handoff checklist verification (design-qa + design-handoff chain), developer confusion after handoff (figma-to-code produces reference code), QA triage process (qa-guide generates prioritized test plans).

Multi-skill workflows in one command

Chain commands run multiple skills in sequence, wait for approval between steps, and produce a combined output. They represent the most common full-workflow paths.

PM Chain

/new-feature

Complete end-to-end feature definition: problem framing → dependencies → edge cases → design system check → wireframe → spec. Six skills, one command, PM approves each step.

problem-framing → feature-dependency → edge-case-finder → design-system-check → wireframe-generator → feature-spec
PM Chain

/release-check

Pre-release impact analysis and test plan from the codebase and git history. Reads changes, maps affected modules, generates prioritized test cases.

release-impact → qa-guide
PM Chain

/sync-spec

Compare spec against implementation. Finds where the spec is outdated, where code deviated, and where the PM must decide which is right. Never auto-updates files.

Reads spec file + codebase + git history → drift report
Designer Chain

/design-review

Full design review — policy compliance check then deep Vuetify constraint check. Produces a unified report with blockers, important findings, and optional improvements.

design-policy-review → vuetify-constraint-check → unified report

All 25 skills at a glance

Each skill has a dedicated command with the same name. Invoke directly or let chain commands run them in sequence.

PM Skills — 10 unique

problem-framing

Vague idea → engineering-ready DOD

feature-prioritization

Defensible prioritization with trade-offs

feature-dependency

Codebase dependency analysis

edge-case-finder

Stress-test feature definitions

scope-check

Scope creep detection and trimming

feature-spec

Team alignment spec document

requirement-writer

Engineering-precise requirements

release-impact

Pre-release impact analysis

qa-guide

Prioritized test plan from codebase

decision-logger

Capture product decisions

Designer Skills — 9 unique

design-research

Research context before designing

design-policy-review

Mid-process policy compliance check

vuetify-constraint-check

Vuetify 3 component coverage

design-qa

Final gate check before handoff

design-handoff

Complete engineering handoff doc

figma-to-code

Figma → Vue + Vuetify 3 code

microcopy-writer

UI copy following product voice

implementation-review

Figma vs. code gap analysis

+1 open slot

Design system documentation

Shared Skills — 6 (available to both PM and Designer)

design-system-check

Inventory existing UI components

wireframe-generator

Interactive HTML wireframe

task-writer

Linear task with four-part structure

meeting-support

Agenda prep and action items

presentation-style

HTML slide deck generation

prompt-optimizer

Analyze and rewrite prompts

Setup in 3 steps

Install takes under 5 minutes. The interview or Figma scan generates all context files automatically.

1

Install the package

Run npm install -g claude-pm then cd your-product-repo && claude-pm init --role pm (or --role designer). Installs skills globally and scaffolds the project.

2

Run the interview

Open Claude Code in your product repo and run /start-interview (PM) or /start-designer-interview (Designer). Answer questions (PM) or provide Figma links (Designer). Claude generates all context files.

3

Start using skills

Every skill is now available as a slash command. Run /new-feature [describe it] for a PM-led feature flow, or /design-review for a designer-led review. Claude reads your product context automatically.

Update the policy layer: Run claude-pm update to pull the latest skills and commands. Your context files (CLAUDE.md, context.md files) are never overwritten.

Add personal context: Edit CLAUDE.local.md for private notes. It loads alongside CLAUDE.md on every session and is gitignored.

Product Team · Claude Code Skills
claude-pm package · MIT License · 2026
Product Manager Guide Product Designer Guide Workflow Deck Figma → Vue