speckit-clarify

Scan feature specs for gaps and generate prioritized clarification questions.

4|Updated May 16, 2025
One-click install
npx skills add https://github.com/AustinZ21/EggHatch-AI --skill speckit-clarify-austinz21
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: speckit-clarify
Source: https://github.com/AustinZ21/EggHatch-AI/tree/main/.agents/skills/speckit-clarify
Command: npx skills add https://github.com/AustinZ21/EggHatch-AI --skill speckit-clarify-austinz21

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Feature specifications with ambiguous or missing decision points lead to misaligned implementation, unnecessary rework, and unclear acceptance criteria. This Skill eliminates that risk by systematically identifying gaps in your active feature spec before planning begins.

Core Features & Use Cases

  • Ambiguity Scanning: Automatically scans feature specs across 12 taxonomy categories (functional scope, data model, UX, non-functional requirements, edge cases, etc.) to flag partial or missing coverage.
  • Targeted Clarification Generation: Produces up to 5 high-impact, prioritized questions (multiple choice or short answer) that materially impact architecture, implementation, or validation.
  • Automated Spec Integration: Accepts user answers and automatically updates the spec file with clarifications, plus re-validates associated quality checklists to reflect new information.
  • Use Case: A product team building a new payment processing feature can use this Skill to identify missing security and compliance requirements before starting development, reducing downstream rework.

Quick Start

Invoke the speckit-clarify skill to identify and resolve critical ambiguities in your current active feature specification prior to starting the planning phase.

Frequently Asked Questions about speckit-clarify

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

FAQPage Schema
How do I resolve ambiguity and missing decision points in feature specifications?

To resolve feature specification ambiguity, you can systematically scan spec files across functional scope, data model, UX, and edge case categories to identify coverage gaps. Generating prioritized clarification questions prevents misaligned implementation and downstream rework before development begins.

How do I validate acceptance criteria for missing edge cases before planning?

Validating acceptance criteria involves scanning feature specs across taxonomy categories like non-functional requirements and edge cases to flag partial coverage. This requirement validation process ensures spec completeness by identifying missing decision points prior to the planning phase.

Does spec-kit structured feature development work with automated spec clarification?

Spec-kit structured feature development workflows support automated spec clarification by scanning active spec files for ambiguities. The process integrates accepted clarification answers directly back into spec files and updates associated quality checklists to reflect new information.

What is the best way to generate high-impact clarification questions for feature specs?

The best way to generate high-impact clarification questions is to scan feature specifications for missing decision points and produce prioritized multiple choice or short answer queries. Targeting questions that materially impact architecture ensures clarifications prevent unnecessary rework.

How do I update quality checklists after resolving feature spec ambiguities?

Updating quality checklists after resolving feature spec ambiguities involves integrating user answers back into the spec file and automatically re-validating associated checklists. This ensures spec completeness and reflects newly clarified requirements prior to starting implementation.

When should I scan feature specs for ambiguity to prevent misaligned implementation?

You should scan feature specs for ambiguity and missing decision points prior to starting the planning phase. Identifying coverage gaps in functional scope, data model, and non-functional requirements early prevents misaligned implementation and downstream rework during development.