A structural issue has arisen as AI agents become more powerful: the need for speed, but not clarity. The developers generate code within minutes only to find out days later it does not match the requirements of the system. Spec-driven development (SDD) addresses this directly — by treating a structured specification as the source of truth and code as its generated output, rather than the other way around.
The list below contains the nine AI tools used by developers to create SDD in 2026.
AWS Kiro
Kiro, an agentic IDE, is built on spec-driven design. It’s designed to help developers move from conception to production using structured rigor rather than iterative guidance. Kiro forces developers to define their intentions before they can ask for AI assistance. It guides them through a three-phase process — Requirements, Design, and Tasks — producing three structured artifacts: requirements.md, design.md, and tasks.md. A noteworthy technical detail is that Kiro produces user stories with EARS (Easy Approach for Requirements Syntax), resulting in structured acceptance criteria. Developers would have to manually handle edge cases.
A major differentiator is its agent hooks system — event-driven automations that fire when files are saved or created, handling tasks like test updates, README refreshes, and security scans without manual prompting. For model selection, Kiro’s default is an Auto router that combines multiple frontier models — including Claude Sonnet, Qwen, DeepSeek, GLM, and MiniMax — and selects the optimal model per task to balance quality and cost. The model can be pinned by developers to ensure consistency. VS Code’s code OSS base will make it easy for users to adapt. Kiro has a CLI, a web interface and is not AWS-required. This is the best option for teams looking to create formal specifications in a familiar environment.
GitHub Spec Kit
🔗 github.com/github/spec-kit | Blog Post
GitHub Spec Kit is the most community-adopted open-source option for spec-driven development — a Python CLI with 93,000+ stars, the latest release being v0.8.7 (May 7, 2026), supporting 30+ AI coding agents including Claude Code, GitHub Copilot, Amazon Q, and Gemini CLI. It is structured in four phases that have clear checkpoints. Specify captures business context, Plan translates specs into architectural choices, Tasks decomposes the plans into testable and reviewable units and finally Implement runs AI agents within those constraints.
The foundation for every Spec Kit is a “constitution” — a markdown rules file containing high-level immutable principles that apply to every change across every session. The contract is then established between developer and agent. Spec Kit, according to GitHub, has a philosophy that states code is no longer the final output, but rather intent and specifications. This is the starting point of choice for new teams to SDD, and it’s also the best option for those teams who want to use their current IDE.
BMAD-METHOD
🔗 github.com/bmad-code-org/BMAD-METHOD | Docs
BMAD (Build more Architect Dreams), a licensed open-source project, is a framework for orchestrating 12+ specialized AI Agents across the entire software development lifecycle. Version 6.6.0 will be released in 2026. It has already received 46,700+ GitHub’stars’ and is a fork of more than 5,500. The 12+ agents cover distinct SDLC roles — including product management, architecture, UX, development, QA, and scrum master functions — and work together through structured, file-based handoffs: each agent reads the previous agent’s output document and writes its own, maintaining a traceable chain from requirements through delivery.
V6 introduces the Cross Platform Agent Team. This allows the same configuration of an agent to be used across Claude Code (the universal human-AI collaboration framework), Cursor (the agile development module built on Core), and Codex without any reconfiguration. V6’s architecture separates the concerns in three layers, BMad Core and BMad Method. The latter is an agile module built upon Core. BMad Builder allows teams to create custom workflows and agents. BMAD provides highly-structured, multi-agent workflows that are role-separated without vendor-lock-in. This framework is completely free and has no paywalls.
The Augment Code
Augment Code is spec-driven from the context layer, not the specification layer. Its Context Engine maintains a persistent architectural understanding across 400,000+ files — addressing the cross-repository context gap that breaks most specification workflows at scale, particularly in multi-service brownfield codebases. In comparison to the industry average, Augment achieved 70.6% SWE Bench (versus a score of 54%) and 59% F on an AI Code Review benchmark. Please note that these are vendor reported figures and they should be treated appropriately.
The BYOA model (Bring Your Own Agent), allows teams to plug-in Claude Code or Codex alongside the native Auggie agent. Augment Code does not author specs natively — teams still need a tool like Spec Kit or Kiro for structured spec management — but it provides the semantic foundation that makes those specs accurate across large codebases. This tool is ideal for teams who are running multi-service enterprise architectures, where context drift rather than spec creation is the major failure mode.
Claude Code
🔗 claude.ai/code | Docs
Claude Code is Anthropic’s agentic command-line tool, and unlike tools such as Cursor or GitHub Copilot that augment a developer’s workflow, it is designed for fully autonomous development — planning, orchestrating multi-step workflows, and asking follow-up questions without constant prompting. Claude Code is a great tool for spec-driven work flows. It can handle large documents in a single session and generate implementations with complete requirements sets.
Developers typically use CLAUDE.md files as the spec layer — a lightweight approach that enforces persistent project context, coding standards, and architectural constraints across every session. As a result, many developers use Claude Code as a SDD framework without formally referring to it. Claude Code serves as a widely supported execution agent in SDD Frameworks, including BMAD GSD, GitHub Spec Kit, and GSD.
The GSD acronym stands for Get the Job Done.
🔗 github.com/gsd-build/get-shit-done
GSD is a spec based meta-prompting, context engineering and agent-specific framework. GSD positions itself to be BMAD’s low-frills, lean alternative. The project has crossed 61,000 GitHub stars — growing from zero to that figure in under five months since its December 2025 initial commit. The project installs using npx get-shit-done-cc@latest This works with Claude Code (OpenCode), Gemini CLI (Codex), Copilot, Cursor Windsurf Augment and Cline.
The multi-agent orchestration creates parallel researchers and planners who operate in separate context windows, with 200K tokens each dedicated to the implementation. The model-agnostic design — including support for OpenRouter and local models — decouples the workflow from any single LLM vendor. GSD, unlike BMAD which adds stakeholder and sprint coordination as well as ceremonies, believes complexity belongs in the system itself, not within the workflow. The GSD also covers a number of gaps that Claude Code does not cover: quality gates, context rotation and persistent planning states across sessions.
Use the Cursor with Plan Mode and Project Rules
🔗 cursor.com | Agent Best Practices
Cursor continues to be one of most popular AI editors. Plan Mode is a great way for teams who want to start adopting the spec first approach without changing toolchains. Plan Mode creates a detailed implementation plan before any code is written — asking clarifying questions, mapping affected files, and generating a reviewable plan that the developer approves before the agent acts. It prevents the premature generation of code for features that require multiple files and architectural decisions.
Cursor currently uses Project Rules to provide a consistent spec-like environment. .cursor/rules/ The older .cursorrules The conventions are now considered outdated). Cursor, when combined with project-rules, supports a lightweight and portable specification workflow for large to medium greenfield features. The tradeoff is that Cursor’s spec support is not native to its architecture the way Kiro’s is — there is no built-in spec lifecycle, drift detection, or living-spec synchronization. Cursor Plan Mode provides a middle-ground for teams looking to structure AI development in an intuitive, high-quality editor, without having full SDD overhead.
OpenSpec
🔗 github.com/Fission-AI/OpenSpec
OpenSpec is aimed at a very specific use case that has not been adequately addressed: Teams who require explicit and auditable documentation prior to any implementation. It uses a proposal-centered workflow with structured artifacts for changes, and specifically addresses brownfield iteration with delta markers (ADDED/MODIFIED/REMOVED) that track what changes relative to existing functionality rather than greenfield descriptions. Importantly, OpenSpec’s own documentation positions it as lightweight and flexible rather than a rigid phase-gated system — it provides structure without enforcing hard approval gates between phases.
In a February 2026 independent evaluation run across 13 scoring categories on a medium-sized serverless Python backend, OpenSpec scored highest overall — though that ranking shifts significantly with different priorities. OpenSpec is best suited for teams that prioritize documentation, change tracking and accountability over living-spec sync. OpenSpec is recommended for larger, multi-service projects, as its proposal-based format can produce static documents which may drift over time.
Tessl
🔗 tessl.io | Spec Registry | Docs
Tessl is an agent enablement system built around two different products. Tessl is installed as “tiles” into a project’s .tessl/ directory and teaches any MCP-compatible agent — including Claude Code, Cursor, and others — to follow a spec-driven workflow regardless of stack: agents ask clarifying questions first, write structured specification documents, wait for developer approval, then implement. The spec files are stored in the codebase, which acts as a long-term storage. This allows the agent to develop the application over time and provide an audit trail.
Tessl Spec Registry, the most distinct feature of the platform is its open registry with over 10,000 specifications that describe how to use open-source external libraries correctly. This directly targets the API confusions and versions mix-ups which agents often produce in codebases. Think of it as npm for specifications — teams install both a methodology tile (how to work) and library tiles (what tools to use correctly) to prevent both process chaos and documentation hallucination. The two-layer architecture — process context plus library context — is Tessl’s core insight: structured workflow alone isn’t enough if the agent still hallucinates the APIs it’s building with.
Follow us to stay updated Twitter Join our Facebook group! 150k+ ML SubReddit Subscribe Now our Newsletter. Wait! What? now you can join us on telegram as well.
Want to promote your GitHub repo, Hugging Face page, Product release or Webinar?? Connect with us
