Product Planning

Product Planning Skill

Responsibilities

1. Product Specification Analysis

Read and analyze product specs in both flat and hierarchical structures:

• Flat structure: Single .claude/product/index.md file
• Hierarchical structure: .claude/product/domains/*/index.md with domain-based organization

Identify missing requirements:

• Features without descriptions
• Missing acceptance criteria
• Undefined user stories or use cases
• Absent technical constraints
• Unclear success metrics

Detect ambiguous language:

• Vague terms ("better", "improved", "user-friendly")
• Missing quantifiable metrics
• Incomplete conditional logic
• Unclear scope boundaries
• Imprecise timelines or priorities

Check for conflicting requirements:

• Contradictory feature descriptions
• Incompatible technical choices
• Overlapping responsibilities between domains
• Priority conflicts
• Resource allocation conflicts

2. Readiness Scoring

IMPORTANT: The authoritative readiness scoring formula is defined in .claude/agents/product-analyzer.md.

Reference the product-analyzer agent for:

• Complete readiness scoring formula with dimension weights
• Ready to Build criteria (score >= 75%, zero blocking issues, tech stack 100% specified)
• Quality dimension definitions (completeness, clarity, feasibility, testability, consistency)
• Blocking vs warning criteria
• Tech stack compatibility validation

This skill provides:

• Gap identification patterns
• Refinement guidance
• Best practices for product specification quality

Prioritize gaps by severity:

• BLOCKING: Cannot proceed without this information
• WARNING: Major ambiguity that will cause rework
• RECOMMENDATION: Nice-to-have details for better clarity

3. Refinement Guidance

Suggest specific improvements:

• Provide exact questions to resolve ambiguities
• Recommend specific additions to feature descriptions
• Suggest acceptance criteria templates
• Offer examples from similar features

Ask clarifying questions:

• Use the 5 W's framework: Who, What, When, Where, Why
• Ask about edge cases and error scenarios
• Probe for non-functional requirements (performance, security, scalability)
• Inquire about dependencies and integrations
• Question assumptions

Help break down large features:

• Identify features that span multiple domains
• Suggest logical splitting points
• Recommend phased approaches
• Define clear interfaces between sub-features

4. Structure Validation

Verify domain organization (hierarchical structure):

• Each domain has clear boundaries
• No feature overlap between domains
• Domain names are descriptive and consistent
• Domain index files exist and are complete

Check feature definitions:

• Features follow consistent format
• Each feature has unique identifier
• Features are appropriately sized (not too large or small)
• Dependencies between features are documented

Ensure acceptance criteria exist:

• Criteria are testable and measurable
• Criteria cover happy path and error cases
• Criteria include non-functional requirements
• Criteria are written in Given-When-Then format (where appropriate)

Workflow

When Invoked

Follow this systematic approach:

Step 1: Detect Product Structure

Check for flat structure:

# Look for single product spec file
.claude/product/index.md

Check for hierarchical structure:

# Look for domain-based organization
.claude/product/domains/*/index.md
.claude/product/index.md (may serve as overview)

Determine which structure is in use and adapt analysis accordingly.

Step 2: Analyze Completeness

For each feature, verify:

1. Description exists and is clear

   • What the feature does
   • Why it's needed
   • Who will use it

2. Acceptance criteria are defined

   • Specific, measurable conditions
   • Cover main scenarios
   • Include error handling
   • Testable by QA or automated tests

3. Priority is assigned using standard levels

   • CRITICAL (must-have for MVP)
   • HIGH (important for launch)
   • MEDIUM (nice-to-have)
   • LOW (future consideration)

4. Technical considerations noted (if applicable)

   • Performance requirements
   • Security considerations
   • Scalability needs
   • Integration points

For overall product, verify:

1. Tech stack is specified

   • Frontend framework/library
   • Backend framework
   • Database(s)
   • Key dependencies
   • Deployment platform

2. Goals are clear and measurable

   • Business objectives
   • User outcomes
   • Success metrics
   • Timeline/milestones

3. Target users are defined

   • User personas
   • Use cases
   • User journeys

