Skip to content
RuleSellBeta
Sign up

Topic · A9

Spec-Driven Development: Spec-Kit (93k stars), AWS Kiro, BMAD

Spec-driven development (SDD) is the 2026 successor to 'vibe coding': write a structured spec, let agents generate the tasks, tests, and implementation from it. The three tools to know are GitHub's Spec-Kit (93,000 stars, 30+ agent integrations), AWS Kiro (spec-first IDE with contradiction-proving), and BMAD-METHOD (46,700 stars, 12 specialized agents). Andrej Karpathy formalized the shift at Sequoia AI Ascent 2026.

Spec-driven development is the workflow shift that finally puts structure underneath agentic coding.

The premise: instead of telling the agent to "add a payments page" and hoping, you write a spec — what to build, success criteria, edge cases, examples — and the agent generates the task list, tests, and implementation from that spec. The human reviews the spec instead of reviewing the code. It's slower at the front and faster everywhere else. Andrej Karpathy formalized the shift at Sequoia AI Ascent 2026, calling it the explicit successor to "vibe coding."

This page covers the three SDD tools developers are actually adopting in 2026: GitHub Spec-Kit, AWS Kiro, and BMAD-METHOD. They make different tradeoffs and target different audiences, and the differences matter when you're picking one.

What SDD actually changes

The "before" workflow with a coding agent looks like this:

  1. Human writes a paragraph in the agent's chat box describing what they want.
  2. Agent generates code.
  3. Human reads the code, finds bugs, asks for fixes.
  4. Repeat steps 2-3 until acceptable.
The agent's understanding is reconstructed from short conversational turns. Edge cases get caught in step 3 (or worse, in production). The spec lives in someone's head.

The SDD workflow looks like this:

  1. Human writes a structured spec — feature description, acceptance criteria, examples, edge cases — into a file in the repo.
  2. Agent reads the spec and generates a task list with explicit dependencies.
  3. Agent generates tests from the acceptance criteria.
  4. Agent generates implementation that satisfies the tests.
  5. Human reviews the spec for completeness, then accepts or rejects the work products.
The spec becomes a durable artifact. The agent's reasoning becomes auditable against the spec. Edge cases that should have been caught in step 1 actually are caught in step 1, because writing them down is part of the workflow.

The cost is real — writing a good spec takes 30-90 minutes for a meaningful feature. The payoff is fewer regressions, faster onboarding for new agents/humans, and a structured artifact that survives the conversation.

GitHub Spec-Kit — the open-source canonical

GitHub Spec-Kit is the open-source SDD toolkit GitHub published. As of May 2026: 93,000 stars, v0.8.7 released May 7 2026, and explicit support for 30+ AI coding agents including Claude Code, Cursor, Codex CLI, Gemini CLI, and Aider (github.blog launch post).

Spec-Kit's shape:

  • A standard spec format in Markdown — sections for problem statement, requirements, examples, acceptance criteria.
  • Tooling that reads the spec, generates a task tree, and dispatches tasks to whichever AI coding agent the developer has installed.
  • Hooks for human review at each stage (spec approved → tasks approved → tests approved → implementation accepted).
Best for: teams that want a vendor-neutral SDD workflow that plugs into whatever AI coding tools they already use. The 30+ integrations matter — you don't have to standardize your team on one agent.

AWS Kiro — spec-first IDE with contradiction-proving

AWS Kiro is Amazon's take: a complete spec-first IDE, not a toolkit on top of an existing setup. Released in 2026 with a feature Amazon highlighted called mathematical contradiction proving — Kiro analyzes the spec for logical contradictions before letting the agent generate work products.

Kiro's distinctive shape:

  • Uses EARS notation ("Easy Approach to Requirements Syntax") for unambiguous requirements. EARS gives you a small grammar — "WHEN [trigger] THE SYSTEM SHALL [behavior]" — that's easier for agents to parse than free prose.
  • Bundles its own agent stack rather than integrating with external tools.
  • Targets enterprise SDD use cases where contradiction-detection in specs is a real value (regulated industries, large codebases).
Best for: teams that want a turnkey SDD environment and are willing to standardize on Amazon's tooling. Not best for teams already invested in Claude Code or Cursor.

BMAD-METHOD — multi-agent SDD across the SDLC

BMAD-METHOD ("Breakthrough Method of Agile AI-Driven Development") is the 46,700-star project that takes a different angle: instead of one agent reading the spec, BMAD ships 12 specialized agents covering different roles across the SDLC — product owner, architect, developer, QA, technical writer, and so on.

BMAD's shape:

  • Each agent has a tightly-scoped role and reads/writes specific spec files.
  • The product-owner agent refines the initial spec into structured requirements.
  • The architect agent designs the implementation approach.
  • The developer agents handle the coding work.
  • The QA agent generates tests and edge cases.
  • Coordination happens via shared Markdown files in the repo.
Released v6.6.0 on April 29 2026. Best for: teams that want explicit role separation in agent work, especially across feature-development cycles that involve more than just code (specs, ADRs, docs, tests, deployment notes).

How the three compare

