specifypro 0.0.24
SpecifyPro CLI - Imam Sanghaar's Spec-Driven Development Toolkit. A fork of GitHub Spec Kit.
Requires Python: >=3.11

> **SpecifyPro**: It enables Spec-driven Vibe-coding by combining the rapid, conversational generation power of "vibe coding" with the structure and architectural coherence provided by the "spec-driven" methodology. This is a enhanced Spec-Driven Development toolkit with patterns & templates for building scalable multi-agent AI systems. It is a practical fork of github/spec-kit for spec-driven development of agentic AI systems. It provides patterns, templates, and reference projects for building scalable, distributed multi-agent apps with the OpenAI Agents SDK, MCP, A2A, and a cloud-native runtime stack—Docker, Kubernetes, Dapr (Actors & Workflows), and Ray. Use it to define specs, spin up services, orchestrate agents, and ship production-ready stacks faster with guardrails and CI-friendly scaffolds.

## The Most Important Question for Today's Developer

There's a question that every software developer should be asking themselves, one that will fundamentally shape the future of our profession: **If AI writes the code, what's left for a developer to do?**

Far from making developers obsolete, the rise of AI coding assistants clarifies their true value. The focus is shifting away from the mechanical act of writing syntax and toward the higher-order skills that drive real innovation:

- **Strategic Problem-Solving:** The ability to deconstruct complex business challenges.
- **System Architecture:** The vision to design resilient and efficient systems.
- **Incisive Diagnostics:** The expertise to perform deep-seated root cause analysis.
- **Critical Inquiry:** The wisdom to ask the right questions and define project scope.
- **Technical Governance:** The judgment to establish standards and evaluate trade-offs.

Embracing this shift, our initiative is to leverage AI to develop advanced AI Agents. We are implementing a new workflow using tools like **spec-kit-plus** to facilitate this.

While this means development will become more conversational, it reinforces the need for foundational knowledge. A command of Python and technologies like the OpenAI Agents SDK, Kubernetes, Dapr, and Ray is indispensable. Developers must understand the code generated by LLMs to verify its quality, debug its flaws, and guide the AI toward optimal solutions.

---

## The New Coding Revolution: Why AI-Native Programmers Will Win

