Initial setup of repo with prompts and instructions

prompts/gen-specs-as-issues.prompt.md

@@ -0,0 +1,160 @@
+# 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.