Unlocking AI-Native Development: Spec Driven Development for Dummies

 

In the fast-evolving world of AI-assisted coding, a new approach is emerging that flips traditional development on its head: Spec-Driven Development (SDD). Rather than treating specifications as mere documentation, SDD makes them executable artifacts that directly drive code generation. The open-source repository (https://github.com/SpillwaveSolutions/sdd-skill) brings this methodology to life as a powerful agent skill for AI coding tools like Claude Code, GitHub Copilot, Cursor, and more. It does with the the Easy Button approach.

Created by Spillwave Solutions and built on GitHub’s Spec-Kit, this skill (version 2.1.0) transforms how developers interact with AI agents. Instead of vague prompts leading to unpredictable results, users guide projects through structured, traceable workflows using natural language and slash commands.

It builds on the shoulder of giants by building on top of GitHub Spec Driven Development, but uses agent skills to automate the process. You don’t have to be an expert on SDD to get started. The agent skill walks you through it.

If you have been procrastination trying SDD, then this agent skill might just be for you.

What Makes SDD-Skill Special?

The skill excels at two core scenarios:

• Greenfield projects → building brand-new applications from scratch.
• Brownfield projects → adding features to or modernizing existing codebases.

Key standout features include:

• Transparent 10-point summaries after every major command, explaining decisions, generated artifacts, review items, risks, and next steps.
• Automatic feature status tracking with progress percentages (20% Specified → 40% Planned → 60% Tasked → 80% In Progress → 100% Complete).
• Dependency visualization and blocker detection.
• Natural language feature management — add, reorder, remove, or query features with simple phrases like “Add email notifications” or “What’s blocking the admin dashboard?”

These capabilities eliminate the “black box” feel of AI coding and give developers full visibility and control.

How It Works: The Workflows

Greenfield (New Projects)

A clean six-step process:

1. Initialize the project with specify init.
2. Define principles via /speckit.constitution.
3. Specify requirements with /speckit.specify.
4. Create a technical plan using /speckit.plan.
5. Break into tasks via /speckit.tasks.
6. Implement with /speckit.implement.

Optional quality commands like /speckit.clarify, /speckit.analyze, and /speckit.checklist ensure robustness.

Brownfield (Existing Codebases)

A thoughtful seven-step approach for legacy systems:

1. Analyze the codebase with /speckit.brownfield.
2. Initialize SDD in the existing directory.
3. Generate a constitution reflecting current patterns via /speckit.analyze-codebase.
4. Choose a reverse-engineering strategy (constitution-only to full artifact suite).
5. Optionally document existing features.
6. Specify the new feature.
7. Implement with integration-aware planning.

Validation commands help verify that reverse-engineered specs match reality.

Natural Language Superpowers

One of the skill’s most impressive aspects is how effortlessly it handles multi-feature projects. Users can say things like:

• “Move user-notifications before profile-management”
• “Show me all features”
• “What depends on user-authentication?”

The agent responds with clear dashboards, dependency trees, and progress bars, keeping everyone aligned without manual tracking.

Getting Started

Installation is straightforward thanks to the uv tool and the agent skill can do the install for you:

uv tool install specify-cli — from git+https://github.com/github/spec-kit.git

The agent skill does the setup for you and if you deviate from the spec driven process, the skill helps you true up the specs. This gives you more flexibility while maintaining a lot of rigor.

The skill will initialize a project and start chatting with your AI agent. The skill activates on triggers like “spec-driven development,” “sdd,” or slash commands such as /speckit.

Why It Matters

SDD-Skill represents a shift toward truly AI-native development. By making specifications executable and giving AI agents structured guidance, it delivers more predictable, maintainable, and high-quality code; whether starting fresh or evolving legacy systems.

If you’re tired of one-shot prompts and want a repeatable, professional workflow for AI-assisted coding, check out (https://github.com/SpillwaveSolutions/sdd-skill). It’s MIT-licensed, actively evolving, and already proving that the future of software development is intent-driven, transparent, and delightfully conversational.

Next steps

I plan on turning this into a full blown Claude agent plugin.

Getting Started

The install can be as simple as:

# install skilz 
pip install skilz 

# install the sdd skill (installs in ~/.claude/skills)
skilz install https://github.com/SpillwaveSolutions/sdd-skill

Or if you want to install project level or use OpenCode, Gemini, Github Copilot, or Codex.

# install skilz 
pip install skilz 

# install the sdd skill (installs in ~/.claude/skills)
skilz install https://github.com/SpillwaveSolutions/sdd-skill

# or for project level install use (installs locally .claude/skills)
skilz install https://github.com/SpillwaveSolutions/sdd-skill --project 

# You can target opencode, gemini, codex, github copilot, etc. 
# by specifying --agent

# install the sdd skill (installs in ~/.codex/skills)
skilz install https://github.com/SpillwaveSolutions/sdd-skill \
      --agent codex

# or --agent gemini or --agent copilot or --agent opencode

# or for project level install use (installs locally .claude/skills)
skilz install https://github.com/SpillwaveSolutions/sdd-skill --project

The installer supports 14+ agenting coding assistance and coding agents.

Once you have it installed, go into planning mode or the equivalent, describe what you want to build. When you are done, ask your coding assistant to turn that plan into a detailed spec, features and tasks, and it does it all. You just review and you are off to the races.

Then let’s say you go off the rails and you start implemeting things or fixing bugs outside of the SDD process. No big deal, just ask the agent to refer to the SDD skill and get you back into it.

I have used this a lot with both Claude Code and OpenCode. It seems to work slightly better with Claude Code, but it also works well with OpenCode. This might just be the way I wrote the skill. It tends to be more Claude Code centric. I use this and find it useful but it is one of the first skills that I wrote. It could use some love an polish.

Using this agent skill doesn’t mean you shouldn’t take the time to learn the ins and outs of Github Spec Driven Development, it just creates a nice on-ramp.

About the Author

Rick Hightower is a technology executive and data engineer who led ML/AI development at a Fortune 100 financial services company. He created skilz, the universal agent skill installer, supporting 14+ coding agents including Claude Code, Gemini, Copilot, and Cursor, and co-founded the world’s largest agentic skill marketplace. CConnect with Rick Hightower on LinkedIn or Medium.

The Claude Code community has developed powerful extensions that enhance its capabilities. Here are some valuable resources from Spillwave Solutions (Spillwave Solutions Home Page):

Integration Skills

• Notion Uploader/Downloader Agent Skill: Seamlessly upload and download Markdown content and images to Notion for documentation workflows
• Confluence Agent Skill: Upload and download Markdown content and images to Confluence for enterprise documentation
• JIRA Integration Agent Skill: Create and read JIRA tickets, including handling special required fields

Recently, I wrote a desktop app called Agent Skill Viewer to evaluate Agents skills for safety, usefulness, links and PDA.