Introducing SDD Framework
Engineering discipline for the AI era
AI is an amplifier: it multiplies a team that has a control system, and it multiplies the chaos of a team that lacks one. SDD Framework is that control system — machine-enforced, auditable, running on the strongest coding agent available.
On your own repo. Nothing to prepare.
“A specification that is not enforced is merely a suggestion.”
Other tools generate specs and hope the AI follows them. SDD enforces them: CI-blocking gates, tool-level hooks, a hash-chained decision log.
90%
of developers now use AI at work
DORA 2025
66%
name “almost right, but not quite” their #1 frustration
Stack Overflow 2025
45%
of AI-generated code contains security flaws
Veracode 2025
95%
of enterprise GenAI pilots show zero P&L impact
MIT NANDA 2025
The real pain of AI-assisted development
Not anecdotes — 2024–2025 data from the largest studies in the industry.
–19%
The productivity mirage
A randomized trial on veteran maintainers of 1M+ LOC repos: AI made them 19% slower — while they believed they were 20% faster. The last 30% of every task (edge cases, security, production) stays as hard as ever.
METR RCT 2025 · Addy Osmani 2024
×8
Systematic quality decay
Across 211M changed lines: duplicated code blocks grew 8× in 2024, copy-paste overtook refactoring for the first time, and churn nearly doubled. That is the maintenance debt your company pays for 3–5 years.
GitClear 2025
45%
Insecure by default
45% of AI-generated code carries a vulnerability (Java: 72%) — and newer models are no safer. Worse: 19.7% of packages LLMs recommend do not exist, feeding “slopsquatting” supply-chain attacks.
Veracode 2025 · USENIX Security 2025
–7.2%
Faster, but less stable
DORA 2024 measured each step of AI adoption against –7.2% delivery stability; the 2025 report shows the instability persists. AI only pays off where a control system — tests, traceability, fast feedback — already exists.
DORA 2024 / 2025
95%
Pilots that never reach P&L
MIT surveyed 300+ enterprise GenAI initiatives: 95% show no measurable financial impact. The named root cause is not model quality — it is flawed integration into the workflow. Gartner expects ≥30% abandoned after PoC.
MIT NANDA 2025 · Gartner
DB×0
When there are no guardrails
July 2025: during a publicized vibe-coding run, an AI agent deleted a production database during a declared code freeze, then fabricated ~4,000 fake records to mask it. Every safeguard added afterwards is what a gated pipeline enforces up front.
Fortune · The Register · AI Incident DB #1152
SDD Framework: the discipline operating system
A methodology shipped as tooling on Claude Code: it turns a vague request into working, fully-traceable, audit-grade software through six disciplined phases. Built for enterprise, regulated, and ERP/fintech teams. Vietnamese-native across the whole lifecycle.
SPECIFY → PLAN → TASKS → IMPLEMENT → VERIFY → REVIEW → (REPORT)
Every phase ends at a hard quality gate. A failed gate never passes silently — it jumps straight to a report a human always sees.
The four backbone articles of the eight-article constitution
01
Specs are the source of truth
When code disagrees with the spec, the spec wins. A wrong spec gets fixed first; then the code, with a regression test.
02
Traceability is non-negotiable
Every requirement traces spec → task → code → test → commit, verified by machine, not by promise.
03
TDD is mandatory
The failing test comes first; editing a test to make it pass is blocked by a hook.
04
Gates fail loud
Nothing is skipped silently. Every failure produces an explicit record.
Each pain, answered by a mechanism
Read the right column as a list of risks your team stops carrying — none of it is a promise in a prompt; every line is a mechanism you can switch on from day one.
“Almost right, but not quite”
EARS + Given/When/Then requirements with numbered acceptance criteria; a gate requires every scenario to be cited by at least one test. “Almost right” does not pass.
AI edits tests until they pass
20 hooks.json-wired enforcement hooks at the tool layer: test-tamper guard, write-before-failing-test guard, commit-on-red-gate guard (config-enabled). Mechanical blocks, not prompt reminders.
45% of AI code is vulnerable
A full security-gate suite — committed secrets, CWE shapes, SSRF, dependency CVEs, injection, PII — plus an OWASP semantic review lens and SBOM generation, inside the pipeline.
Nobody can audit AI decisions
Every autonomous decision is risk-classified and appended to a hash-chained log (IETF AAT profile); HMAC-SHA256 signing with an operator-held key makes it tamper-resistant.
Replit-class incidents
Structural separation of powers: reviewers hold no write permission (enforced by tool allowlist), worktrees carry a write-lock, CRITICAL decisions require an independent critic PASS.
95% of pilots die in integration
SDD is the process itself — six phases, gates, roles, audit — not a chatbot bolted on. DORA: AI amplifies your control system; SDD is that control system, pre-installed.
Watch it run
This website was itself built by the SDD pipeline. The replay below condenses its most recent run: every figure can be checked against the committed QUALITY_REPORT.md, down to the closing marker.
/pipeline
IMPLEMENT · 4 tasks, TDD-first: the failing test lands before the code — a real RED, then GREEN
✓ APPROVED · per-task review round
VERIFY · full suite 349/349 green · FR → code → test traceability · evidence sealed
✓ PASS · verify gate
REVIEW · independent reviewers with no write access · critical 0 · major 0 · minor 0
✓ PASS · review gate
REPORT · the numbers block in QUALITY_REPORT.md is machine-generated from sealed gate evidence
%%SDD_GATE gate=report verdict=PASS must_fr_blocked=0
Figures from the project’s QUALITY_REPORT.md — pipeline session 01484855, verdict PASS; the %%SDD_GATE line drops its technical fields (head, session, evidence).
The 90-minute demo runs a session exactly like this on your own repo.
33 skills across the whole lifecycle
Three tiers, machine-verified: 12 core skills for the everyday path, 18 advanced for lifecycle and operations, 3 enterprise integrations — plus 15 specialized agents and an autonomous mode that never stops mid-pipeline to ask. You are not buying a tool: you are receiving a packaged, working process your current team installs and runs.
Core
12The everyday path — the six phases, the orchestrators, and the fix loops.
/specify
Extract requirements from business documents into a structured, testable SRS
/plan
Design the architecture from the specs — modules, data model, ADRs
/tasks
Break specs + design into a milestone-grouped task DAG
/implement
Implement one task TDD-style, with traceability markers
/verify
The verification gate: tests + traceability + acceptance + lint → PASS/WARN/FAIL
/review
Structured review against the specs: compliance, OWASP, performance, boundaries
/pipeline
Run phases 4→7 end to end; a failed gate jumps to the report
/autopilot
From a requirements folder to built, verified software — end to end
/bugfix
TDD bug protocol: failing regression test first, fix the source, never the test
/change
The front door for any described change: classify, survey impact, route, stop at the task DAG
/security-scan
Full security sweep: secrets, CWE shapes, SSRF, dependency CVEs, injection, PII + OWASP lens
/sdd-help
Deterministic usage cards for every skill — no LLM, no network
Advanced
18Lifecycle and operations: brownfield onboarding, change management, isolation, observability.
/brief
Analyst-persona discovery: turn a raw idea into a signed project brief
/clarify
Bounded clarification loop over an 11-category requirement taxonomy
/validate-specs
Validate SRS quality and cross-artifact consistency
/sdd-init
One-time bootstrap: scope config + the decision-audit directory
/sdd-adopt
Onboard an existing codebase onto SDD at any maturity, gap by gap
/srs-from-source
Reverse-engineer an IEEE 29148-grade SRS from existing code (~12 stacks)
/sdd-doctor
Deterministic health check + autonomous self-healing of the install
/sdd-metrics
Operational KPIs: gate pass-rate, decision volume and risk mix, reversal rate
/delta
Requirement-level change proposals — machine-validated, versioned, reversal-scanned
/architecture-change
Cross-service change: blast radius, specs before code, dependency order
/subagent-implement
A fresh, context-isolated subagent per task with its own review loop
/resume
Resume an interrupted pipeline from the last checkpoint; reverse decisions with --adjust
/worktree
Isolated git worktrees so parallel runs never collide
/finish-branch
Close the branch lifecycle: verify, merge/PR, provenance-checked cleanup
/trace-check
Quick FR → code → test coverage scan with an orphan report
/generate-guardrails
Compile the BOUNDARIES rules into tool-layer permission denies
/ui-testgen
Generate durable Playwright E2E tests from UI acceptance criteria
/champion-mode
Mentor mode: personalized SDD onboarding for new team members
Enterprise
3Integration and compliance (experimental tier — the code-backed audit guarantee is the hash chain).
/sync-jira
Two-way sync between SDD requirements/tasks and Jira issues
/publish-confluence
Publish specs to Confluence as versioned, searchable knowledge
/audit-report
Auditor-ready bundle from SDD artifacts; Vietnamese output supported
Autonomous mode with a paper trail
At every would-ask point the agent decides through a 7-step authority chain, classifies risk, and logs the decision to the hash chain. CRITICAL decisions need an independent critic PASS; operators review post-hoc and can reverse any decision. Hand it a requirements folder in the evening; receive implemented, verified, reviewed software with the full “why” of every judgment call.
Three independent review rounds
Task → milestone → project, multiple lenses per round (spec compliance → code quality → adversarial). Reviewers structurally cannot write code, and extra lenses (blind-hunter, drift-sentinel, UI-taste) only block when the primary reviewer independently confirms — the two-key rule.
Brownfield: your legacy code included
/sdd-adopt onboards an existing codebase at any maturity, gap by gap. /srs-from-source reverse-engineers an IEEE 29148-grade SRS from 1,000+ file repos — recipes for .NET, Java, Python, JS/TS, Go, Rust, PHP, Ruby, Kotlin. No competitor ships this.
Change management that answers “Waterfall?”
/change classifies and routes any described change; /delta versions requirement-level proposals with machine validation; /architecture-change computes blast radius across services and updates specs before code, in dependency order. Designed for continuous change, not big-bang documents.
Against the best-known tools
The market sells two things: speed without governance (Cursor, Copilot, Devin, Codex) or methodology without enforcement (Spec Kit, Kiro, BMAD, Superpowers). SDD is the third layer serious software companies actually need.
| Capability | SDD Framework | GitHub Spec Kit | AWS Kiro | BMAD-Method | Superpowers | Cursor / Copilot | Devin / Codex |
|---|---|---|---|---|---|---|---|
| Structured specs (EARS/GWT) | ✔ + depth gates | ✔ templates | ✔ EARS | ✔ PRD/story | ✘ design docs, not SRS | ✘ | ✘ |
| Machine-enforced specs (CI-blocking exit-code gates) | ✔ 98 gate scripts | ✘ AI self-check | ✘ agent-judged | ✘ advisory | ✘ skill-guided | ✘ | ✘ |
| FR → code → test traceability, machine-verified | ✔ + commit trailer | ✘ | ✘ no RTM | partial, optional module | ✘ | ✘ | ✘ |
| TDD enforced by hooks (test-tamper blocked) | ✔ test-tamper · write-TDD · gate-stop | ✘ “Tests are OPTIONAL” | ✘ automation hooks, no blocking | TEA module only | TDD skill, not hook-enforced | ✘ | ✘ |
| Independent multi-round review, reviewers without write access | ✔ 3 rounds, 15 agents | ✘ | ✘ | persona prompts | 2-stage subagent review | single-pass PR review | self-review, not independent |
| Hash-chained decision log, HMAC signing | ✔ IETF AAT | ✘ | ✘ | ✘ | ✘ | access logs only | ✘ |
| Governed autonomy: independent critic + reversible decisions | ✔ | ✘ | ✘ | ✘ | subagent-driven, no audit | agent mode, no audit | autonomous, ungoverned |
| Brownfield: reverse-engineer an SRS from existing code | ✔ IEEE 29148, ~12 stacks | ✘ greenfield-first | ✘ per-feature | partial (project docs) | ✘ greenfield-first | ✘ | auto wiki, not an SRS |
| Change management (delta specs, multi-service blast radius) | ✔ | ✘ | ✘ | manual doc edits | ✘ | ✘ | ✘ |
| Security scan + SBOM + generated guardrails | ✔ | ✘ | basic credential scan | ✘ | ✘ | depends on companion product | ✘ |
| Audit / compliance reporting foundation | ✔ hash-chain based | ✘ | ✘ | ✘ | ✘ | ✘ | ✘ |
| Vietnamese-native process & docs | ✔ whole lifecycle | ✘ | ✘ | ✘ | ✘ | ✘ | ✘ |
Spec Kit ships “Tests are OPTIONAL” in its runtime templates and its Constitution Check is an AI self-check. Kiro’s task completion is agent-judged with no coverage gate. BMAD’s trace matrix lives in an optional module with advisory sign-off. Superpowers is the closest peer — a composable-skills methodology on Claude Code with a real TDD workflow and two-stage subagent review — but its skills guide by prompt, nothing blocks at the tool layer, and it ships no traceability matrix, audit log, security suite, or Vietnamese lifecycle. Copilot Enterprise’s SOC 2 is vendor-level compliance — not an audit report for your own development process. Sources and dates: see the full reference document.
The economics of discipline
The proven upside — when AI is used right
55%
faster task completion in GitHub’s controlled experiment
GitHub RCT
+84%
more successful builds in the GitHub × Accenture enterprise study
GitHub × Accenture 2024
35–45%
faster code generation (but <10% on complex tasks — the gain concentrates where structure exists)
McKinsey 2023
59%
report better code quality — conditional on a strong control system
DORA 2025
The silent bleed SDD stops
For a 20-engineer team using ungoverned AI, the hidden cost lines the industry data points at — and the mechanism that closes each one:
Rework on “almost right” code
AC-coverage gate: every acceptance scenario needs a citing test before the phase passes.
Security incidents from AI code
The security-gate suite and OWASP lens run inside the pipeline, not once a quarter.
Maintenance debt from duplication
Architecture designed at Phase 2 with ADRs; three review rounds watch quality and conformance.
Production incidents caused by agents
Tool-layer hooks, isolated worktrees with write-locks, independent critic on CRITICAL decisions.
Pilots dying after the PoC
SDD ships as the integrated process — precisely the “learning gap” MIT identified.
System knowledge leaving with people
SRS, DESIGN, ADRs and the audit log are automatic by-products of every build.
An illustration you can re-run with your own numbers: 20 engineers at a blended cost of 25M VND/person/month. If just 15% of that time bleeds into reworking “almost right” AI code — far below what the survey data suggests — that is 75M VND every month, 900M VND a year, on one waste line alone. Process discipline costs far less than its absence.
Why believe it: SDD built itself with SDD
We are not asking you to trust slides. These figures were measured directly from the framework repo (2026-07-14):
98
machine-verification gate scripts
specs-framework/scripts/
20
tool-layer enforcement hooks
hooks/hooks.json
15
specialized reviewer/critic agents
agents/
33
user-invokable skills, 3 tiers
skills/*/SKILL.md
7,386
test functions on the engine itself
CI: Python 3.10–3.12
14/14
planted defects caught — zero escapes, zero false alarms
evals/RESULTS.md
81/81
FRs traced spec↔code↔test in the dogfood build (100%)
meta-sdd/QUALITY_REPORT.md
190
Python scripts run the deterministic engine — machinery, not prompts
specs-framework/scripts/
One detail we keep on purpose: the framework publishes its own limits — traceability gates check citations (behavioral correctness is the review rounds’ job), enterprise integrations are experimental, small-sample evals carry caveats. A vendor that knows its tool’s exact boundary is worth more to an audited industry than one that promises everything.
Delivery model
A private toolkit, transferred directly. Minimal footprint: Claude Code + Python 3.10+ — gates run on the Python standard library, fully local — beyond Claude Code itself, no third-party service touches your source.
Week 1 — Pilot
One project, new or brownfield. The team watches the pipeline and gates run on their own code.
Weeks 2–4 — Standardize
Configure the risk appetite (rigor profile, review-lens floors, HMAC signing), onboard the team with champion-mode.
Month 2+ — Scale
Replicate across projects; track gate pass-rates and decision mix with /sdd-metrics; wire Jira/Confluence as needed.
See SDD run on your own codebase
A 90-minute demo on your own repo: /srs-from-source on a legacy system, or /autopilot on a real requirement. Discipline is something you watch run — not something you get told about.
Book a demo90 minutes · on your repo · nothing to prepare
Industry figures: DORA 2024/2025, Stack Overflow Developer Survey 2025, METR 2025, GitClear 2025, Veracode 2025, USENIX Security 2025, MIT Project NANDA 2025, Gartner, GitHub/Accenture, McKinsey 2023. Framework figures measured from the SDD-Framework repo on 2026-07-14. Fast-moving numbers (stars, pricing) as read on that date.
Book a consultation
Leave your details and we’ll reach out to advise on applying SDD to your team.