Spec Dev

Develop testable software specifications using EARS notation, Mermaid diagrams, and Socratic dialogue.

1|Updated Apr 25, 2026
One-click install
npx skills add https://github.com/htxryan/claude-code-config-profiles --skill spec-dev-htxryan
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: Spec Dev
Source: https://github.com/htxryan/claude-code-config-profiles/tree/main/.agents/skills/compound/spec-dev
Command: npx skills add https://github.com/htxryan/claude-code-config-profiles --skill spec-dev-htxryan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Writing software requirements in plain natural language produces ambiguity, untestable statements, and missed edge cases that surface only during implementation. This Skill provides a structured 4-phase methodology (Explore, Understand, Specify, Hand off) that turns vague feature ideas into formal, testable specifications before any code is written. ## Core Features & Use Cases - EARS Requirements: Writes requirements in Easy Approach to Requirements Syntax (ubiquitous, event-driven, state-driven, unwanted-behavior, optional patterns) so every statement is testable and unambiguous. - Diagram-Driven Thinking: Uses Mermaid mindmaps, sequence diagrams, state diagrams, ER diagrams, and C4 context diagrams to expose hidden assumptions and domain structure. - Scenario Table Generation: Derives happy, error, boundary, combinatorial, and adversarial (STRIDE-based) test scenarios directly from requirements and diagrams. - Ambiguity Detection: Applies a 9-type natural-language ambiguity checklist with red-flag word detection to catch vague requirements early. - Use Case: Before building a new file-upload feature, run the full spec process to produce EARS requirements, a state diagram of the upload lifecycle, a scenario table covering boundary and adversarial cases, and a beads epic ready for the planning phase. ## Quick Start Ask the AI to develop a formal specification for your feature using EARS notation and Mermaid diagrams, scaling formality to the risk of the task.

Frequently Asked Questions about Spec Dev

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

FAQPage Schema
How do I write testable software requirements with EARS notation?▼

EARS notation structures requirements into five patterns: ubiquitous, event-driven (When), state-driven (While), unwanted-behavior (If/then), and optional (Where). Each requirement names an explicit trigger, condition, and system response, making it directly verifiable.

What is the process for developing a software specification before coding?▼

Follow four phases: Explore the problem domain with mindmaps and research, Understand requirements through Socratic dialogue and diagrams, Specify with EARS notation and scenario tables, then Hand off by storing the spec in a beads epic for planning.

Which Mermaid diagram should I use for requirements analysis?▼

Use mindmaps for domain exploration, sequence diagrams for workflows and API interactions, state diagrams for entity lifecycles, ER diagrams for data models, C4 context diagrams for system boundaries, and flowcharts for branching decision logic.

How do I detect ambiguity in natural language requirements?▼

Scan for nine ambiguity types including vague adjectives without thresholds, unclear pronouns, passive voice, and compound requirements. Red-flag words like 'etc.', 'appropriate', 'efficient', and 'handle' almost always signal ambiguity needing quantification.

When should I skip formal specification for a task?▼

Skip the process entirely for trivial tasks under one hour of work. Use a lightweight version with just EARS requirements and an epic for small tasks, and reserve the full 4-phase process for medium or larger efforts.

How do I generate test scenarios from requirements?▼

Derive at least one happy and one error scenario per EARS requirement, boundary scenarios for quantified parameters, adversarial scenarios per applicable STRIDE category for external interfaces, and pairwise combinatorial scenarios for multi-parameter requirements.