Gen Specs As Issues

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:

1. Overview & Scope

   • What problem does it solve?

   • What's included and what's explicitly excluded?

2. Technical Requirements

   • Core functionality needed

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

   • Integration points with existing code

3. Implementation Plan

   • Key modules/files to create or modify

   • Simple code examples showing the approach

   • Clear data structures and interfaces

4. 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.