Spec Kit: GitHub's answer to vibe-coding — specs your agent can execute

At a glance

The repo is actively maintained by GitHub itself — 1,700+ commits and a steady release cadence — and explicitly supports both greenfield (zero-to-one builds) and brownfield work (adding features to or modernizing an existing codebase). That second case is the one most "AI project generators" quietly ignore.

How the workflow works

Once initialized, your agent gains a family of /speckit.* commands that you run in order:

1. /speckit.constitution — establish the project's non-negotiable principles once (code quality bars, testing standards, performance targets)
2. /speckit.specify — describe what you're building and why: requirements and user stories, deliberately free of tech-stack decisions
3. /speckit.plan — now bring the stack: architecture, frameworks, and constraints turn the spec into a technical plan
4. /speckit.tasks — decompose the plan into an actionable, reviewable task list
5. /speckit.implement — the agent executes the tasks against the spec, plan, and constitution

Three optional passes tighten the loop when the stakes are higher: /speckit.clarify interrogates underspecified requirements before planning, /speckit.analyze checks cross-artifact consistency before implementation, and /speckit.checklist generates custom quality gates.

The separation between step 2 and step 3 is the whole trick. Because the spec is stack-agnostic, you can hand the same spec a different plan — swap Flask for Next.js, try a parallel implementation — without rewriting the requirements. The spec outlives any single implementation attempt.

Installation

You need Python 3.11+, Git, and uv (or pipx). Then:

uv tool install specify-cli

Then initialize a project — new directory or the repo you're already in — and tell it which agent you use:

specify init my-project --integration claude
# or: copilot, cursor, gemini, codex, windsurf, roocode …
specify integration list      # see all 30+ supported agents

Init drops the /speckit.* command files in the right place for your agent (.claude/commands/ for Claude Code) plus the templates and scripts the workflow uses. From there everything happens inside your normal agent session.

Using it day to day

A realistic session for a real feature looks like: /speckit.specify with two paragraphs about the user problem, a read-through of the generated spec (this is where you edit — it's Markdown, not magic), /speckit.clarify if the agent flagged open questions, then plan → tasks → implement. The artifacts live in your repo, so the spec review can happen in a pull request like any other code review.

Where it earns its overhead is anything beyond a small feature: multi-day builds, features touching several subsystems, or work you'll hand between agents or teammates. The spec becomes the shared source of truth instead of a chat scrollback nobody can replay.

Pricing

Entirely free and MIT-licensed — no hosted service, no paid tier, no account. The only cost is the token usage of whichever coding agent executes the workflow, and the structured process arguably reduces that by cutting failed attempts and rework.

My take

Spec Kit is the most credible answer I've seen to the real failure mode of agentic coding: not bad code, but code that solves the wrong problem because the requirements only ever existed in your head. Forcing the "what and why" onto disk before any stack talk catches misunderstandings when they cost minutes, not days. And because it's from GitHub with 30+ agent integrations, it isn't a bet on any one assistant.

The honest caveat: for small, well-understood changes the ceremony is overhead — a bug fix does not need a constitution. It also pairs naturally with Superpowers, which governs how the agent works task-to-task while Spec Kit governs what gets built. I reach for Spec Kit at the "this would take me more than a day" threshold and skip it below that.

Frequently asked questions