gen-specs-as-issues
This workflow guides you through a systematic approach to identify missing features, prioritize them, and create detailed specifications for implementation.
- License 许可
- MIT
- 最近更新
- 2026-08-19
- Stars
- ★ 2
- Forks
- 0
01 前言 Front Matter
- name
- gen-specs-as-issues
- description
- This workflow guides you through a systematic approach to identify missing features, prioritize them, and create detailed specifications for implementation.
03 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.
04 同仓库更多 Skills
youtube-transcript
Extract transcripts from YouTube videos. Use when the user asks for a transcript, subtitles, or captions of a YouTube video and provides a YouTube URL (youtube.com/watch?v=, youtu.be/, or similar). Supports output with or without timestamps.
youtube-thumbnail-design
YouTube thumbnail design with specific dimensions, contrast rules, and mobile preview optimization. Covers safe zones, text placement, face expression psychology, and A/B testing. Use for: YouTube thumbnails, video cover images, click-through optimization. Triggers: youtube thumbnail, thumbnail design, video thumbnail, click through rate, ctr optimization, youtube cover, video cover image, thumbnail maker, thumbnail tips, youtube design, video preview image
youtube-short-maker
Make YouTube Shorts that hold attention with Pexo — vertical 9:16, fast-paced, hook in the first 3 seconds. Describe your topic and Pexo writes the script, generates the shots, picks the models, and assembles a finished Short with music and captions. Use for YouTube Shorts: "youtube short", "make a youtube short", "shorts video", "short-form video". NOT for long-form or landscape video.
xcode-project-setup
Safely modifies Xcode projects (.pbxproj) to add Swift Packages and link files. Use this skill whenever an iOS project needs dependencies installed (e.g. Firebase, Alamofire).
x402
Set up Browser Use Cloud payments with x402 — pay per request from a crypto wallet (USDC on Base mainnet), no signup or API key. Two setups it works out up front — "just use it" (set up a wallet so you or Claude Code can run cloud browser tasks paid from the wallet — Claude writes and runs throwaway scripts, nothing touches your codebase) or "build it in" (install the SDK and write the key + code into your project). Walks through wallet setup, funding, .env, and a ~$1 test run. Use when the user asks about x402, pay-per-use, USDC payments, or wants Browser Use Cloud without an API key. For the free-tier signup (reverse-CAPTCHA → API key), use `browser-use cloud signup` or the `cloud` skill instead.
x-twitter-scraper
Build GitHub Copilot workflows with Xquik X API SDKs, REST endpoints, hosted Apify Actor runs, MCP tools, TweetClaw OpenClaw plugin installs, signed webhooks, tweet search, user lookup, follower exports, media actions, and agent automation.