As AI cryptographic agents become more powerful, a structural problem has emerged: speed without clarity. Developers create working code in minutes, only to discover days later that it doesn’t match what the system actually needs. Specification-driven development (SDD) addresses this directly – by treating structured specifications as a source of truth and code as generated output, rather than the other way around.
This list covers the nine AI tools that developers are actually using to implement SDD workflows in 2026.
Os Kiro
🔗 kiro.dev | Documents | Models
Kiro is a proxy integrated development environment (IDE) built on specification-driven development, designed to move developers from concept to production with structured precision rather than iterative demandingness. Instead of writing code and asking AI for help along the way, Kiro asks developers to formalize the intent first. It guides them through a three-stage process-requirements, design, and tasks-to produce three structured elements: requirements.md, design.md, and tasks.md. Notable technical details: Kiro creates user stories using EARS (Easy Approach to Requirements Syntax) notation, which produces structured acceptance criteria covering edge cases that developers might handle manually.
The main difference is its agent binding system – event-based automations that are triggered when files are saved or created, handling tasks like test updates, README file updates, and security scans without manual prompting. As for model selection, Kiro’s default is an autorouter that combines several leading models – including Claude Sonnet, Qwen, DeepSeek, GLM and MiniMax – and selects the optimal model for each task to balance quality and cost. Developers can also install a specific model for consistent behavior. Because it’s built on Code OSS, VS Code users will feel at home right away. Kiro also supports CLI and web interface, and does not require an AWS account. Best for teams that need formal workflows in a familiar development environment.
Github specification set
🔗 github.com/github/spec-kit | Blog post
GitHub Spec Kit is the most community-adopted open source option for spec-driven development – Python CLI with over 93,000 stars, latest version is v0.8.7 (May 7, 2026), and supports 30+ AI coding agents including Claude Code, GitHub Copilot, Amazon Q, and Gemini CLI. The workflow passes through four phases with clear checkpoints: Define (captures the business context and success criteria), Plan (translates specifications into architectural decisions), Task (decomposes plans into testable and reviewable units), and Execute (runs AI agents under those constraints).
At the foundation of every Spec Kit workflow is a “constitution” – a markdown rules file that contains high-level, immutable principles that apply to every change across every session. This becomes an ongoing contract between the developer and the agent. The Spec Kit philosophy, as laid out by GitHub, is that the code is now the last-mile deliverable: intent is the source of truth, and the spec is executable. It’s the default starting point for teams new to SDD and the most portable option for teams that want to keep their existing IDE.
BMAD method
🔗 github.com/bmad-code-org/BMAD-METHOD | Documents
BMAD-METHOD (Build More Architect Dreams) is an MIT-licensed open source framework that orchestrates more than 12 AI agents across the full software development lifecycle. Version 6.6.0 shipped on April 29, 2026, with the project reaching 46,700+ GitHub stars and over 5,500 forks. More than 12 agents cover distinct SDLC roles – including product management, architecture, UX, development, QA, and key scrum functions – and work together through structured, file-based deliverables: each document agent reads the previous agent’s deliverables and writes its own document, maintaining a traceable chain of requirements through delivery.
V6 introduced Cross Platform Agent Teaming, allowing the same agent configuration to run across Claude Code, Cursor, Codex, and other hosts without reconfiguration. The V6 architecture also separates concerns into three layers: BMad Core (the global human-AI collaboration framework), BMad Method (the agile development module built on top of the Core), and BMad Builder (which lets teams create and share custom agents and workflows). BMAD is the optimal framework for teams that want a highly structured, role-segregated multi-agent workflow without vendor lock-in. The framework is completely free and has no paywall.
Boost code
🔗 augmentcode.com | SDD Manual
Augmented code approaches specification-driven development from the context layer rather than the specification authoring layer. Its context engine maintains persistent architectural understanding across more than 400,000 files – addressing the context gap across repositories that breaks most large-scale specification workflows, particularly in multi-service field codebases. Augment scored 70.6% on the SWE bench (compared to the industry average of 54%) and an F grade of 59% on the AI code review benchmark; These numbers are reported by the seller and should be treated accordingly.
The BYOA (Bring Your Own Agent) model allows teams to connect Claude Code, Codex, or OpenCode alongside a native Auggie agent. Augment Code doesn’t author the specifications locally – teams still need a tool like Spec Kit or Kiro to manage structured specifications – but it provides the semantic foundation that makes those specifications accurate across large codebases. Best suited for enterprise teams using complex multi-service architectures where context deviation, not specification generation, is the primary failure mode.
Claude Code
🔗 claude.ai/code | Documents
Claude Code is a proxy command-line tool from Anthropic, and unlike tools like Cursor or GitHub Copilot that augment developer workflows, it’s designed for completely autonomous development – planning and organizing multi-step workflows and asking follow-up questions without constant prompting. For a specification-driven workflow, Claude Code handles large specification documents well within a single session, processing complete requirements sets and generating implementations in one cohesive pipeline.
Developers typically use CLAUDE.md files as the specification layer-a lightweight approach that enforces persistent project context, coding standards, and architectural constraints across each session. This means that many developers are already practicing some form of SDD with Claude Code without officially classifying it as such. Claude Code also acts as an execution agent that is generally supported across SDD frameworks including BMAD, GSD, and GitHub Spec Kit.
GSD (it’s over)
🔗 github.com/gsd-build/get-shit-done
GSD is a specification-based context and meta-claims engineering framework designed primarily for Claude Code and corresponding agents, positioning itself as a simple, low-festival alternative to BMAD. The project has surpassed 61,000 stars on GitHub – rising from zero to that number in less than five months since the initial commit in December 2025. Install via npx get-shit-done-cc@latest It works across Claude Code, OpenCode, Gemini CLI, Codex, Copilot, Cursor, Windsurf, Augment, and Cline.
Its multi-agent format gives rise to parallel researchers, planners, implementers, and verifiers, each operating in a new context window with up to 200,000 tokens allocated for execution. Form-agnostic design – including support for OpenRouter and native forms – separates the workflow from any single LLM resource. Where BMAD adds sprint celebrations and coordination between stakeholders, the GSD philosophy is that complexity should lie in the system, not in the workflow. It also fills a gap that CloudCode itself doesn’t cover natively: context rotation, quality gates, and persistence of mapping state across sessions.
Indicator (with plan established + project rules)
🔗 cursor.com | Agent best practices
Cursor remains one of the most widely used AI editors, and its plan mode makes it a practical entry point for teams adopting spec-first habits without switching toolchains. Plan mode creates a detailed execution plan before any code is written – asking clarifying questions, mapping affected files, and creating a reviewable plan that the developer agrees to before the agent acts. This prevents premature code generation for features that touch multiple files or require architectural decisions.
For continuous, specification-like context, Cursor’s existing rules system uses the project rules stored within .cursor/rules/ (Oldest .cursorrules The agreement is now considered heritage.) When combined with Project Rules, Cursor supports a lightweight and portable specification workflow for medium and large greenfield features. The trade-off is that Cursor spec support is not as native in its architecture as it is in Kiro – there is no built-in spec lifecycle, drift detection, or live spec synchronization. For teams that want structured AI development within a familiar, high-quality editor without loading a full SDD, Cursor with Plan Mode is a capable compromise.
Open specifications
🔗 github.com/Fission-AI/OpenSpec
OpenSpec targets a specific underserved use case: teams where change management requires clear, auditable documentation before any implementation can begin. It uses a proposal-focused workflow with structured elements for changes, and specifically addresses duplication of brown fields with delta (added/modified/removed) tags that track changes related to existing functionality rather than green field descriptions. Importantly, OpenSpec’s own documentation positions it as a lightweight and flexible system rather than a rigid phase-gated system – it provides architecture without imposing strict approval gates between phases.
In an independent evaluation conducted in February 2026 across 13 scoring categories on a medium-sized serverless Python backend, OpenSpec scored top overall – although this ranking changes widely with different priorities. Teams whose accountability and documentation paths outperform live specification synchronization will find it a better fit. For larger multi-service initiatives, it is recommended to pair OpenSpec with a live specification platform, since its proposal-based structure produces static documents that can drift during extended implementation.
Tessel
🔗 tessl.io | Record specifications | Documents
Tessl is a language-agnostic agent enablement platform built on two distinct products. The Tessl Framework is installed as “tiles” in the project .tessl/ The guide teaches any MCP-compliant agent-including Claude Code, Cursor, and others-to follow a spec-driven workflow regardless of stack: Agents first ask clarifying questions, write structured spec documents, wait for developer approval, and then execute. The specifications live in the code base as long-term memory, giving decisions an audit trail and allowing the agent to evolve the application coherently over time.
The Tessl Spec Registry is the platform’s clearest distinction: an open registry of over 10,000 specifications that describe how to properly use external open source libraries, and directly target API hallucinations and the mixing of versions frequently produced by proxies into production code bases. Think of it as npm for specifications – teams install both the methodology framework (how it works) and the library frameworks (which tools to use correctly) to prevent process chaos and documentation hallucinations. The two-layer architecture – process context plus library context – is Tessl’s core vision: structured workflow alone is not enough if the agent is still hallucinating the APIs it builds.
Feel free to follow us twitter Don’t forget to join us 150k+ mil SubReddit And subscribe to Our newsletter. I am waiting! Are you on telegram? Now you can join us on Telegram too.
Do you need to partner with us to promote your GitHub Repo page, face hug page, product release, webinar, etc.? Contact us