At 28, Alexandr Wang has built Scale AI and now leads a major AI lab at Meta. His prediction? [Every line of code he's ever written will eventually be replaced by AI-generated software](https://fortune.com/2025/09/19/alexandr-wang-ai-vibe-coding-next-bill-gates/).

### A Generational Shift

Wang sees today's moment as equivalent to the PC revolution. Just as Gates and Zuckerberg gained an edge by tinkering with early computers, today's teenagers can dominate by spending thousands of hours "Spec-driven Vibe-coding" with AI.

The advantage won't come from traditional programming skills. It will come from growing up with AI as a collaborative partner—building an intuition that older programmers, trained in pure human-to-machine coding, will struggle to match.

### The Real Competition

This isn't about AI replacing programmers. It's about a new kind of programmer emerging: one who intuitively understands how to harness AI to bring ideas to life.

The developers who build the next generation of transformative software might not be grinding through CS degrees. They'll be young people who learned to think and create in partnership with AI.

**The message is clear:** The future belongs to those who start experimenting now. The revolution isn't coming—it's already here.

---

Use `specifypro` or `sp` commands instead of `specify`.

<div align="center">
    <img src="./media/logo_large.webp" alt="SpeckitPro Logo" width="200" height="200"/>
    <h1>🌱 SpeckitPro</h1>
    <h3><em>Imam Sanghaar's SpeckitPro - Spec-Driven Development Toolkit</em></h3>
</div>

<p align="center">
    <strong>An open source toolkit that allows you to focus on product scenarios and predictable outcomes instead of vibe coding every piece from scratch.</strong>
</p>

<p align="center">
    <a href="https://github.com/imsanghaar/spec-kit-pro/actions/workflows/publish.yml"><img src="https://github.com/imsanghaar/spec-kit-pro/actions/workflows/publish.yml/badge.svg?branch=main" alt="Release"/></a>
    <a href="https://github.com/imsanghaar/spec-kit-pro/stargazers"><img src="https://img.shields.io/github/stars/imsanghaar/spec-kit-pro?style=social" alt="GitHub stars"/></a>
    <a href="https://github.com/imsanghaar/spec-kit-pro/blob/main/LICENSE"><img src="https://img.shields.io/github/license/imsanghaar/spec-kit-pro" alt="License"/></a>
</p>

---

## Table of Contents

- [🤔 What is Spec-Driven Development?](#-what-is-spec-driven-development)
- [⚡ Get Started](#-get-started)
- [📽️ Video Overview](#️-video-overview)
- [🤖 Supported AI Agents](#-supported-ai-agents)
- [🔧 Specify CLI Reference](#-specify-cli-reference)
- [📚 Core Philosophy](#-core-philosophy)
- [🌟 Development Phases](#-development-phases)
- [🎯 Experimental Goals](#-experimental-goals)
- [🔧 Prerequisites](#-prerequisites)
- [📖 Learn More](#-learn-more)
- [📋 Detailed Process](#-detailed-process)
- [🔍 Troubleshooting](#-troubleshooting)
- [👥 Maintainers](#-maintainers)
- [💬 Support](#-support)
- [🙏 Acknowledgements](#-acknowledgements)
- [📄 License](#-license)

## 🤔 What is Spec-Driven Development?

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.

## ⚡ Get Started

### 1. Install Specify CLI

Choose your preferred installation method:

#### Option 1: Persistent Installation (Recommended)

Install once and use everywhere:

```bash
# From PyPI (recommended)
pip install specifypro

# Or with uv tools
uv tool install specifypro

# Upgrade to latest later
pip install -U specifypro
uv tool upgrade specifypro
```

You may uninstall specifypro:

```bash
pip uninstall specifypro

# or

uv tool uninstall specifypro
```

Then use the tool directly:

```bash
# Create new project
specifypro init <PROJECT_NAME>
# or
sp init <PROJECT_NAME>

# Or initialize in existing project
specifypro init . --ai claude
# or
sp init --here --ai claude

# Check installed tools
specifypro check
# or
sp check
```

To upgrade SpecifyPro, see the [Upgrade Guide](./docs/upgrade.md) for detailed instructions. Quick upgrade:

```bash
uv tool install specifypro --force --from git+https://github.com/imsanghaar/spec-kit-pro.git
```

#### Option 2: One-time Usage

Run directly without installing:

```bash
uvx specifypro --help
uvx specifypro init <PROJECT_NAME>
# or
uvx sp init <PROJECT_NAME>
```

**Benefits of persistent installation:**

- Tool stays installed and available in PATH
- No need to create shell aliases
- Better tool management with `uv tool list`, `uv tool upgrade`, `uv tool uninstall`
- Cleaner shell configuration

## 📽️ Video Overview

Want to see SpeckitPro in action? Watch our [video overview](https://youtu.be/H8osKk9ysng?si=MKFfl-5Ur%cXmqnS)!

[![Spec Kit video header](https://img.youtube.com/vi/H8osKk9ysng/maxresdefault.jpg)](https://youtu.be/H8osKk9ysng?si=MKFfl-5Ur%cXmqnS)

### 2. Establish project principles

Use the **`/spp.constitution`** command to create your project's governing principles and development guidelines that will guide all subsequent development.

```bash
/spp.constitution Create principles focused on code quality, testing standards, user experience consistency, and performance requirements
```

### 3. Create the spec

Use the **`/spp.specify`** command to describe what you want to build. Focus on the **what** and **why**, not the tech stack.

```bash
/spp.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.
```

### 4. Create a technical implementation plan

Use the **`/spp.plan`** command to provide your tech stack and architecture choices.

```bash
/spp.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.
```

### 5. Break down into tasks

Use **`/spp.tasks`** to create an actionable task list from your implementation plan.

```bash
/spp.tasks
```

### 6. Execute implementation

Use **`/spp.implement`** to execute all tasks and build your feature according to the plan.

```bash
/spp.implement
```

For detailed step-by-step instructions, see our [comprehensive guide](./spec-driven.md).

## 🤖 Supported AI Agents

| Agent                                                                                | Support | Notes                                                                                                                                     |
| ------------------------------------------------------------------------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| [Qoder CLI](https://qoder.com/cli)                                                   | ✅      |                                                                                                                                           |
| [Amazon Q Developer CLI](https://aws.amazon.com/developer/learning/q-developer-cli/) | ⚠️      | Amazon Q Developer CLI [does not support](https://github.com/aws/amazon-q-developer-cli/issues/3064) custom arguments for slash commands. |
| [Amp](https://ampcode.com/)                                                          | ✅      |                                                                                                                                           |
| [Auggie CLI](https://docs.augmentcode.com/cli/overview)                              | ✅      |                                                                                                                                           |
| [Claude Code](https://www.anthropic.com/claude-code)                                 | ✅      |                                                                                                                                           |
| [CodeBuddy CLI](https://www.codebuddy.ai/cli)                                        | ✅      |                                                                                                                                           |
| [Codex CLI](https://github.com/openai/codex)                                         | ✅      |                                                                                                                                           |
| [Cursor](https://cursor.sh/)                                                         | ✅      |                                                                                                                                           |
| [Gemini CLI](https://github.com/google-gemini/gemini-cli)                            | ✅      |                                                                                                                                           |
| [GitHub Copilot](https://code.visualstudio.com/)                                     | ✅      |                                                                                                                                           |
| [IBM Bob](https://www.ibm.com/products/bob)                                          | ✅      | IDE-based agent with slash command support                                                                                                |
| [Jules](https://jules.google.com/)                                                   | ✅      |                                                                                                                                           |
| [Kilo Code](https://github.com/Kilo-Org/kilocode)                                    | ✅      |                                                                                                                                           |
| [opencode](https://opencode.ai/)                                                     | ✅      |                                                                                                                                           |
| [Qwen Code](https://github.com/QwenLM/qwen-code)                                     | ✅      |                                                                                                                                           |
| [Roo Code](https://roocode.com/)                                                     | ✅      |                                                                                                                                           |
| [SHAI (OVHcloud)](https://github.com/ovh/shai)                                       | ✅      |                                                                                                                                           |
| [Windsurf](https://windsurf.com/)                                                    | ✅      |                                                                                                                                           |

## 🔧 Specify CLI Reference

### Learning subagents (optional)

- Spec Architect – `docs-plus/02_start_prompting/02_qwen_code/04_subagents/prompts/0002-spec-architect.prompt.md`
- PHR/ADR Curator & Evaluator – `docs-plus/02_start_prompting/02_qwen_code/04_subagents/prompts/0004-phr-adr-curator.prompt.md`

> **Note**: Use `specifypro` or `sp` commands instead of `specify` in this fork.

The `specifypro` command supports the following options:

### Commands

| 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`, `windsurf`, `qwen`, `opencode`, `codex`, `shai`, `qoder`) |
| `version` | Display version and system information                                                                                                                  |

### `specifypro init` Arguments & Options

| Argument/Option        | Type     | Description                                                                                                                                                                                  |
| ---------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `<project-name>`       | Argument | Name for your new project directory (optional if using `--here`, or use `.` for current directory)                                                                                           |
| `--ai`                 | Option   | AI assistant to use: `claude`, `gemini`, `copilot`, `cursor-agent`, `qwen`, `opencode`, `codex`, `windsurf`, `kilocode`, `auggie`, `roo`, `codebuddy`, `amp`, `shai`, `q`, `bob`, or `qoder` |
| `--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                                                                                                                    |
| `--force`              | Flag     | Force merge/overwrite when initializing in current directory (skip confirmation)                                                                                                             |
| `--skip-tls`           | Flag     | Skip SSL/TLS verification (not recommended)                                                                                                                                                  |
| `--debug`              | Flag     | Enable detailed debug output for troubleshooting                                                                                                                                             |
| `--github-token`       | Option   | GitHub token for API requests (or set GH_TOKEN/GITHUB_TOKEN env variable)                                                                                                                    |

### Examples

```bash
# Basic project initialization
specifypro init my-project

# Initialize with specific AI assistant
specifypro init my-project --ai claude

# Initialize with Cursor support
specifypro init my-project --ai cursor

# Initialize with Qoder support
specifypro init my-project --ai qoder

# Initialize with Windsurf support
specifypro init my-project --ai windsurf

# Initialize with Amp support
specifypro init my-project --ai amp

# Initialize with SHAI support
specifypro init my-project --ai shai

# Initialize with IBM Bob support
specifypro init my-project --ai bob

# Initialize with PowerShell scripts (Windows/cross-platform)
specifypro init my-project --ai copilot --script ps

# Initialize in current directory
specifypro init . --ai copilot
# or use the --here flag
specifypro init --here --ai copilot

# Force merge into current (non-empty) directory without confirmation
specifypro init . --force --ai copilot
# or
specifypro init --here --force --ai copilot

# Skip git initialization
specifypro init my-project --ai gemini --no-git

# Enable debug output for troubleshooting
specifypro init my-project --ai claude --debug

# Use GitHub token for API requests (helpful for corporate environments)
specifypro init my-project --ai claude --github-token ghp_your_token_here

# Check system requirements
specifypro check
```

### Available Slash Commands

After running `specifypro init`, your AI coding agent will have access to these slash commands for structured development:

#### Core Commands

Essential commands for the Spec-Driven Development workflow:

| Command             | Description                                                              |
|:--------------------|:-------------------------------------------------------------------------|
| `/spp.constitution` | Create or update project governing principles and development guidelines |
| `/spp.specify`      | Define what you want to build (requirements and user stories)            |
| `/spp.plan`         | Create technical implementation plans with your chosen tech stack        |
| `/spp.tasks`        | Generate actionable task lists for implementation                        |
| `/spp.implement`    | Execute all tasks to build the feature according to the plan             |

Additional commands for enhanced quality and validation:

| Command          | Description                                                                                                                           |
|:-----------------|:--------------------------------------------------------------------------------------------------------------------------------------|
| `/spp.clarify`   | Clarify underspecified areas (recommended before `/spp.plan`; formerly `/quizme`)                                                      |
| `/spp.analyze`   | Cross-artifact consistency & coverage analysis (run after `/spp.tasks`, before `/spp.implement`)                                        |
| `/spp.checklist` | Generate custom quality checklists that validate requirements completeness, clarity, and consistency (like "unit tests for English")    |
| `/spp.readme`    | Create professional and attractive README.md files with project documentation, setup instructions, and usage guides                     |

### Environment Variables

| Variable          | Description                                                                                                                                                                                                                                                                                       |
|:------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `SPECIFY_FEATURE` | Override feature detection for non-Git repositories. Set to the feature directory name (e.g., `001-photo-albums`) to work on a specific feature when not using Git branches.<br/>\*\*Must be set in the context of the agent you're working with prior to using `/spp.plan` or follow-up commands. |

## 📚 Core Philosophy

Spec-Driven Development is a structured process that emphasizes:

- **Intent-driven development** where specifications define the "*what*" before the "*how*"
- **Rich specification creation** using guardrails and organizational principles
- **Multi-step refinement** rather than one-shot code generation from prompts
- **Heavy reliance** on advanced AI model capabilities for specification interpretation

## 🌟 Development Phases

| Phase                                    | Focus                    | Key Activities                                                                                                                                                     |
| ---------------------------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **0-to-1 Development** ("Greenfield")    | Generate from scratch    | <ul><li>Start with high-level requirements</li><li>Generate specifications</li><li>Plan implementation steps</li><li>Build production-ready applications</li></ul> |
| **Creative Exploration**                 | Parallel implementations | <ul><li>Explore diverse solutions</li><li>Support multiple technology stacks & architectures</li><li>Experiment with UX patterns</li></ul>                         |
| **Iterative Enhancement** ("Brownfield") | Brownfield modernization | <ul><li>Add features iteratively</li><li>Modernize legacy systems</li><li>Adapt processes</li></ul>                                                                |

## 🎯 Experimental Goals

Our research and experimentation focus on:

### Technology independence

- Create applications using diverse technology stacks
- Validate the hypothesis that Spec-Driven Development is a process not tied to specific technologies, programming languages, or frameworks

### Enterprise constraints

- Demonstrate mission-critical application development
- Incorporate organizational constraints (cloud providers, tech stacks, engineering practices)
- Support enterprise design systems and compliance requirements

### User-centric development

- Build applications for different user cohorts and preferences
- Support various development approaches (from vibe-coding to AI-native development)

### Creative & iterative processes

- Validate the concept of parallel implementation exploration
- Provide robust iterative feature development workflows
- Extend processes to handle upgrades and modernization tasks

## 🔧 Prerequisites

- **Linux/macOS/Windows**
- [Supported](#-supported-ai-agents) AI coding agent.
- [uv](https://docs.astral.sh/uv/) for package management
- [Python 3.11+](https://www.python.org/downloads/)
- [Git](https://git-scm.com/downloads)

If you encounter issues with an agent, please open an issue so we can refine the integration.

## 📖 Learn More

- **[Complete Spec-Driven Development Methodology](./spec-driven.md)** - Deep dive into the full process
- **[Detailed Walkthrough](#-detailed-process)** - Step-by-step implementation guide

---

## 📋 Detailed Process

<details>
<summary>Click to expand the detailed step-by-step walkthrough</summary>

</details>

---

You can use SpecifyPro to bootstrap your project, which will bring in the required artifacts in your environment. Run:

```bash
specifypro init <project_name>
# or
sp init <project_name>
```

Or initialize in the current directory:

```bash
specifypro init .
# or use the --here flag
specifypro init --here
# Skip confirmation when the directory already has files
specifypro init . --force
# or
specifypro init --here --force
# or using alias
sp init .
sp init --here
sp init . --force
sp init --here --force
```

![SpecifyPro CLI bootstrapping a new project in the terminal](./media/specify_cli.gif)

You will be prompted to select the AI agent you are using. You can also proactively specify it directly in the terminal:

```bash
specifypro init <project_name> --ai claude
specifypro init <project_name> --ai gemini
specifypro init <project_name> --ai copilot
specifypro init <project_name> --ai cursor
specifypro init <project_name> --ai qwen
specifypro init <project_name> --ai opencode
specifypro init <project_name> --ai codex
specifypro init <project_name> --ai windsurf
specifypro init <project_name> --ai q

# Or in current directory:
specifypro init . --ai claude
specifypro init . --ai codex

# or use --here flag
specifypro init --here --ai claude
specifypro init --here --ai codex

# Force merge into a non-empty current directory
specifypro init . --force --ai claude
specifypro init --here --force --ai claude

# Or using the short alias:
sp init <project_name> --ai claude
sp init . --ai claude
sp init --here --ai claude
sp init . --force --ai claude
```

The CLI will check if you have Claude Code, Gemini CLI, Cursor CLI, Qwen CLI, opencode, Codex CLI, Qoder CLI, or Amazon Q Developer CLI installed. If you do not, or you prefer to get the templates without checking for the right tools, use `--ignore-agent-tools` with your command:

```bash
specifypro init <project_name> --ai claude --ignore-agent-tools
# or
sp init <project_name> --ai claude --ignore-agent-tools
```

### **STEP 1:** Establish project principles

Go to the project folder and run your AI agent. In our example, we're using `claude`.

![Bootstrapping Claude Code environment](./media/bootstrap-claude-code.gif)

You will know that things are configured correctly if you see the `/spp.constitution`, `/spp.specify`, `/spp.plan`, `/spp.tasks`, and `/spp.implement` commands available.

The first step should be establishing your project's governing principles using the `/spp.constitution` command. This helps ensure consistent decision-making throughout all subsequent development phases:

```text
/spp.constitution Create principles focused on code quality, testing standards, user experience consistency, and performance requirements. Include governance for how these principles should guide technical decisions and implementation choices.
```

This step creates or updates the `.specify/memory/constitution.md` file with your project's foundational guidelines that the AI agent will reference during specification, planning, and implementation phases.

### **STEP 2:** Create project specifications

With your project principles established, you can now create the functional specifications. Use the `/spp.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:

```text
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, you should see Claude Code kick off the planning and spec drafting process. Claude 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:

```text
└── .specify
    ├── memory
    │  └── constitution.md
    ├── scripts
    │  ├── check-prerequisites.sh
    │  ├── common.sh
    │  ├── create-new-feature.sh
    │  ├── setup-plan.sh
    │  └── update-claude-md.sh
    ├── specs
    │  └── 001-create-taskify
    │      └── spec.md
    └── templates
        ├── plan-template.md
        ├── spec-template.md
        └── tasks-template.md
```

### **STEP 3:** Functional specification clarification (required before planning)

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.

You should run the structured clarification workflow **before** creating a technical plan to reduce rework downstream.

Preferred order:

1. Use `/spp.clarify` (structured) – sequential, coverage-based questioning that records answers in a Clarifications section.
2. Optionally follow up with ad-hoc free-form refinement if something still feels vague.

If you intentionally want to skip clarification (e.g., spike or exploratory prototype), explicitly state that so the agent doesn't block on missing clarifications.

Example free-form refinement prompt (after `/spp.clarify` if still needed):

```text
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 Claude 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:

```text
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 Claude Code as an opportunity to clarify and ask questions around the specification - **do not treat its first attempt as final**.

### **STEP 4:** Generate a plan

You can now be specific about the tech stack and other technical requirements. You can use the `/spp.plan` command that is built into the project template with a prompt like this:

```text
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:

```text
.
├── CLAUDE.md
├── memory
│  └── constitution.md
├── scripts
│  ├── check-prerequisites.sh
│  ├── common.sh
│  ├── create-new-feature.sh
│  ├── setup-plan.sh
│  └── update-claude-md.sh
├── specs
│  └── 001-create-taskify
│      ├── contracts
│      │  ├── api-spec.json
│      │  └── signalr-spec.md
│      ├── data-model.md
│      ├── plan.md
│      ├── quickstart.md
│      ├── research.md
│      └── spec.md
└── templates
    ├── CLAUDE-template.md
    ├── plan-template.md
    ├── spec-template.md
    └── tasks-template.md
```

Check the `research.md` document to ensure that the right tech stack is used, based on your instructions. You can ask Claude 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 Claude 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:

```text
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 Claude Code gets stuck researching the wrong thing - you can help nudge it in the right direction with a prompt like this:

```text
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 net results is we are researching
all of those very specific tasks in parallel. What I saw you doing was it looks like you were
researching .NET Aspire in general and I don't think that's gonna do much for us in this case.
That's way too untargeted research. The research needs to help you solve a specific targeted question.
```

> [!NOTE]
> Claude 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.

### **STEP 5:** Have Claude Code validate the plan

With the plan in place, you should have Claude Code run through it to make sure that there are no missing pieces. You can use a prompt like this:

```text
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 Claude Code missed in its planning cycle. Once the initial refinement pass is complete, ask Claude Code to go through the checklist once more before you can get to the implementation.

You can also ask Claude Code (if you have the [GitHub CLI](https://docs.github.com/en/github-cli/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 Claude 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 Claude Code to resolve them. Ensure that Claude Code follows the [constitution](base/memory/constitution.md) as the foundational piece that it must adhere to when establishing the plan.

### STEP 6: Implementation

Once ready, use the `/spp.implement` command to execute your implementation plan:

```text
/spp.implement
```

The `/spp.implement` command will:

- **Task breakdown organized by user story** - Each user story becomes a separate implementation phase with its own set of tasks
- **Dependency management** - Tasks are ordered to respect dependencies between components (e.g., models before services, services before endpoints)
- **Parallel execution markers** - Tasks that can run in parallel are marked with `[P]` to optimize development workflow
- **File path specifications** - Each task includes the exact file paths where implementation should occur
- **Test-driven development structure** - If tests are requested, test tasks are included and ordered to be written before implementation
- **Checkpoint validation** - Each user story phase includes checkpoints to validate independent functionality

The generated tasks.md provides a clear roadmap for the `/spp.implement` command, ensuring systematic implementation that maintains code quality and allows for incremental delivery of user stories.

### **STEP 7:** Implementation

Once ready, use the `/spp.implement` command to execute your implementation plan:

```text
/spp.implement
```

The `/spp.implement` command will:

- Validate that all prerequisites are in place (constitution, spec, plan, and tasks)
- Parse the task breakd