The full structured workflow — from installing the toolkit to building your first feature end-to-end.
SDD is a methodology created specifically for working with AI coding tools. Instead of just typing
“build me a thing” and hoping for the best, you go through a structured process that produces
dramatically better results. Think of it like the difference between telling a contractor “build me a house”
vs. giving them blueprints, a materials list, and an inspection checklist.
Learn more:
Spec-Driven Development Guide ·
GitHub Spec Kit
Step 1: Install the Prerequisites
You need two tools: uv (a Python package manager) and spec-kit itself.
Install uv:
Windows (PowerShell):
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
Mac:
curl -LsSf https://astral.sh/uv/install.sh | sh
Close and reopen your terminal after installing uv.
Install Spec Kit:
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git
Verify it worked:
specify --help
Step 2: Initialize Your Project
Navigate to where you want your project (create the folder first if it doesn’t exist), then run the init command:
Windows:
mkdir $HOME\projects
cd $HOME\projects
specify init aviation-platform --ai claude
Mac:
mkdir -p ~/projects
cd ~/projects
specify init aviation-platform --ai claude
If the projects folder already exists, that’s fine — mkdir will just tell you it already exists. No harm done.
This creates a project folder with the SDD structure:
aviation-platform/
.specify/ ← SDD toolkit (templates, scripts, config)
memory/ ← Constitution and project memory
templates/ ← Templates for specs, plans, tasks
scripts/ ← Automation scripts
CLAUDE.md ← Instructions Claude Code reads automatically
specs/ ← Where your feature specs will live
If you already have a project folder with data in it, init in place:
Windows:
cd $HOME\projects\aviation-platform
specify init . --ai claude
Mac:
cd ~/projects/aviation-platform
specify init . --ai claude
Step 3: Start Claude Code (Must Be in the Project Directory)
This is critical: Claude Code reads the project configuration when it starts.
The SDD commands only work when Claude Code is launched from inside a project that has the .specify/ folder.
Windows:
cd $HOME\projects\aviation-platform
claude
Mac:
cd ~/projects/aviation-platform
claude
If the /speckit.* commands don’t work: type pwd to check you’re in the right directory.
On Windows you should see something like C:\Users\Gus\projects\aviation-platform.
On Mac it would be /Users/gus/projects/aviation-platform.
If you’re somewhere else, type /exit, navigate to your project, and start claude again.
Step 4: Set Your Constitution
The constitution defines the non-negotiable principles for your project — the rules that every feature,
plan, and piece of code must follow. Think of it like a company’s operating agreement: it establishes
the ground rules before any work begins.
/speckit.constitution
Claude will ask you about your project’s core principles. For your aviation platform, you might establish:
- Data accuracy is non-negotiable — An incorrect quote is worse than a slow quote
- Human review before customer-facing output — AI drafts, human approves
- Security first — Customer data, pricing, inventory levels are confidential
- Aviation compliance — FAA 8130-3 documentation requirements must be respected
- Small operator focus — Design for 5-50 employee shops, not enterprise
The constitution gets saved to .specify/memory/constitution.md and Claude Code references
it for every future feature. Without it, different features might make conflicting assumptions.
Step 5: Your First Feature — The Full Workflow
/speckit.specify — Define What You Want
/speckit.specify "Build an RFQ email parser that reads inbound
request-for-quote emails, extracts part numbers, quantities, condition
codes, aircraft types, customer info, and urgency level (standard vs AOG).
Cross-reference extracted parts against our inventory CSV and produce a
summary showing what we have, what we don't, and flag all AOG requests
as critical priority."
Write this like a scope of work. Focus on what you want and why, not how to build it.
Claude produces a formal specification document saved to your specs/ folder.
/speckit.clarify — Fill in the Gaps
/speckit.clarify
Claude reads the spec and identifies up to 3 ambiguities. It asks focused questions like:
“Should the parser handle multi-line RFQs where one email requests 15 parts?”
or “What email format do RFQs come in — structured forms, freeform text, or a mix?”
Claude recommends an answer based on best practices — you can just say “yes” to accept.
Your answers get written back into the spec.
/speckit.plan — Design the Approach
/speckit.plan
Claude switches from “what” to “how.” It researches the best tools, designs the architecture,
defines the data model, and creates interface contracts.
Pro tip: Before running this, tell Claude: “Before you plan, research the current state of
aviation aftermarket email parsing tools and how companies like ePlaneAI and Rotabull handle this.”
This makes the plan dramatically better.
Review the plan. This is your chance to say “actually, use this approach instead” before any code is written.
It’s much cheaper to change a plan than to rewrite code.
/speckit.tasks — Break It into Steps
/speckit.tasks
Claude takes the plan and creates an ordered checklist: setup first, then core features, then polish.
Each task specifies what to build, which file to modify, and dependencies.
This is your last checkpoint before implementation starts.
/speckit.analyze — Quality Check (Optional)
/speckit.analyze
Cross-checks your spec, plan, and tasks for consistency. Catches requirements with no tasks,
tasks referencing undefined components, terminology drift, and constitution violations.
If there are critical issues, fix them before implementing.
/speckit.implement — Build It
/speckit.implement
Claude works through the tasks one by one. It creates the project structure, builds each component,
runs tests, fixes its own errors, and checks in with you at each phase. When it’s done,
you have a working feature.
The Full Flow at a Glance
cd $HOME\projects\aviation-platform # Navigate to your project (Windows)
cd ~/projects/aviation-platform # Navigate to your project (Mac)
claude # Start Claude Code
/speckit.constitution # Set project principles (one-time)
/speckit.specify "description..." # What do you want?
/speckit.clarify # Fill in gaps
/speckit.plan # How should we build it?
/speckit.tasks # Break it into steps
/speckit.analyze # Quality check (optional)
/speckit.implement # Build it
For your first feature, go through all the steps. For subsequent features, skip the constitution
(it’s already set) and repeat specify → clarify → plan → tasks → implement.
Why This Works Better Than Just Asking
You could skip all of this and just tell Claude Code “build me an email parser.” And it would build something.
But without the structured process, it guesses at requirements, picks tools without researching alternatives,
misses edge cases, and produces no documentation.
The SDD process takes maybe 15-20 extra minutes upfront. But it saves hours of rework, produces better results,
and creates documentation that makes every future feature easier.
You already know this instinctively from running logistics operations —
preparation saves time, documentation prevents errors, and structured processes beat ad-hoc firefighting every time.