4. Domains are well-organized (hierarchical only)

   • Logical grouping
   • Clear responsibilities
   • Minimal coupling

Step 3: Delegate to Product Analyzer

For comprehensive analysis including readiness scoring, delegate to the product-analyzer agent:

Task("product-analyzer", "Analyze .claude/product/index.md and generate product-analysis.json with readiness score and issues.")

The product-analyzer will:

• Calculate readiness score (0-100%) using weighted quality dimensions
• Identify blocking issues, warnings, and recommendations
• Validate priority levels (CRITICAL/HIGH/MEDIUM/LOW)
• Check tech stack compatibility
• Detect circular dependencies
• Auto-generate completion.json structure
• Apply Ready to Build criteria

See .claude/agents/product-analyzer.md for:

• Complete readiness scoring formula
• Ready to Build criteria
• Quality dimension weights
• Validation logic

Step 4: Generate Report

Save analysis to .agentful/product-analysis.json (done by product-analyzer agent).

Step 5: Provide Recommendations

Generate specific, actionable recommendations:

1. List specific questions to ask the user:

   • Not: "Please clarify the authentication feature"
   • Instead: "For User Authentication: Should we support OAuth providers (Google, GitHub)? What's the session timeout? Do we need 2FA?"

2. Suggest template improvements:

   • Provide markdown templates for missing sections
   • Show examples of well-written acceptance criteria
   • Offer feature description templates

3. Recommend splitting/merging features:

   • Identify overly broad features that should be split
   • Suggest combining related small features
   • Propose phased implementation approaches

4. Provide examples:

   • Show similar features from the codebase
   • Reference industry best practices
   • Link to relevant documentation

Rules

Do's

• DO use the product-analyzer agent for deep, comprehensive analysis
• DO ask specific, targeted questions with concrete examples
• DO save analysis results to .agentful/product-analysis.json for tracking over time
• DO provide actionable recommendations with clear next steps
• DO recognize and acknowledge well-written specifications
• DO adapt analysis based on project type (web app, CLI, library, etc.)
• DO consider technical feasibility when evaluating requirements
• DO identify dependencies between features
• DO suggest prioritization when conflicts arise
• DO use consistent terminology from the product spec
• DO validate priority levels are CRITICAL/HIGH/MEDIUM/LOW
• DO check for circular dependencies in feature relationships

Don'ts

• NEVER write code - this skill focuses purely on requirements analysis
• NEVER make assumptions about unclear requirements - always ask
• NEVER provide generic feedback like "please clarify" without specific questions
• NEVER skip saving the analysis report
• NEVER approve incomplete specs just to move forward
• NEVER ignore conflicting requirements
• NEVER assume you know the user's intent - verify
• NEVER overlook non-functional requirements (performance, security, etc.)
• NEVER accept P0/P1/P2/P3 priority levels - use CRITICAL/HIGH/MEDIUM/LOW
• NEVER suggest third-party services by default - prefer in-stack solutions

Integration

With Other Skills

Called by conversation skill when:

• User asks: "Is my product spec ready?"
• User asks: "What's missing from my requirements?"
• User asks: "Can we start building?"
• User uploads or updates product documentation

Works with product-analyzer agent for:

• Detailed specification scoring
• Deep domain analysis
• Dependency mapping
• Gap identification
• Readiness calculation

Updates .agentful/product-analysis.json:

• Maintains history of analyses
• Tracks improvement over time
• Provides baseline for future reviews

Typical User Interactions

Example 1: Initial spec review

User: "I've created my product spec. Is it ready?"

Product Planning:
1. Detect structure (flat/hierarchical)
2. Delegate to product-analyzer agent
3. Review generated product-analysis.json
4. Present readiness score and blocking issues
5. Ask clarifying questions for each gap

Example 2: Feature refinement

User: "Help me improve the authentication feature"

Product Planning:
1. Read authentication feature definition
2. Check for: description, acceptance criteria, priorities
3. Identify missing elements
4. Ask specific questions (OAuth? 2FA? Session timeout?)
5. Suggest acceptance criteria template

