SpecDDAgent workflows
Workflow guides for using SpecDD with coding agents after setup: prompts, plans, context, boundaries, review, ambiguity, and consistent behavior across tools.
- How to prompt an agent with SpecDD
Use short task prompts with SpecDD by naming the real work, keeping each prompt to one instruction, and reviewing the result against the governing spec.
Read guide - How to make an agent follow specs
Use a file-aware coding agent with SpecDD by verifying spec-aware behavior, prompting one bounded task, reviewing the plan, and checking the diff.
Read guide - How to reduce agent mistakes with specs
Use local SpecDD specs to reduce common agent mistakes: wrong files, missed requirements, broad scope, forgotten checks, and task status changes before verification.
Read guide - How to ask an agent to plan before coding
Use a SpecDD planning prompt before implementation so the agent identifies the governing spec, allowed files, constraints, checks, and ambiguity before editing.
Read guide - How to review an agent plan against a spec
Use a SpecDD review checklist before implementation so an agent plan stays inside authority, satisfies the spec, avoids forbidden work, and names checks.
Read guide - How to keep agents from changing the wrong files
Use SpecDD write authority and review checks to keep agents inside the files a local spec allows and prevent edits to read-only or referenced context.
Read guide - How to stop agents from overengineering
Use SpecDD to keep agent work small: write bounded tasks, define Done when criteria, block tempting non-goals, and reject plans that add unnecessary abstractions.
Read guide - How to use specs as agent memory
Make agent context durable by keeping project memory in local SpecDD specs, where humans and agents can review intent, ownership, constraints, and tasks across sessions.
Read guide - How to manage context for agents
Use SpecDD to manage agent context without huge prompts: open the right root, keep specs local, inherit vertical context, and reference outside contracts explicitly.
Read guide - How to use SpecDD with multiple agents on one repo
Coordinate multiple agents in one repo with SpecDD by using shared specs, separate bounded tasks, consistent roots, careful task status, and review against local contracts.
Read guide - How to get consistent results across different agents
Use SpecDD to make Claude Code, Codex, Copilot, Cursor, and other agents work from the same project contracts instead of separate chat memory.
Read guide - How to ask an agent to explain a spec before implementation
Use a spec explanation prompt before implementation to catch missing context, wrong authority, ambiguous tasks, and misunderstood completion criteria early.
Read guide - How to stop an agent when the spec is ambiguous
Use SpecDD ambiguity handling to pause implementation, record decisions with task states, update the local spec, and prevent agents from guessing.
Read guide - How to ask an agent to update the spec after discovering missing context
When implementation reveals missing context, use SpecDD to stop guessing, draft a spec update, review it, apply the approved rule, and resume from the updated contract.
Read guide - How to keep agent prompts short with SpecDD
Use SpecDD to replace long repeated agent prompts with local specs, short task names, separate planning and implementation requests, and contract-based review.
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 - 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 - Testing and quality
Turn SpecDD specs into practical quality work: TDD and BDD loops, acceptance criteria, coverage tracing, CI checks, regression tests, and testability review.
11 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