gen-specs-as-issues

SKILL.md

Product Manager Assistant: Feature Identification and Specification

This workflow guides you through a systematic approach to identify missing features, prioritize them, and create detailed specifications for implementation.

1. Project Understanding Phase

Review the project structure to understand its organization

Read the README.md and other documentation files to understand the project's core functionality

Identify the existing implementation status by examining:

Main entry points (CLI, API, UI, etc.)

Core modules and their functionality

Tests to understand expected behavior

Any placeholder implementations

Guiding Questions:

What is the primary purpose of this project?

What user problems does it solve?

What patterns exist in the current implementation?

Which features are mentioned in documentation but not fully implemented?

2. Gap Analysis Phase

Compare the documented capabilities ONLY against the actual implementation

Identify "placeholder" code that lacks real functionality

Look for features mentioned in documentation but missing robust implementation

Consider the user journey and identify broken or missing steps

Focus on core functionality first (not nice-to-have features)

Output Creation:

Create a list of potential missing features (5-7 items)

For each feature, note:

Current implementation status

References in documentation

Impact on user experience if missing

3. Prioritization Phase

Apply a score to each identified gap:

Scoring Matrix (1-5 scale):

User Impact: How many users benefit?

Strategic Alignment: Fits core mission?

Implementation Feasibility: Technical complexity?

Resource Requirements: Development effort needed?

Risk Level: Potential negative impacts?

Priority = (User Impact × Strategic Alignment) / (Implementation Effort × Risk Level)

Output Creation:

Present the top 3 highest-priority missing features based on the scoring

For each, provide:

Feature name

Current status

Impact if not implemented

Dependencies on other features

4. Specification Development Phase

For each prioritized feature, develop a detailed but practical specification:

Begin with the philosophical approach: simplicity over complexity

Focus on MVP functionality first

Consider the developer experience

Keep the specification implementation-friendly

For Each Feature Specification:

Overview & Scope

What problem does it solve?

What's included and what's explicitly excluded?

Technical Requirements

Core functionality needed

User-facing interfaces (API, UI, CLI, etc.)

Integration points with existing code

Implementation Plan

Key modules/files to create or modify

Simple code examples showing the approach

Clear data structures and interfaces

Acceptance Criteria

How will we know when it's done?

What specific functionality must work?

What tests should pass?

5. GitHub Issue Creation Phase

For each specification, create a GitHub issue:

Clear, descriptive title

Comprehensive specification in the body

Appropriate labels (enhancement, high-priority, etc.)

Explicitly mention MVP philosophy where relevant

Issue Template Structure:

[Feature Name]

Overview

[Brief description of the feature and its purpose]

Scope

[What's included and what's explicitly excluded]

Technical Requirements

[Specific technical needs and constraints]

Implementation Plan

[Step-by-step approach with simple code examples]

Acceptance Criteria

[Clear list of requirements to consider the feature complete]

Priority

[Justification for prioritization]

Dependencies

Blocks: [List of issues blocked by this one]

Blocked by: [List of issues this one depends on]

Implementation Size

Estimated effort: [Small/Medium/Large]

Sub-issues: [Links to sub-issues if this is a parent issue]

5.5 Work Distribution Optimization

Independence Analysis

Review each specification to identify truly independent components

Refactor specifications to maximize independent work streams

Create clear boundaries between interdependent components

Dependency Mapping

For features with unavoidable dependencies, establish clear issue hierarchies

Create parent issues for the overall feature with sub-issues for components

Explicitly document "blocked by" and "blocks" relationships

Workload Balancing

Break down large specifications into smaller, manageable sub-issues

Ensure each sub-issue represents 1-3 days of development work

Include sub-issue specific acceptance criteria

Implementation Guidelines:

Use GitHub issue linking syntax to create explicit relationships

Add labels to indicate dependency status (e.g., "blocked", "prerequisite")

Include estimated complexity/effort for each issue to aid sprint planning

6. Final Review Phase

Summarize all created specifications

Highlight implementation dependencies between features

Suggest a logical implementation order

Note any potential challenges or considerations

Remember throughout this process:

Favor simplicity over complexity

Start with minimal viable implementations that work

Focus on developer experience

Build a foundation that can be extended later

Consider the open-source community and contribution model

This workflow embodiment of our approach should help maintain consistency in how features are specified and prioritized, ensuring that software projects evolve in a thoughtful, user-centered way.
28