An intelligent toolkit that integrates Roo Code's advanced modes with the proven Spec-Driven Development methodology to build high-quality software faster.
- 🤔 What is Spec-Driven Development?
- ⚡ Get started
- 📽️ Video Overview
- 🔧 Specify CLI Reference
- 📚 Core philosophy
- 🌟 Development phases
- 🎯 Roo Code integration
- 🔧 Prerequisites
- 📖 Learn more
- 📋 Detailed process
- 🔍 Troubleshooting
- 👥 Maintainers
- 💬 Support
- 🙏 Acknowledgements
- 📄 License
Spec-Driven Development flips the script on traditional software development. For decades, code has been king — specifications were just scaffolding we built and discarded once the "real work" of coding began. Spec-Driven Development changes this: specifications become executable, directly generating working implementations rather than just guiding them.
With Spec-Kit-Roo, we've enhanced this methodology with Roo Code's intelligent modes:
- Spec Writer mode for comprehensive specification creation
- Plan Architect mode for strategic implementation planning
- Task Orchestrator mode for precise task execution
- Constitution Guardian mode for continuous compliance
Initialize your project optimized for Roo Code:
# Roo Code integration (recommended)
uvx --from git+https://github.com/Michaelzag/spec-kit-roo.git specify init <PROJECT_NAME> --ai rooOr initialize in current directory:
uvx --from git+https://github.com/Michaelzag/spec-kit-roo.git specify init --here --ai rooUse Roo Code's Spec Writer mode or the /specify command to describe what you want to build. Focus on the what and why, not the tech stack.
/specify Build an application that can help me organize my photos in separate photo albums. Albums are grouped by date and can be re-organized by dragging and dropping on the main page. Albums are never in other nested albums. Within each album, photos are previewed in a tile-like interface.Use Roo Code's Plan Architect mode or the /plan command to provide your tech stack and architecture choices.
/plan The application uses Vite with minimal number of libraries. Use vanilla HTML, CSS, and JavaScript as much as possible. Images are not uploaded anywhere and metadata is stored in a local SQLite database.Use Roo Code's Task Orchestrator mode or /tasks to create an actionable task list, then implement features systematically.
For detailed step-by-step instructions, see our comprehensive guide.
Want to see Spec Kit in action? Watch our video overview!
The specify command supports the following options:
| Command | Description |
|---|---|
init |
Initialize a new Specify project from the latest template |
check |
Check for installed tools (git, claude, gemini, code/code-insiders, cursor-agent) |
| Argument/Option | Type | Description |
|---|---|---|
<project-name> |
Argument | Name for your new project directory (optional if using --here) |
--ai |
Option | AI assistant to use: claude, gemini, copilot, cursor, or roo |
--script |
Option | Script variant to use: sh (bash/zsh) or ps (PowerShell) |
--ignore-agent-tools |
Flag | Skip checks for AI agent tools like Claude Code |
--no-git |
Flag | Skip git repository initialization |
--here |
Flag | Initialize project in the current directory instead of creating a new one |
--skip-tls |
Flag | Skip SSL/TLS verification (not recommended) |
--debug |
Flag | Enable detailed debug output for troubleshooting |
# Basic project initialization
specify init my-project
# Initialize with specific AI assistant
specify init my-project --ai claude
# Initialize with Cursor support
specify init my-project --ai cursor
# Initialize with PowerShell scripts (Windows/cross-platform)
specify init my-project --ai copilot --script ps
# Initialize in current directory
specify init --here --ai copilot
# Skip git initialization
specify init my-project --ai gemini --no-git
# Enable debug output for troubleshooting
specify init my-project --ai claude --debug
# Check system requirements
specify checkSpec-Driven Development with Roo Code integration is a structured process that emphasizes:
- Intent-driven development where specifications define the "what" before the "how"
- Intelligent mode orchestration using Roo Code's specialized modes for each development phase
- Rich specification creation using guardrails and organizational principles
- Multi-step refinement rather than one-shot code generation from prompts
- Constitutional awareness ensuring compliance throughout the development lifecycle
- Heavy reliance on advanced AI model capabilities for specification interpretation
| Phase | Roo Mode | Focus | Key Activities |
|---|---|---|---|
| 0-to-1 Development ("Greenfield") | Spec Writer → Plan Architect → Task Orchestrator | Generate from scratch |
|
| Creative Exploration | Constitution Guardian | Parallel implementations |
|
| Iterative Enhancement ("Brownfield") | Task Orchestrator | Brownfield modernization |
|
Spec-Kit-Roo leverages Roo Code's powerful mode system to create a seamless spec-driven development experience:
- Purpose: Create detailed feature specifications and user stories
- When to use: First phase of development, specification creation
- Capabilities: Comprehensive requirement gathering, team culture alignment, constitutional compliance validation
- Purpose: Generate strategic implementation plans and technical decisions
- When to use: Second phase, after specifications are complete
- Capabilities: Research generation, data model design, contract creation, and technical documentation
- Purpose: Break down plans into executable tasks with precise coordination
- When to use: Third phase, after plans are created
- Capabilities: Parallel task execution, dependency management, and progress tracking
- Purpose: Ensure ongoing compliance with project principles and constraints
- When to use: Throughout development lifecycle for constitutional validation
- Capabilities: Continuous compliance monitoring and proactive guidance
- Intelligent Context Sharing: Seamless information flow between modes
- Constitutional Awareness: Built-in compliance with project principles
- Mode Orchestration: Automatic coordination between development phases
- Progressive Refinement: Iterative enhancement based on user feedback
- User-Centric Delivery: Build applications for different user cohorts and preferences
- Flexible Development Approaches: Support workflows from vibe-coding to AI-native development
- Validate the concept of parallel implementation exploration
- Provide robust iterative feature development workflows
- Extend processes to handle upgrades and modernization tasks
- Linux/macOS (or WSL2 on Windows)
- Roo Code extension for VS Code (primary agent)
- Optional AI coding agents: Claude Code, GitHub Copilot, Gemini CLI, or Cursor
- uv for package management
- Python 3.11+
- Git
- Install the Roo Code extension in VS Code
- Enable Experimental → Run Slash Command in Roo settings
- Use the integrated modes through VS Code's command palette
- Complete Spec-Driven Development Methodology - Deep dive into the full process
- Detailed Walkthrough - Step-by-step implementation guide
- Roo Code Modes Reference - Complete mode definitions and capabilities
Click to expand the detailed step-by-step walkthrough
You can use the Specify CLI to bootstrap your project, which will bring in the required artifacts in your environment. Run:
specify init <project_name> --ai rooOr initialize in the current directory:
specify init --here --ai roo
You will be prompted to select the AI agent you are using. For Roo Code optimized setup:
# Roo Code with full integration
specify init <project_name> --ai roo
# Or in current directory:
specify init --here --ai rooThe CLI will set up Roo Code specific configurations and copy the required templates and rules.
Open your project in VS Code with the Roo Code extension installed. Ensure the following settings are configured:
- Enable Experimental → Run Slash Command in Roo settings
- Roo version that supports custom modes
When properly configured, you should see the /specify, /plan, and /tasks commands available in the command palette.
The first step should be creating a new project scaffolding. Use the Spec Writer mode or /specify command and then provide the concrete requirements for the project you want to develop.
[!IMPORTANT] Be as explicit as possible about what you are trying to build and why. Do not focus on the tech stack at this point.
An example prompt:
Develop Taskify, a team productivity platform. It should allow users to create projects, add team members,
assign tasks, comment and move tasks between boards in Kanban style. In this initial phase for this feature,
let's call it "Create Taskify," let's have multiple users but the users will be declared ahead of time, predefined.
I want five users in two different categories, one product manager and four engineers. Let's create three
different sample projects. Let's have the standard Kanban columns for the status of each task, such as "To Do,"
"In Progress," "In Review," and "Done." There will be no login for this application as this is just the very
first testing thing to ensure that our basic features are set up. For each task in the UI for a task card,
you should be able to change the current status of the task between the different columns in the Kanban work board.
You should be able to leave an unlimited number of comments for a particular card. You should be able to, from that task
card, assign one of the valid users. When you first launch Taskify, it's going to give you a list of the five users to pick
from. There will be no password required. When you click on a user, you go into the main view, which displays the list of
projects. When you click on a project, you open the Kanban board for that project. You're going to see the columns.
You'll be able to drag and drop cards back and forth between different columns. You will see any cards that are
assigned to you, the currently logged in user, in a different color from all the other ones, so you can quickly
see yours. You can edit any comments that you make, but you can't edit comments that other people made. You can
delete any comments that you made, but you can't delete comments anybody else made.
After this prompt is entered, Roo Code will kick off the planning and spec drafting process using the Spec Writer mode. Roo Code will also trigger some of the built-in scripts to set up the repository.
Once this step is completed, you should have a new branch created (e.g., 001-create-taskify), as well as a new specification in the specs/001-create-taskify directory.
The produced specification should contain a set of user stories and functional requirements, as defined in the template.
At this stage, your project folder contents should resemble the following:
├── memory
│ ├── constitution.md
│ └── constitution_update_checklist.md
├── scripts
│ ├── check-task-prerequisites.sh
│ ├── common.sh
│ ├── create-new-feature.sh
│ ├── get-feature-paths.sh
│ ├── setup-plan.sh
│ └── update-agent-context.sh
├── specs
│ └── 001-create-taskify
│ └── spec.md
├── templates
│ ├── plan-template.md
│ ├── spec-template.md
│ ├── tasks-template.md
│ └── roo/
├── .roo
│ ├── commands/
│ └── rules-*/
└── AGENTS.md
With the baseline specification created, you can go ahead and clarify any of the requirements that were not captured properly within the first shot attempt. For example, you could use a prompt like this within the same Roo Code session:
For each sample project or project that you create there should be a variable number of tasks between 5 and 15
tasks for each one randomly distributed into different states of completion. Make sure that there's at least
one task in each stage of completion.
You should also ask Roo Code to validate the Review & Acceptance Checklist, checking off the things that are validated/pass the requirements, and leave the ones that are not unchecked. The following prompt can be used:
Read the review and acceptance checklist, and check off each item in the checklist if the feature spec meets the criteria. Leave it empty if it does not.
It's important to use the interaction with Roo Code as an opportunity to clarify and ask questions around the specification - do not treat its first attempt as final.
You can now be specific about the tech stack and other technical requirements. Use the Plan Architect mode or the /plan command with a prompt like this:
We are going to generate this using .NET Aspire, using Postgres as the database. The frontend should use
Blazor server with drag-and-drop task boards, real-time updates. There should be a REST API created with a projects API,
tasks API, and a notifications API.
The output of this step will include a number of implementation detail documents, with your directory tree resembling this:
.
├── AGENTS.md
├── memory
│ ├── constitution.md
│ └── constitution_update_checklist.md
├── scripts
│ ├── check-task-prerequisites.sh
│ ├── common.sh
│ ├── create-new-feature.sh
│ ├── get-feature-paths.sh
│ ├── setup-plan.sh
│ └── update-agent-context.sh
├── specs
│ └── 001-create-taskify
│ ├── contracts
│ │ ├── api-spec.json
│ │ └── signalr-spec.md
│ ├── data-model.md
│ ├── plan.md
│ ├── quickstart.md
│ ├── research.md
│ └── spec.md
├── templates
│ ├── roo/
│ └── tasks-template.md
└── .roo
Check the research.md document to ensure that the right tech stack is used, based on your instructions. You can ask Roo Code to refine it if any of the components stand out, or even have it check the locally-installed version of the platform/framework you want to use (e.g., .NET).
Additionally, you might want to ask Roo Code to research details about the chosen tech stack if it's something that is rapidly changing (e.g., .NET Aspire, JS frameworks), with a prompt like this:
I want you to go through the implementation plan and implementation details, looking for areas that could
benefit from additional research as .NET Aspire is a rapidly changing library. For those areas that you identify that
require further research, I want you to update the research document with additional details about the specific
versions that we are going to be using in this Taskify application and spawn parallel research tasks to clarify
any details using research from the web.
During this process, you might find that Roo Code gets stuck researching the wrong thing - you can help nudge it in the right direction with a prompt like this:
I think we need to break this down into a series of steps. First, identify a list of tasks
that you would need to do during implementation that you're not sure of or would benefit
from further research. Write down a list of those tasks. And then for each one of these tasks,
I want you to spin up a separate research task so that the research is highly targeted
to the specific needs you have. Research the correct .NET Aspire versions and
specific implementation patterns for Taskify.
[!NOTE] Roo Code might be over-eager and add components that you did not ask for. Ask it to clarify the rationale and the source of the change.
With the plan in place, you should have Roo Code run through it to make sure that there are no missing pieces. You can use a prompt like this:
Now I want you to go and audit the implementation plan and the implementation detail files.
Read through it with an eye on determining whether or not there is a sequence of tasks that you need
to be doing that are obvious from reading this. Because I don't know if there's enough here. For example,
when I look at the core implementation, it would be useful to reference the appropriate places in the implementation
details where it can find the information as it walks through each step in the core implementation or in the refinement.
This helps refine the implementation plan and helps you avoid potential blind spots that Roo Code missed in its planning cycle. Once the initial refinement pass is complete, ask Roo Code to go through the checklist once more before you can get to the implementation.
You can also ask Roo Code (if you have the GitHub CLI installed) to go ahead and create a pull request from your current branch to main with a detailed description, to make sure that the effort is properly tracked.
[!NOTE] Before you have the agent implement it, it's also worth prompting Roo Code to cross-check the details to see if there are any over-engineered pieces (remember - it can be over-eager). If over-engineered components or decisions exist, you can ask Roo Code to resolve them. Ensure that Roo Code follows the constitution as the foundational piece that it must adhere to when establishing the plan.
Once ready, use the Task Orchestrator mode or /tasks to break down and execute:
/tasks Break down the plan in specs/001-create-taskify/plan.md into executable tasks
Roo Code will spring into action and will start creating the implementation, coordinating between modes as needed.
[!IMPORTANT] Roo Code will execute local CLI commands (such as
dotnet) - make sure you have them installed on your machine.
Once the implementation step is done, ask Roo Code to try to run the application and resolve any emerging build errors. If the application runs, but there are runtime errors that are not directly available to Roo Code through CLI logs (e.g., errors rendered in browser logs), copy and paste the error in Roo Code and have it attempt to resolve it.
If you're having issues with Git authentication on Linux, you can install Git Credential Manager:
#!/usr/bin/env bash
set -e
echo "Downloading Git Credential Manager v2.6.1..."
wget https://github.com/git-ecosystem/git-credential-manager/releases/download/v2.6.1/gcm-linux_amd64.2.6.1.deb
echo "Installing Git Credential Manager..."
sudo dpkg -i gcm-linux_amd64.2.6.1.deb
echo "Configuring Git to use GCM..."
git config --global credential.helper manager
echo "Cleaning up..."
rm gcm-linux_amd64.2.6.1.deb- Michael Zag (@Michaelzag)
- Original Spec-Kit Contributors
For support, please open a GitHub issue. We welcome bug reports, feature requests, and questions about using Spec-Driven Development with Roo Code.
This project builds upon the original Spec-Kit project from GitHub and is inspired by the work of John Lam. Enhanced with Roo Code integration developed by Michael Zag.
This project is licensed under the terms of the MIT open source license. Please refer to the LICENSE file for the full terms.