Spec-driven development asks an AI coding agent to build to a written spec instead of a chat prompt. GitHub Spec Kit, Kiro and Tessl all do that. They differ on where the spec lives, who approves it, and what happens to it after the merge.
The short answer
Start with Spec Kit for a free, open workflow around the agent you already use. Choose Kiro if you want it built into an IDE. Watch Tessl. Look at CrewPE when named people must approve the spec and the change spans several repositories.
The problem: agents build what you said
Coding agents got good at writing code faster than teams got good at telling them what to write. A one-line ticket becomes a prompt, the agent fills the gaps with guesses, and the guesses look plausible enough to pass review.
The strain shows up in review. In Sonar’s 2026 State of Code survey of more than 1,100 developers, 96% said they do not fully trust AI-generated code, and 38% said reviewing it takes more effort than reviewing a colleague’s. Much of what reviewers catch is not bad code. It is code that does the wrong thing well.
THE GAP
The agent built exactly what the prompt said. The prompt was not what the business meant.
Spec-driven development is the industry’s answer: write a structured spec first, then let the agent plan, build and check against it. It is the most discussed shift in agentic engineering this year. Spec Kit has passed 100,000 stars on GitHub, and Kiro became generally available in May 2026.
Birgitta Böckeler’s review on martinfowler.com sorts the approaches into three levels. Spec-first writes a spec before the code. Spec-anchored keeps the spec and updates it as the code changes. Spec-as-source edits only the spec and generates the code. Every tool starts spec-first. The hard part is what happens next.
How the market solves it
GitHub Spec Kit
Spec Kit is GitHub’s open-source toolkit. Its CLI adds templates and slash commands to your repository, and your agent walks through them: a constitution with the project’s rules, then specify, plan, tasks and implement, with optional clarify and analyze steps. It works with about 30 coding agents, and the specs are Markdown files reviewed in pull requests like any other code.
It is free, open and agent-agnostic, with the largest community of the four. The limits: it is heavy for small changes, and nothing in it says who has to agree to a spec before the agent starts.
Kiro
Kiro is an agentic IDE from AWS. Its spec mode moves from requirements written in EARS notation (“When a user submits the form, the system shall…”) to a design, then to a task list the agent works through. Hooks run agents on events such as a file save. EARS is the most testable requirements format here: each line can be checked against a test.
Kiro has a free tier and paid plans from about $20 a month, billed in credits. Sources disagree on the exact tiers, so check Kiro’s own pricing page. The limits: you work in its IDE with its agent, and Böckeler saw it turn a small bug fix into four user stories with 16 acceptance criteria.
Tessl
Tessl makes the boldest bet: spec-as-source. You edit specs, and its framework generates the code each spec owns, so the spec and the code cannot drift apart. Its registry is public and free. The framework has been in closed beta since January 2026, and early reviews describe it as JavaScript-only, with generation that is not yet deterministic.
Does the tool matter more than the method? One independent benchmark of 50 Python tickets found Kiro merged 41 and Spec Kit 40. Writing the spec is what helps. The tools differ in what they do with it.
How CrewPE approaches it
We agree with the premise. We differ on the questions the others leave open: who agreed to the spec, and does it hold across every repository the change touches?
In CrewPE, each piece of work runs as a thread through stages. At each stage an agent drafts, and a named person locks the result before the next stage begins.
Intent
The Thread Analyst interviews the requester until the ask is clear, then writes the Intent Brief. The product owner locks it.
Spec
Requirements and acceptance criteria in plain language, for every repository the change touches, with a readiness score. You lock it.
Architecture
The Thread Engineer writes the architecture decision, with the alternatives it ruled out. The engineering lead locks it.
Stories and build
Your coding agents build each story and check it against every acceptance criterion. A person approves the merge.
Three things follow from that.
The spec has an owner. Every lock records who locked it and when, so a year later an auditor can see who agreed to what.
The spec spans repositories. CrewPE reads your repositories into a knowledge graph, so the spec and its impact analysis name every service a change touches, not only the one open in the editor.
The spec reaches the agent you already use. Specs, acceptance criteria and context are served to Claude Code, Codex, Cursor or Copilot over MCP, so the agent builds to the locked spec instead of a pasted prompt.
A spec nobody approved is still a prompt.
Here is how that looks for a team adding rate limits per tenant. The spec names three repositories: the API gateway, billing and the admin console. The engineering lead locks an architecture decision for one shared limiter. Each repository’s story is built by the team’s own agent and checked against its acceptance criteria, and every merge links back to the locked spec.
The cost is process. Four locked stages are too much for a typo fix, and CrewPE is newer and has fewer users than any of the three tools above.
Head-to-head comparison
Bold marks where each tool is strongest. Details were checked against public sources in November 2026.
| Comparison of spec-driven development tools | GitHub Spec Kit | Kiro | Tessl | CrewPE |
|---|---|---|---|---|
| What it is | Open-source CLI and templates | Agentic IDE from AWS | Spec framework and skills registry | SDLC platform around your coding agents |
| Spec artifacts | Constitution, spec, plan, tasks | EARS requirements, design, tasks | Specs that own code files | Intent brief, functional spec, ADR, stories |
| Which agent builds | Yours: about 30 agents supported | Kiro’s own agent | Its framework (closed beta) | Yours: Claude Code, Codex, Cursor, Copilot |
| Who approves the spec | Whoever runs it; review in the PR | The developer, in the IDE | The developer | A named owner locks each stage |
| Context across repositories | One repo | One project | One repo | Knowledge graph across repos |
| Small changes | Heavy without a clarify step | Can over-specify a small fix | Not its target yet | Heavy: a thread for each piece of work |
| Cost | Free (open source); you pay for your agent | Free tier; paid plans from about $20 a month | Registry free; framework in beta | No public pricing; proof-of-value pilot |
| Maturity | Largest community | Generally available since May 2026 | Beta | Newer, smaller user base |
Where the others lead: Spec Kit is free, open and works with almost any agent today. Kiro’s EARS requirements are the easiest to test, and they come built into an IDE. Tessl is the only one designing spec drift out of the system. CrewPE has no public pricing and the smallest community of the four.
Who should use what
- Choose Spec Kit if you want to try spec-driven development this week, in one repository, with the coding agent you already pay for.
- Choose Kiro if your developers want the whole workflow in one IDE, you work mostly on AWS, and you value testable requirements over choosing your own agent.
- Watch Tessl if spec drift is your biggest worry and you can wait for the framework to leave beta.
- Choose CrewPE if your changes cross several repositories, if people outside engineering have to agree to what gets built, or if you need to show an auditor who approved each change. It is not the right pick for a small team that wants the lightest possible process.
The four tools agree that the spec should come first. They disagree on who owns it. Spec Kit leaves that to your pull-request process, Kiro to the developer in the IDE, and Tessl to the spec itself. CrewPE gives each stage a named owner and keeps the spec attached to every change across your repositories.
In CrewPE
If your team is evaluating spec-driven development tools, CrewPE is worth a look, especially if specs have to be approved by named people and hold across several repositories.
See how CrewPE worksQuestions teams ask
- What is spec-driven development?
- Spec-driven development means writing a structured specification (requirements, acceptance criteria and a plan) before an AI coding agent writes code, and building and checking the code against that spec. The spec, not the chat prompt, becomes the source of truth for what the change must do.
- Which spec-driven development tool should a team start with?
- Most teams can start with GitHub Spec Kit: it is free, open source and works with the coding agent they already use. Kiro suits developers who want the workflow built into an IDE, especially on AWS. Tessl is worth watching but is still in beta. CrewPE fits teams that need named people to approve specs across several repositories.
- Does spec-driven development work for small changes?
- Not well yet. Every tool in this comparison adds steps that pay off on features and multi-repo changes but feel heavy for a one-line fix. Reviewers have seen a small bug turned into several user stories. Keep a lighter path for small, low-risk changes.
- Does CrewPE replace Spec Kit, Kiro or our coding agent?
- No. Your coding agents keep writing the code. CrewPE governs the work around them: the spec they build against, the people who approve it, and the evidence that each acceptance criterion was met.
Sources
Product and pricing details change often. Check each vendor’s own pages before you decide.
- Birgitta Böckeler, “Understanding Spec-Driven-Development: Kiro, spec-kit, and Tessl”, martinfowler.com
- Sonar, “State of Code developer survey report: the current reality of AI coding”
- Uvik, “Spec-Driven Development Benchmark 2026”
- Visual Studio Magazine, “GitHub Spec Kit takes off as antidote to piecemeal vibe coding”
- Morph, “Kiro pricing (September 2026)”
- CodeMySpec, “Tessl review (2026): the spec-as-source bet”
Maathavan Vinayak
Co-founder of EnWithAI, working on CrewPE and on how teams and AI agents agree what to build before they build it.