SpecDDTesting and quality
Testing and quality practices for SpecDD projects. These guides show how to turn local specs into executable checks, coverage reviews, quality gates, CI workflows, regression protection, and testability decisions while keeping specs, tests, and implementation aligned.
- How to use SpecDD with TDD
Combine SpecDD's source-of-truth contracts with TDD's executable feedback loop so tests prove the behavior the spec defines.
Read guide - How to use SpecDD with BDD
Bridge SpecDD and BDD by writing scenarios inside source-adjacent specs, deriving executable examples, and reviewing behavior together with boundaries.
Read guide - How to define acceptance criteria for implementation
Use SpecDD to write acceptance criteria that are behavioral, local, testable, and clear enough for humans and agents to implement and review.
Read guide - How to find test coverage gaps from specs
Use specs as a coverage map: trace required behavior and boundaries to tests, identify missing checks, and decide what needs verification next.
Read guide - How to run quality gates after SpecDD changes
Use quality gates to prove a SpecDD change is complete: lint specs, run relevant project checks, verify Done when criteria, and report skipped checks.
Read guide - How to use specs in CI
Add SpecDD-aware CI checks that validate specs, run behavior and quality gates, protect negative constraints, and keep task completion honest.
Read guide - How to prevent regressions with local specs
Use local specs to turn regressions into durable behavior and focused checks so the same bug or boundary violation does not return.
Read guide - How to review whether a spec is testable
Use a practical testability review to catch vague specs before implementation starts and make behavior easier to verify.
Read guide - How to choose the right test level from a spec
Use the spec's owner, behavior, risk, and Done when criteria to decide what kind of test or quality check should prove the change.
Read guide - How to test negative constraints
Use tests, static checks, and review evidence to verify important Must not and Forbids rules without forcing every negative constraint into a unit test.
Read guide - How to test authorization rules from specs
Use SpecDD policy and API specs to turn authorization rules into focused tests for allow, deny, bypass, and edge-case behavior.
Read guide
More How-To categories
- Getting started
Start with spec-driven development, write your first local SpecDD spec, and run a small end-to-end change with human-and-agent-friendly guardrails.
11 guides - Install and setup
Install the SpecDD CLI, prepare Node.js when needed, initialize or update projects, and verify the framework files are wired correctly.
9 guides - Set up your agent
Set up Claude Code, Codex, GitHub Copilot, Cursor, Windsurf, Gemini CLI, OpenCode, Junie, Cline, Antigravity, and universal Agent Skills for SpecDD.
15 guides - Editor setup
Install SpecDD editor support, validate .sdd files, resolve path warnings, and use completions and section hints while writing specs.
4 guides - Agent workflows
Use SpecDD with agents by keeping prompts short, plans spec-bound, file changes authorized, context durable, and reviews tied to local .sdd contracts.
15 guides - Write specs by level
Write SpecDD specs at the right level: root specs for project context, module specs for area boundaries, and focused specs for local behavior and contracts.
14 guides - Use spec sections
Use SpecDD sections correctly: write only sections that add local value, keep authority clear, and express behavior, boundaries, tasks, scenarios, paths, and examples.
25 guides - Spec-writing technique
Improve SpecDD craft with techniques for small specs, right-level placement, naming, splitting, explicit rules, draft review, edge cases, and compatibility.
16 guides - Spec-driven workflows
Use SpecDD workflows to draft, review, implement, synchronize, and evolve local specs without losing source-of-truth context.
11 guides - Work with SpecDD skills
Use SpecDD skills deliberately: choose the right skill for the phase, keep authority clear, chain skills safely, and verify each result against local specs.
17 guides - Software design practices
Use SpecDD to make software design decisions operational: responsibility, boundaries, layers, cohesion, debt prevention, public APIs, and dependency direction.
20 guides - Adopt SpecDD on existing projects
Adopt SpecDD gradually in live codebases by starting with active areas, reviewing generated specs, expanding folder by folder, and measuring practical review and delivery signals.
10 guides - Code review and governance
Use SpecDD in code review and governance by checking local authority, behavior, boundaries, spec updates, agent output, and high-risk contract changes.
9 guides - Refactoring and maintenance
Use SpecDD to keep maintenance safe: preserve specified behavior, maintain authority while moving code, keep specs current, and delete obsolete contracts carefully.
9 guides - Security and risk
Use SpecDD to make security and risk constraints local, explicit, reviewable, and hard for humans or agents to weaken accidentally.
13 guides - Teams and process
Use SpecDD as a team process by keeping durable behavior in specs, project planning in tickets, conventions in bootstrap.project.md, and reviews lightweight but consistent.
13 guides - Troubleshooting
Fix common SpecDD problems: agent setup, .sdd highlighting, CLI and Node errors, ambiguous specs, unresolved paths, vague specs, stale criteria, and skill installs.
12 guides