Spec-driven development
You already ask Claude Code, Cursor or Copilot to plan before it writes code. Spec-driven tools keep that plan as files in the repo: requirements, a design, a task list. The agent then writes code from those files, and you review the files instead of a long chat.
Plan modes in Claude Code, Cursor, Codex and Copilot stop at a plan for one task. The tools below add a file layout, commands to fill it, and in some cases checks on it.
Three levels
Section titled “Three levels”Birgitta Böckeler’s article on Martin Fowler’s site names three levels, and Spec Kit’s own docs use them:
- Spec-first. A spec is written before the AI starts a task. After the task it may go stale.
- Spec-anchored. The spec stays after the task, and you change the feature later by changing the spec first.
- Spec-as-source. You edit only the spec, and the code is generated from it.
Most tools are spec-first. Few help you keep the spec current, and none of the tools below is spec-as-source today.
What tells the tools apart
Section titled “What tells the tools apart”- Who writes the requirements. In all of them but SpecCraft the AI writes the requirements file from your prompt, and you edit its text. A few keep your first words: Spec Kit as one line at the top of the spec, AI-DLC in a file later steps read, genkovich/sdd in an optional idea brief. Nothing stops the AI from changing them.
- What happens with an open question. Most tools ask and wait: Kiro, AI-DLC, GSD by default. Many write small guesses in an assumptions section and still ask about the big ones: Spec Kit, OpenSpec, spec-kitty, Intent. genkovich/sdd’s easy mode and BMAD’s fast path write the guesses down and keep going.
- Whether the spec stays current. OpenSpec and Intent are built around it. The others update the spec at some steps, or leave it to you.
- Whether the checks are code or prompts. Many “checks” are an AI pass over the files. Some tools have checks that run as code and fail the same way every time.
- Formal logic. Kiro is the only tool here that checks requirements with a solver.
- Cost. All are free and open source except Kiro. Every tool still needs an AI plan, for example Claude.
The tools
Section titled “The tools”Kiro is AWS’s agent: an IDE, a CLI, a web app and an iOS app, closed source. Specs go
in .kiro/specs/<name>/ as requirements.md, design.md and tasks.md, with requirements in EARS form (“When X,
the system shall Y”). Two things no other tool here has:
- An optional deep analysis: an LLM turns the requirements into solver input, a solver (SMT, a program that checks logic) finds contradictions and cases no rule covers, and each finding becomes a keep-or-change question. Then an LLM rewrites the requirements it affects.
- Property-based tests taken from the requirements, each linked back to its requirement. IDE only.
A “Sync Files” button updates tasks from changed requirements. Nothing updates the spec from the code. The agent asks questions when it needs to, rather than writing assumptions down.
Kiro is the only paid tool here: a free plan with 50 credits a month, then $20 to $200 a month. All AI calls go through Kiro; you cannot use your own key or plan. Claude Code can run inside Kiro only as a preview, and Kiro specs are not supported from plain Claude Code. The iOS app (paid plans, iOS 26+) starts or continues a spec session and reviews diffs.
OpenSpec
Section titled “OpenSpec”OpenSpec (npm @fission-ai/openspec) keeps the current specs in
openspec/specs/ and puts each change in its own folder, with requirements marked ADDED, MODIFIED, REMOVED or
RENAMED. Archiving a change merges it into the specs, so the specs stay current. openspec validate checks the
structure (headers, a scenario per requirement), not the meaning. The AI writes all of it and you review; your
request is not saved. It asks about big gaps and makes “a reasonable assumption and record[s] it” for small details.
Intent
Section titled “Intent”Intent is a desktop app that runs Claude Code, Codex, OpenCode and other agents. It started as “Intent by Augment” and is now a free, Apache 2.0 project of its own. A coordinator agent drafts a “living spec” note, you approve it, agents update it as the code changes, and a verifier agent checks the work against it. The spec writer asks one to four questions first and may mark assumptions “(confirm?)”. The spec is a note in a local SQLite database, not a file in git you review in pull requests. The iOS app reads spec notes and changes only task status, and needs your computer running.
GitHub Spec Kit
Section titled “GitHub Spec Kit”The Spec Kit CLI (specify) adds commands to your agent: /speckit-specify,
-plan, -tasks, -implement, and optional -clarify, -analyze and -checklist. Files go in
specs/<feature>/. It has the most GitHub stars of the tools built only for spec-driven work. The AI makes informed
guesses and lists them in an Assumptions section, but still asks up to three questions in specify and up to five
more in clarify, which rewrites the spec in place. Its docs describe three ways to keep specs and pick none as the
default; analyze reports mismatches and changes nothing.
BMAD Method
Section titled “BMAD Method”BMAD gives the agent many roles: analyst, product manager, product
owner, architect, UX designer, developer. The agents draft the brief, the PRD and the requirements, and a hand edit
“is overwritten on the next run”. The fast path drafts with [ASSUMPTION] tags; the coaching path walks through each
section with you. It is the heaviest process here, close to a small team’s.
Requirement ids checked in code: spec-kitty, GSD, AI-DLC
Section titled “Requirement ids checked in code: spec-kitty, GSD, AI-DLC”Three tools give each requirement an id and check that every id maps to planned work:
- spec-kitty is the strictest: finishing fails in code if a requirement has no work package. Small gaps get defaults in an Assumptions section; it asks at most three questions.
- GSD Core maps each requirement to one phase and flags ids no plan names,
partly in code and partly in prompts. By default it asks about four questions per area;
--autopicks the suggested answer and logs it. - AWS AI-DLC checks a
traceability.jsonfile with a check you can turn off. It saves your first request unchanged and writes assumptions with their reasons, then stops until you accept them: its rule is “Default to asking, not assuming.”
All three are heavy, and the AI writes the requirements.
genkovich/sdd
Section titled “genkovich/sdd”genkovich/sdd is a Claude Code plugin that writes one folder per feature in
docs/features/<slug>/. Its “easy” depth writes each open point as “Assumed: X = Y, because …” and you strike out
the ones you disagree with in one pass; the medium and hard depths ask instead. A question put off gets “Default now:
X”. An optional interview step keeps your raw idea word for word in docs/idea-brief.md. Of the tools here, it
handles open questions closest to “guess, write it down, keep going”.
SpecCraft
Section titled “SpecCraft”SpecCraft is pre-release. You write the requirements, and the AI writes the spec, the tests and the code. The AI’s choices on open questions go into the spec as assumptions instead of questions that wait for you. The spec quotes your requirements, and a gate marks a spec as behind when a requirement it quotes changes. Test cases come from a Quint model and carry ids the tests use. It runs as a Claude Code plugin, and a web editor made for the phone edits the requirements and specs in GitHub.
Which to pick
Section titled “Which to pick”- To try the idea in the agent you use now: Spec Kit or OpenSpec. Pick OpenSpec if the same features change often: of the tools that keep specs as files in the repo, it is the only one whose specs stay current by design. Pick Spec Kit for new features and the largest community.
- When you want a living spec and agents run side by side, and do not need the spec in git: Intent.
- To have requirements checked for contradictions and gaps: Kiro. No other tool here runs a solver on them.
- When an auditor needs every requirement traced to work: spec-kitty, then GSD or AI-DLC.
- When you want the AI to write its guesses down instead of asking: genkovich/sdd in its easy depth.
For a team new to all of this, start with Spec Kit or OpenSpec on one feature. The heavier tools (BMAD, spec-kitty, GSD, AI-DLC) pay off only once you know which part of the process you want enforced.