kiro-discovery

Determine action paths for work requests and decompose them into specs, updates, or implementation.

1.5k|242|Updated Feb 16, 2017
One-click install
npx skills add https://github.com/growilabs/growi --skill kiro-discovery-growilabs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: kiro-discovery
Source: https://github.com/growilabs/growi/tree/main/.claude/skills/kiro-discovery
Command: npx skills add https://github.com/growilabs/growi --skill kiro-discovery-growilabs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Many project requests arrive without clear boundaries, existing-spec mapping, or a clear next action, which leads to wasted time, duplicated effort, and unclear ownership. This Skill provides a lightweight, structured discovery that identifies whether work requires a new spec, an update to an existing spec, or direct implementation, and produces an actionable next step.

Core Features & Use Cases

  • Metadata-first discovery: Quickly inventories specs, steering files, and top-level repo structure without loading heavy file contents to determine the correct action path.
  • Structured clarification: Guides sequential, targeted questions to elicit stakeholder intent, constraints, and boundaries needed to form clean spec candidates.
  • Spec & roadmap outputs: For new or multi-scope work, produces brief.md and roadmap.md artifacts and recommends the exact next CLI-like command for continuing the process.
  • Use case: Intake for product or engineering teams receiving a feature request, bug report, or vague enhancement that needs scoping and spec decisioning.

Quick Start

Perform a lightweight discovery for the request 'add user profile export' and recommend whether to update an existing spec, create a new spec, or implement directly and state the preferred next command.

Frequently Asked Questions about kiro-discovery

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I scope a vague feature request to decide between updating an existing spec or direct implementation?

Scoping a vague feature request involves performing a lightweight metadata scan of existing specs and repository structure to determine the correct action path. This guides sequential clarification questions to elicit stakeholder intent and boundaries, recommending whether to create a new spec, update one, or implement directly.

What is the best way to handle early project intake and discovery for software changes?

Early project intake and discovery requires evaluating existing spec coverage, steering documents, and repository metadata. A structured discovery process proposes 2-3 approaches with trade-offs and produces actionable artifacts like brief.md or roadmap.md to define boundaries and next steps.

How do I decompose a product change request into actionable next steps?

Decomposing a product change request requires targeted clarification questions to map work boundaries. The process inventories existing specs and steering files, then generates a brief.md or roadmap.md artifact while recommending the exact next CLI-like command for continuing the workflow.

When do I need to create a new spec versus directly implementing a bug report?

You need a new spec when a lightweight metadata scan reveals no existing spec coverage for the requested changes. Direct implementation is recommended when existing steering documents and repository metadata already provide clear boundaries and ownership for the bug report.

Can I use this structured discovery process for multi-scope enhancement requests?

Structured discovery handles multi-scope enhancement requests by proposing 2-3 approaches with defined trade-offs. It produces roadmap.md artifacts to capture the multiple scopes and recommends the exact next CLI-like command for continuing the decomposition process.

What are the limitations of using lightweight metadata scans for requirements discovery?

Lightweight metadata scans for requirements discovery intentionally avoid loading heavy file contents to quickly inventory specs and repo structure. The limitation is that deep contextual logic within existing files is not evaluated, meaning highly complex or deeply nested code changes may require further manual investigation beyond the initial scan.