SPEC KIT · OPENSPEC · BMAD · KIRO
Spec-Driven Development: Vibe Coding Grows Structure
Vibe coding started as a joke about accepting whatever the model produced. In 2026 the ecosystem answered with spec-driven development (SDD): write the spec first, make it executable, and let the agent work from structured intent instead of ad-hoc prompts. Here is how Spec Kit, OpenSpec, BMAD-METHOD, and Kiro work — and where the free VibeFuse harness fits.
What is spec-driven development?
Spec-driven development flips the traditional order of software work. For decades, specs were documents you wrote, half-followed, and discarded once the real coding began. SDD makes the specification executable: it is the artifact the AI coding agent works from, phase by phase, with each step producing a markdown artifact that feeds the next. GitHub describes the core loop as Spec → Plan → Tasks → Implement.
The idea is not new — design docs and RFCs always existed — but 2026 is when it became the default posture for AI-assisted work. GitHub's Spec Kit repository passed 130,000 stars with 270+ contributors, shipped version 1.0.0 on its first birthday (August 21, 2026), and now lists 38 agent integrations from Copilot to Claude Code to Zed. "Spec-driven development" went from a GitHub repo tag to the phrase developers use for the whole discipline.
The why is simple economics. Anthropic's own reporting puts AI usage at 60% of developer work — but the share that can be safely delegated at 0–20%. Gartner expects 40% of new enterprise software to be vibe-coded by 2028. Specs are how that trust gap gets closed: structure the intent, verify the output. The same lesson experienced developers keep repeating — the data structures and architecture matter more than the generated code, because the coding was always the drudge part.
The spec-driven workflow, step by step
| Phase | Command / artifact | What it produces |
|---|---|---|
| 1. Constitution | /speckit.constitution | Project principles and guardrails the agent must respect |
| 2. Specify | /speckit.specify → spec.md | What to build: intent, requirements, acceptance criteria |
| 3. Plan | /speckit.plan → plan.md | Technical approach, stack choices, structure |
| 4. Tasks | /speckit.tasks → tasks.md | Ordered, reviewable work breakdown |
| 5. Implement | /speckit.implement | Code generated against the plan and tasks, not vibes |
| 6. Converge | /speckit.converge | Validation that implementation matches spec artifacts |
Each phase emits a markdown artifact that feeds the next. OpenSpec keeps change proposals and specs next to the code; BMAD-METHOD assigns agent roles across the lifecycle; extensions add V-model traceability, quality gates, or even non-software processes.
Vibe coding vs. spec-driven development
They are not rivals — SDD is what serious vibe coding turned into. Karpathy's original "vibe coding" described giving in to the vibes and forgetting the code exists. The tools that took off in 2026 are the ones that added structure back. Same models, same agents, different input contract.
| Dimension | Prompt-only vibe coding | Spec-driven development |
|---|---|---|
| Input | One-off chat prompts, iterated until it looks right | Executable spec with acceptance criteria |
| Context | Whatever fits the chat window this session | Versioned artifacts: constitution, spec, plan, tasks |
| Change control | Re-prompt and hope nothing else regresses | Change proposals; specs updated deliberately |
| Team fit | Solo, prototype, throwaway | Reviewable, branchable, enterprise-friendly |
| Failure mode | Silent drift, mystery regressions | Converge step flags spec/implementation gaps |
| Free cost | Metered by the tool's free tier | Spec Kit is MIT-licensed; the agent runtime is your only cost |
The 2026 spec-driven toolkit
GitHub Spec Kit — the workflow engine
MIT-licensed, 130K+ stars, 38 integrations, 157 community extensions. Install with uv tool install specify-cli, init a project, and your agent gets /speckit.* slash commands. Works with Copilot, Claude, Codex, Gemini, Zed, and more — no lock-in.
OpenSpec — specs that live with code
Keeps change proposals and specifications in the repository next to the implementation, so brownfield work has a spec trail instead of tribal chat history.
BMAD-METHOD — role-based agents
Assigns agent roles across the whole lifecycle — planning, dev, QA — turning a single chat agent into a tiny structured team.
Superpowers & Kiro — packaged process
Superpowers bundles brainstorming, TDD, and review as reusable skills for Claude Code, Cursor, and Codex. AWS's Kiro makes spec-first the IDE's native model.
Where the harness fits
Specs tell the agent what to build. The harness decides where the agent runs, what it can touch, and who reviews the result. Spec Kit is explicitly an "intent-driven harness" — but it still needs a runtime around your CLIs: a place to run Claude Code, Codex, and Gemini side by side, keep sessions named and resumable, and hold your spec artifacts where the agents can see them.
That runtime is VibeFuse — the first ever free widget-based AI harness. Run spec-driven sessions as widgets on one Windows canvas: your spec files and AGENTS.md stay in the project, each agent works in a named session, and local voice control keeps your hands on the review, not the keyboard. Skills are SKILL.md folders the same format Claude and Codex already read — which is also where the open-source marketplace comes in: publish and sell your spec templates, workflow presets, and review skills, with 80% payouts to creators.
Everything processes locally and offline where possible — your specs and code never have to leave the machine, and works in any app you already use.
Start spec-driven in ten minutes
1. Install Spec Kit
uv tool install specify-cli then specify init my-project --integration claude. Swap the integration flag for your agent — there are 38.
2. Write the constitution once
/speckit.constitution captures the project's principles: stack, testing rules, review gates. This is the guardrail every later phase inherits.
3. Specify → Plan → Tasks → Implement
Run the phases in order. Read each artifact before moving on — the review IS the quality control.
4. Run it inside a harness
Point VibeFuse at the project and run each phase as a widget session — or grab community workflow presets from the marketplace.
- ✓ Multi-agent canvas
- ✓ Runs Claude Code + Codex + Gemini
- ✓ Named resumable sessions
- ✓ Local Whisper + Piper
- ✓ 80% creator payouts
Explore VibeFuse & harness guides
- Harness Guide
- Free Coding Tools
- AI Coding Agent Desktop
- Free Voice Transcription
- Free Text to Speech
- VibeFuse Product
- Widget Marketplace
- Download Free
- VibeFuse Docs
- Shareable AI Widgets
- Shareable AI Skills
- MCP Tools
- AI Agent Harness
- Harness Engineering
- HyperFrames Video
- Skill Seekers
- Sell AI Skills
- AI Skills Marketplace Compared
- Cursor Alternative
- Local Whisper + Piper
- Custom AI Dashboard
- Community Hub
Spec-driven development FAQ
What is spec-driven development?
Spec-driven development (SDD) is a workflow where you write an executable specification before generating code. Instead of prompting an AI coding agent ad hoc, each phase — constitution, specify, plan, tasks, implement, converge — produces a markdown artifact that feeds the next. GitHub describes the core loop as Spec → Plan → Tasks → Implement. The spec becomes the source of intent the agent works from, which makes review and change control possible.
What is GitHub Spec Kit?
Spec Kit is GitHub's open-source, MIT-licensed toolkit for spec-driven development with any AI coding agent. It passed 130,000 stars with 270+ contributors, shipped 1.0.0 on August 21, 2026, and supports 38 agent integrations including Copilot, Claude Code, Codex, Gemini, and Zed. Install with uv tool install specify-cli, run specify init in a project, and your agent gets /speckit.* slash commands for each phase.
Is spec-driven development replacing vibe coding?
It is more accurate to say spec-driven development is what serious vibe coding turned into. Vibe coding described accepting whatever the model produced; the 2026 tooling that took off — Spec Kit, OpenSpec, BMAD-METHOD, Superpowers, Kiro — adds structure back: specs, plans, task lists, and verification gates. Same models and agents, a different input contract. Prompt-only sessions still make sense for prototypes and throwaway tools.
What is the difference between Spec Kit and OpenSpec?
Spec Kit gives you a full phased workflow (constitution → specify → plan → tasks → implement → converge) with slash commands injected into your agent of choice. OpenSpec focuses on keeping change proposals and specifications as files that live next to the code, so ongoing brownfield work has a durable spec trail. Teams often use Spec Kit's process with OpenSpec-style storage discipline.
Does spec-driven development work with Claude Code and Codex?
Yes — that is the point of the integration model. Spec Kit supports 38 agents, and most expose the workflow as slash commands (/speckit.* for Claude Code, Codex CLI, Copilot CLI, Gemini CLI, Zed, and more). Skills-mode integrations install agent skills instead of command files. The spec artifacts are plain markdown, so any harness or editor can read them.
How do I run spec-driven development for free?
Spec Kit itself is free and MIT-licensed; OpenSpec and BMAD-METHOD are open source too. The cost sits in the agent runtime — and a free harness removes that too: VibeFuse is the first ever free widget-based AI harness, runs Claude Code, Codex, and Gemini CLI side by side on one Windows canvas with named sessions and local voice control, and its open-source marketplace lets you sell spec templates and workflow presets with 80% payouts to creators.