Product Manager Skill

Purpose

Orchestrate product discovery by dispatching the product-manager subagent to conduct interviews, gather requirements, and produce structured outputs.

Key Output: Creates a spec group with requirements.md that feeds into /spec .

Usage

/pm # Start new discovery interview, create spec group /pm <spec-group-id> # Add requirements to existing spec group /pm feedback <spec-group-id> # Gather feedback on implementation /pm refine <spec-group-id> # Refine existing requirements based on new info

When to Use This Skill

• Initial discovery: Starting a new task that needs a spec (creates spec group)

• Clarification: User request is vague or has multiple interpretations

• Refinement: Spec group exists but has open questions or ambiguities

• Feedback collection: Implementation complete, gathering user reactions

• Iteration planning: Deciding what to build next or how to improve existing features

Process

1. Parse Invocation

Determine the mode from the command:

Command Mode Context

/pm

discovery

New spec group will be created

/pm sg-logout

discovery

Add to existing spec group

/pm feedback sg-logout

feedback

Gather feedback on implementation

/pm refine sg-logout

refine

Refine existing requirements

2. Load Context (if spec group exists)

For modes that reference an existing spec group:

Read: .claude/specs/groups/<spec-group-id>/manifest.json Read: .claude/specs/groups/<spec-group-id>/requirements.md (if exists)

3. Dispatch Product Manager Subagent

Dispatch the product-manager subagent with appropriate context:

Discovery Mode (new)

Task: product-manager Prompt: | <context> Mode: discovery User request: <original user request> </context>

Conduct a discovery interview to gather requirements for a new feature.

Interview the user to understand:

• Problem being solved
• Goals and success criteria
• Constraints and boundaries
• Edge cases and failure modes
• Priorities (must-have vs nice-to-have)

After interviewing, create a spec group directory and requirements.md:

• Directory: .claude/specs/groups/sg-<feature-slug>/
• Create manifest.json with review_state: DRAFT
• Create requirements.md with all gathered requirements in EARS format

Confirm understanding with user before finalizing.

Discovery Mode (existing spec group)

Task: product-manager Prompt: | <context> Mode: discovery Spec group: <spec-group-id> Existing manifest: <manifest contents> Existing requirements: <requirements.md contents if exists> User request: <original user request> </context>

Add requirements to existing spec group.

Interview the user to understand additional requirements. Update requirements.md with new requirements. Maintain existing requirements unless explicitly superseded.

Confirm understanding with user before finalizing.

Feedback Mode

Task: product-manager Prompt: | <context> Mode: feedback Spec group: <spec-group-id> Existing requirements: <requirements.md contents> Implementation status: <from manifest> </context>

Gather feedback on the implementation.

Interview the user to understand:

• What's working well
• What needs improvement
• What's missing
• What should be built next

Produce an iteration plan documenting:

• Feedback summary
• Proposed changes
• Next steps

Update requirements.md with feedback notes.

Refine Mode

Task: product-manager Prompt: | <context> Mode: refine Spec group: <spec-group-id> Existing requirements: <requirements.md contents> Open questions: <extracted from requirements.md> </context>

Refine existing requirements based on new information.

Interview the user to:

• Resolve open questions
• Clarify ambiguities
• Update priorities if needed

Update requirements.md with refined requirements. Mark resolved questions as resolved with answers.

4. Synthesize Results

After subagent completes, report the outcome:

Discovery Complete

Requirements Gathered ✅

Spec group created: sg-<feature-slug> Location: .claude/specs/groups/sg-<feature-slug>/

Files created:

• manifest.json — Spec group metadata (review_state: DRAFT)
• requirements.md — <N> requirements in EARS format

Next Steps:

1. Review requirements: cat .claude/specs/groups/sg-<feature-slug>/requirements.md
2. (Optional) Run /prd draft sg-<feature-slug> to write PRD to git repository
3. Run /spec sg-<feature-slug> to create spec.md
4. User approves → implementation begins

Note: For orchestrator workflows with multiple workstreams, also run /atomize and /enforce after /spec to decompose into atomic specs.

Feedback Complete

Feedback Gathered ✅

Spec group: <spec-group-id>

Feedback Summary:

• Working well: <count> items
• Needs improvement: <count> items
• Missing: <count> items

Iteration plan added to requirements.md

Next Steps:

1. Review iteration plan
2. Run /spec <spec-group-id> to update spec with changes
3. Re-implement changed requirements

Refine Complete

Requirements Refined ✅

Spec group: <spec-group-id>

Resolved:

• <count> open questions resolved
• <count> requirements clarified

Next Steps:

1. Review updated requirements.md
2. Continue with /spec

State Transitions

After /pm completes:

Mode review_state work_state updated_by

discovery (new) DRAFT PLAN_READY agent

discovery (existing) DRAFT PLAN_READY agent

feedback DRAFT PLAN_READY agent

refine DRAFT PLAN_READY agent

Integration with Workflow

In oneoff-spec Workflow

/route → /pm → requirements.md ↓ /spec → spec.md ↓ User approves ↓ /implement + /test

In orchestrator Workflow

/route → /pm → requirements.md ↓ /spec → spec.md ↓ /atomize → atomic/*.md ↓ /enforce → validation ↓ User approves ↓ /implement + /test

Linking to External PRD

After /pm , if requirements should link to a PRD in the git repository:

/prd link sg-<feature-slug> <prd-path>

Error Handling

Spec Group Not Found

Error: Spec group 'sg-unknown' not found

Available spec groups:

• sg-logout-button
• sg-auth-system

To create a new spec group, run: /pm

Invalid Mode

Error: Invalid mode 'invalid'

Valid modes:

• /pm (new discovery)
• /pm <spec-group-id> (add to existing)
• /pm feedback <sg-id> (gather feedback)
• /pm refine <sg-id> (refine requirements)

Examples

Example 1: New Discovery

User: /pm

→ Dispatch product-manager (discovery mode) → Subagent interviews user about the problem → Subagent creates sg-logout-button/ with manifest.json and requirements.md → Report: Requirements Gathered ✅

Example 2: Add to Existing

User: /pm sg-auth-system

→ Load existing manifest and requirements → Dispatch product-manager (discovery mode with context) → Subagent interviews for additional requirements → Subagent updates requirements.md → Report: Requirements Updated ✅

Example 3: Feedback Collection

User: /pm feedback sg-logout-button

→ Load existing manifest and requirements → Dispatch product-manager (feedback mode) → Subagent interviews about implementation → Subagent produces iteration plan → Report: Feedback Gathered ✅

Example 4: Refine Requirements

User: /pm refine sg-auth-system

→ Load existing requirements and open questions → Dispatch product-manager (refine mode) → Subagent interviews to resolve questions → Subagent updates requirements.md → Report: Requirements Refined ✅