The Spec-Driven Development (SDD) Playbook
Complete a feature in minutes, not days. Liatrio's Spec-Driven Development workflow is just 4 markdown prompts that help developers guide an AI assistant through implementing their day-to-day work with structure, clarity, and evidence.
These prompts are transparent (you can read and modify every one), tool-agnostic (works with any AI assistant), and lightweight (no installation, no dependencies). They create a simple file structure in docs/specs/ that doesn't pollute your repo.
View the prompts on GitHub: github.com/liatrio-labs/spec-driven-workflow/prompts
What You Bring: Flow Input
Start with anything: an idea, a Jira story, a GitHub issue, or a feature request. The prompts adapt to your input and guide you through the workflow. No special format required—just describe what you want to build.
Built-in Scope Validation
The prompts automatically check if your work is appropriately sized. If it's too large, they'll suggest splitting it into smaller specs. If it's too small, they'll suggest direct implementation. Perfect for well-scoped features that are ready to implement.
Step 1: Specification
Transform your flow input into a structured spec with clear boundaries
The Four Steps
One person runs through these 4 prompts sequentially with an AI assistant. The example described on this site took less than 15 minutes from start to finish.
Specification
Focus: Transform your flow input into a structured specification with clear boundaries and functional requirements.
What It Does: The prompt validates scope (too large/too small/just right), asks clarifying questions, and generates a specification document.
Output: A markdown spec file in docs/specs/[NN]-spec-[feature-name]/
Prompt: generate-spec.md
Task Breakdown
Focus: Break the specification into actionable tasks with demo criteria and proof artifacts.
What It Does: Analyzes the spec, identifies relevant files, and creates a task list with parent tasks (first) and sub-tasks (after confirmation).
Output: A task list markdown file with demo criteria and proof artifact requirements
Prompt: generate-task-list-from-spec.md
Implementation
Focus: Execute tasks systematically while creating proof artifacts and following git workflow.
What It Does: Guides implementation with checkpoint modes (continuous/task/batch), creates proof artifacts, and manages git commits.
Output: Working code, proof artifact files, and task-aligned git commits
Prompt: manage-tasks.md
Validation
Focus: Verify implementation meets all spec requirements using proof artifacts and evidence.
What It Does: Creates a coverage matrix, verifies proof artifacts, checks file integrity, and produces a validation report.
Output: A validation report with PASS/FAIL gates and evidence-based coverage matrix
Prompt: validate-spec-implementation.md
The upfront investment in clarity de-risks the entire development lifecycle by preventing the two most common causes of project failure: ambiguous requirements and unchecked scope creep.
Why This Works
- Built-in scope validation prevents oversized work
- Transparent prompts you can read and modify
- Tool-agnostic—works with any AI assistant
- Simple file structure that doesn't pollute your repo
Perfect For
- Jira stories post-grooming (ready to pick up)
- Small-to-medium features (one user story)
- One-person workflows with AI assistance
- Teams wanting lightweight, flexible processes
How does this compare to other structured development tools? See our comparison against Kiro, SpecKit, and Taskmaster to understand why Liatrio's prompts fit better into the typical workflow of software developers doing day-to-day work.
From Reactive Art to Predictable Engineering
By consistently using these four prompts, developers transform small feature work from reactive coding into predictable, evidence-based implementation. Liatrio's Spec-Driven Development workflow creates a self-documenting, auditable process that systematically drives up quality, reduces ambiguity, and ensures every feature delivered is a feature validated—all in minutes, not days.
Abstract Idea
Initial concept with unclear requirements
Clear Specification
Locked scope with stakeholder alignment
Systematic Execution
Evidence-backed implementation
Validated Feature
Production-ready, merge-approved code
The Audit Trail Advantage
The linkage from Git commit, to task list, to proof artifact forms an unbreakable audit trail from a specific line of code back to the requirement it satisfies. This traceability is non-negotiable and transforms development into a transparent, verifiable process.
Self-Documenting Process
Every step generates artifacts that serve as living documentation, creating a complete project history without additional overhead.
Auditable Progress
Machine-readable commit messages and proof documents enable automated verification and compliance tracking at any point in time.
Evidence-Based Quality
Replaces subjective opinions with verifiable proof, ensuring what was built is exactly what was requested.
This disciplined approach prevents common development pitfalls and ensures that completion is a matter of proof, not opinion. The result is higher quality software, reduced risk, and a development process that scales with organizational growth.