SkillAgentSearch skills...

gen-specs-as-issues

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

Install / Use

npx skills add github/awesome-copilot --skill gen-specs-as-issues

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

88/100

Category

Automation

Supported Platforms

Universal

Our assessment of gen-specs-as-issues

gen-specs-as-issues scores 88/100 on our quality scale, 1482nd of 2,790 Automation skills we index.

Its SKILL.md is 5.7 KB long, well organised into 17 sections and no code examples: a solid amount of guidance for an agent.

With 39,348 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
26/30
Structure
13/20
Description
15/15
Adoption
20/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so gen-specs-as-issues is actively maintained.
  • Our last check on 2026-10-31 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-09-26. Automated pattern scan on 2026-09-25. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

gen-specs-as-issues compared with similar skills

All 4 of these similar skills score higher than gen-specs-as-issues; compare them before choosing.

SkillScoreStarsUpdatedFormat
gen-specs-as-issues (this skill)by github8839.3k53d agoSKILL.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md
Scraplingby D4Vinci100103.6k2d agoMCP Server

Frequently asked questions

How do I install gen-specs-as-issues?
Run npx skills add github/awesome-copilot --skill gen-specs-as-issues. The install tabs above show the steps for each supported agent.
Which AI agents does gen-specs-as-issues work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is gen-specs-as-issues safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is gen-specs-as-issues still maintained?
The repository was last updated about 2 months ago, so gen-specs-as-issues is actively maintained.

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

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.

Related Skills

View on GitHub
GitHub Stars39.3k
CategoryAutomation
Updated1mo ago
Forks5.0k

Languages

JavaScript

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions