sdd-principles

Enforce Specification-Driven Development principles with phase gates and uncertainty markers.

Updated Jan 24, 2026
One-click install
npx skills add https://github.com/umatoma/claude-example --skill sdd-principles
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sdd-principles
Source: https://github.com/umatoma/claude-example/tree/main/.claude/skills/sdd-principles
Command: npx skills add https://github.com/umatoma/claude-example --skill sdd-principles

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a structured methodology (Specification-Driven Development - SDD) to ensure that software development is initiated and guided by clear, unambiguous specifications, minimizing guesswork and rework.

Core Features & Use Cases

  • Defines SDD Principles: Outlines core concepts like "Specification = Single Source of Truth" and "Executable Specifications".
  • Project Constitution: Enforces a set of immutable principles for development (e.g., Module First, Contract First, Test First).
  • Phase Gate Definitions: Clearly defines the criteria for moving between development phases (Specify -> Plan, Plan -> Implement).
  • Uncertainty Markers: Standardizes how to flag and manage ambiguities in specifications using [NEEDS CLARIFICATION].
  • Use Case: Before starting a new feature, use this Skill to ensure all requirements are documented, ambiguities are flagged, and the team agrees on the "Project Constitution" and phase gate criteria, leading to a more predictable development cycle.

Quick Start

Review the SDD principles and phase gate definitions to understand the Specification-Driven Development process.

Frequently Asked Questions about sdd-principles

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

FAQPage Schema
What are specification-driven development principles and why use them for software engineering?

Specification-driven development principles establish specifications as the single source of truth to guide software engineering. Using this methodology minimizes guesswork and rework by enforcing clear requirements and defined phase gates before implementation begins.

How do I define phase gate criteria for moving from specification to implementation?

Defining phase gate criteria involves setting explicit benchmarks that must be met before advancing from the Specify phase to the Plan phase, and from Plan to Implement. This structured methodology ensures all requirements are documented and ambiguities are resolved prior to coding.

How do I manage and flag ambiguities or uncertainties in software requirements?

You can manage ambiguities in software requirements by using standardized uncertainty markers like [NEEDS CLARIFICATION]. This methodology explicitly flags unclear specifications, ensuring they are reviewed and resolved by the team before development proceeds.

Does specification-driven development work for complex projects with changing requirements?

Specification-driven development is designed for complex projects by maintaining a project constitution and strict phase gates. While it provides a structured methodology to minimize rework, frequent requirement changes may require continuous specification updates to maintain the single source of truth.