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.