Blog/Specs

Specs

Spec-driven development tools: how Spec Kit, Kiro, Tessl and CrewPE compare

Maathavan VinayakCo-founder, EnWithAI

7 min read

Talk to us

Where the spec lives after the merge

  1. Spec KitMarkdown files in your repo
  2. KiroRequirements, design and tasks in the IDE project
  3. TesslThe spec owns the code it generates
  4. CrewPELocked in the thread by a named person

A spec is only as strong as the person who agreed to it.

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.
Most rework from coding agents starts before the first line is written.

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.

  1. Intent

    The Thread Analyst interviews the requester until the ask is clear, then writes the Intent Brief. The product owner locks it.

  2. Spec

    Requirements and acceptance criteria in plain language, for every repository the change touches, with a readiness score. You lock it.

  3. Architecture

    The Thread Engineer writes the architecture decision, with the alternatives it ruled out. The engineering lead locks it.

  4. 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 toolsGitHub Spec KitKiroTesslCrewPE
What it isOpen-source CLI and templatesAgentic IDE from AWSSpec framework and skills registrySDLC platform around your coding agents
Spec artifactsConstitution, spec, plan, tasksEARS requirements, design, tasksSpecs that own code filesIntent brief, functional spec, ADR, stories
Which agent buildsYours: about 30 agents supportedKiro’s own agentIts framework (closed beta)Yours: Claude Code, Codex, Cursor, Copilot
Who approves the specWhoever runs it; review in the PRThe developer, in the IDEThe developerA named owner locks each stage
Context across repositoriesOne repoOne projectOne repoKnowledge graph across repos
Small changesHeavy without a clarify stepCan over-specify a small fixNot its target yetHeavy: a thread for each piece of work
CostFree (open source); you pay for your agentFree tier; paid plans from about $20 a monthRegistry free; framework in betaNo public pricing; proof-of-value pilot
MaturityLargest communityGenerally available since May 2026BetaNewer, 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 works

Questions 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.

  1. Birgitta Böckeler, “Understanding Spec-Driven-Development: Kiro, spec-kit, and Tessl”, martinfowler.com
  2. Sonar, “State of Code developer survey report: the current reality of AI coding”
  3. Uvik, “Spec-Driven Development Benchmark 2026”
  4. Visual Studio Magazine, “GitHub Spec Kit takes off as antidote to piecemeal vibe coding”
  5. Morph, “Kiro pricing (September 2026)”
  6. 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.

Keep reading

Bring one change that crosses repositories. See the spec it would be built to.

Start with a 45-minute call about your system: how it is built, where specs are agreed today, and a sensible first step.