ToolLicenseAudienceDistinctive featureMulti-tool?
Spec-KitOpen-source (GitHub)Vendor-neutral teams30+ AI coding agent integrationsYes
KiroCommercial (AWS)Enterprise, regulated industriesMathematical contradiction proving in specs, EARS notationNo (own IDE)
BMADOpen-sourceTeams that want multi-agent role separation12 specialized SDLC agentsYes
None of these are toys. The star counts (93k for Spec-Kit, 46.7k for BMAD) and Amazon's investment in Kiro reflect real adoption. The choice depends on whether you want to plug SDD into your existing tools (Spec-Kit), adopt a new IDE (Kiro), or restructure your team's workflow around multi-agent roles (BMAD).

Karpathy's framing: why "vibe coding" is being replaced

Karpathy coined "vibe coding" in early 2025 to describe letting AI write code you don't fully read — captured in his Medium post "I ship code I don't read". That style worked for prototypes and personal projects. It hit ceilings on production codebases where consistency across multiple features mattered.

At Sequoia AI Ascent 2026, Karpathy named the shift explicitly: "agentic engineering" replaces "vibe coding," and the central difference is the spec. The spec is the contract between human and agent, the artifact that survives across sessions, and the thing the human is now responsible for getting right.

The cultural framing matters because it changes what developers are paid for. In the vibe-coding era, the developer's value was speed of generation. In the SDD era, the developer's value is the quality of the spec — the structured intent the agent translates into work.

Where this fails / what we don't know

  • SDD adds front-loaded effort. A 30-90 minute spec is more work than a 30-second prompt. For one-off scripts or throwaway prototypes, SDD is overkill and you should just vibe-code it.
  • The contradiction-proving claim in Kiro is unverified. "Mathematically prove that software requirements are free of contradictions" is a strong claim that hasn't been independently demonstrated in published case studies as of this writing.
  • BMAD's 12-agent shape can be heavy. For small teams or solo developers, the role separation creates ceremony without clear payoff. BMAD is best for teams that already work in cross-functional roles.
  • No long-term data on bug rates. SDD proponents claim fewer regressions in production. We don't have public, multi-team longitudinal studies confirming this. The claim is plausible but unproven.

What to read next

Sources

Related GitHub projects

@github

spec-kit

💫 Toolkit to help you get started with Spec-Driven Development

⭐ 97,140

Frequently asked

What is spec-driven development (SDD)?
Spec-driven development is a workflow pattern where the human writes a structured specification first — what to build, what success looks like, what edge cases matter — and then agents generate the task list, the tests, and the implementation from that spec. It's the agentic-engineering counterpart to traditional 'write code first, document later' work, and Andrej Karpathy framed it at Sequoia AI Ascent 2026 as the successor to 'vibe coding.'
How is SDD different from writing a normal feature spec?
A normal feature spec is read by humans who then write code. An SDD spec is also read by an agent that generates the work products directly: tasks broken down, tests written, implementation drafted, then handed back to the human for review. The spec format matters more in SDD because the agent reads it literally. Tools like Kiro use a notation called EARS to make requirements unambiguous; Spec-Kit and BMAD use structured Markdown with explicit acceptance criteria.
Which SDD tool should I install?
If you want open-source and broad agent integration, install GitHub Spec-Kit — 93k stars, v0.8.7 supports 30+ AI coding agents. If you want a complete spec-first IDE with mathematical contradiction checking, evaluate AWS Kiro. If you want multi-agent orchestration across the full SDLC, BMAD-METHOD (46.7k stars) ships 12 specialized agents. The three tools are not interchangeable — they make different tradeoffs.
What is 'vibe coding' and why is it being replaced?
'Vibe coding' is the term Karpathy coined in early 2025 for letting AI write code without fully understanding it — describing it as 'shipping code I don't read.' By 2026, that approach hit ceilings on complex codebases where the agent's lack of structured intent led to inconsistent results. SDD is the structured replacement: same speed, but with a spec the agent and human both refer back to. Karpathy's [Sequoia AI Ascent 2026 keynote](https://karpathy.bearblog.dev/sequoia-ascent-2026/) called this transition explicitly.
Does RuleSell sell spec-driven workflows?
Yes. The spec itself is now a sellable asset — a well-written spec template for, say, 'add Stripe billing to a Next.js SaaS' is something a senior engineer can package, price, and sell. The downstream tasks, tests, and implementation guidance ride along. RuleSell creators publish SDD templates targeting Spec-Kit, Kiro, and BMAD audiences; the same template often works across all three with minor format adaptation.
Does SDD work with Claude Code, Cursor, or other tools?
Yes — SDD is a workflow layer that sits above any agent runtime. Spec-Kit supports 30+ AI coding agents out of the box, including Claude Code, Cursor, Codex CLI, Gemini CLI, and Aider. BMAD's specialized agents are model-agnostic. Kiro is the exception — it's an IDE, so it ships its own agent stack. For Spec-Kit and BMAD, you can run the same spec through any tool in the multi-CLI catalog (see [/topic/cli-everything-wave](/topic/cli-everything-wave)).

Related topics