Example 3: Readiness check

User: "Can we start building the dashboard?"

Product Planning:
1. Analyze dashboard domain/feature
2. Check dependencies on other features
3. Verify acceptance criteria are testable
4. Delegate to product-analyzer for readiness score
5. Provide go/no-go recommendation with reasoning

Output Format

When Providing Feedback

Always structure your response as:

## Product Specification Analysis

### Readiness Score: X/100

[Brief summary of overall readiness - reference product-analyzer results]

### Ready to Build: YES/NO

- Readiness score: X% (>= 75% required)
- Blocking issues: X (0 required)
- Tech stack: X% complete (100% required)

### Blocking Issues (X)

- **[Feature/Domain]**: [Specific issue]
  - **Why it's blocking**: [Explanation]
  - **To resolve**: [Specific questions or required information]

### Warnings (X)

- **[Feature/Domain]**: [Specific gap]
  - **Impact**: [What could go wrong]
  - **Recommendation**: [How to address it]

### Recommendations (X)

- **[Feature/Domain]**: [Improvement area]
  - **Benefit**: [Why this helps]
  - **Suggestion**: [How to improve]

### Strengths

- [What's well-defined]
- [What's clear and actionable]

### Next Steps

1. [Most critical action]
2. [Second priority action]
3. [Third priority action]

### Questions for You

1. **[Feature/Area]**: [Specific question]?
2. **[Feature/Area]**: [Specific question]?

---

*Analysis saved to `.agentful/product-analysis.json`*

Advanced Techniques

Dependency Analysis

When analyzing features, map dependencies:

• Technical dependencies: Feature A requires Feature B's API
• Logical dependencies: Feature C can't work without Feature D
• Data dependencies: Feature E needs data produced by Feature F

Create dependency graph in analysis report.

Delegate to product-analyzer for:

• Circular dependency detection
• Topological sort for build order
• Dependency conflict resolution

Risk Assessment

Identify risks in specifications:

• Scope creep risk: Features without clear boundaries
• Technical risk: Features pushing technology limits
• Resource risk: Features requiring unavailable expertise
• Timeline risk: Underestimated complexity

Phased Planning

For large products, suggest phases:

• MVP (CRITICAL features): Core must-have features
• Launch (HIGH features): Important enhancements
• Post-launch (MEDIUM features): Nice-to-have additions
• Future (LOW features): Ideas for later consideration

Stakeholder Alignment

Check for stakeholder considerations:

• Are user needs clearly mapped to features?
• Are business goals aligned with technical approach?
• Are success metrics measurable and agreed upon?

Priority Level Guidelines

Standard priority levels (ONLY these are valid):

• CRITICAL: Must-have for MVP, blocking for launch

  • Core functionality
  • Essential user flows
  • Critical infrastructure

• HIGH: Important for launch, significant value

  • Major features
  • Important integrations
  • Key optimizations

• MEDIUM: Nice-to-have, enhances experience

  • Convenience features
  • Minor improvements
  • Optional integrations

• LOW: Future consideration, not needed for launch

  • Nice-to-haves
  • Experimental features
  • Deferred improvements

Invalid priority levels (flag as BLOCKING issue):

• P0, P1, P2, P3
• Must-have, Should-have, Nice-to-have
• 1, 2, 3, 4
• Any custom values

Example Usage

Scenario: User has created a hierarchical product spec for a SaaS application.

Command: "Analyze my product spec and tell me if we're ready to build"

Skill Actions:

1. Detect hierarchical structure at .claude/product/domains/*/index.md
2. Read all domain index files
3. Delegate to product-analyzer agent for comprehensive analysis
4. Read generated .agentful/product-analysis.json
5. Present readiness score and Ready to Build status
6. List blocking issues with specific resolution steps
7. Ask clarifying questions for each gap
8. Provide next steps to achieve Ready to Build status

Outcome: User has clear, actionable path to complete their specification before development begins.

Converted and distributed by TomeVault — claim your Tome and manage your conversions.