A lightweight spec-driven development workflow for AI coding tools. Ten battle-tested prompts take you from a rough idea to a verified PRD, prioritized features, project rules, and sequenced RFCs — then guide implementation, code review, and testing, one RFC at a time.

Use it two ways:

• Native slash commands in Claude Code and Cursor — /create-prd, /implement-rfc 001, /workflow-status, …
• Copy-paste prompts into any AI assistant or IDE — ChatGPT, Gemini, Windsurf, Copilot, anything

No CLI to learn, no framework to adopt, no lock-in. Just markdown.

Quick Start

Option 1: Install as slash commands (Claude Code & Cursor)

curl -fsSL https://raw.githubusercontent.com/nurettincoban/ai-prd-workflow/main/install.sh | bash -s -- /path/to/your/project

Or from a clone:

git clone https://github.com/nurettincoban/ai-prd-workflow.git
cd ai-prd-workflow
./install.sh /path/to/your/project            # both tools
./install.sh /path/to/your/project --claude   # Claude Code only
./install.sh /path/to/your/project --cursor   # Cursor only

Then open your project and work through the pipeline:

/create-prd            # guided interview → PRD.md
/verify-prd            # gap analysis → improved PRD.md
/extract-features      # PRD.md → FEATURES.md (MoSCoW prioritized)
/generate-rules        # → RULES.md (project standards for the AI)
/generate-rfcs         # → RFCs/ folder, in strict implementation order
/implement-rfc 001     # plan → your approval → implementation
/review-rfc 001        # review the implementation against its spec
/test-strategy         # comprehensive test plan
/manage-changes        # requirements changed mid-build? assess impact first
/workflow-status       # lost? see what's done and what's next

[!TIP]
Cloning this repo and opening it in Claude Code or Cursor gives you the commands immediately — try them against the example project.

Option 2: Copy-paste into any AI assistant

1. Pick a prompt from Available Prompts below
2. Copy its contents (or use ./copy-prompt.sh --list to browse)
3. Paste into any AI assistant with your project context attached

Workflow

flowchart LR
    IDEA([💡 Idea]) --> PRD[Create PRD] --> VERIFY[Verify PRD] --> FEAT[Extract Features] --> RULES[Generate Rules] --> RFCS[Generate RFCs]
    RFCS --> IMPL[Implement RFC] --> REVIEW[Code Review] --> TEST[Test Strategy]
    REVIEW -.->|next RFC| IMPL
    CHANGE([Change request]) -.-> CM[Change Management] -.-> RFCS

1. Create PRD — Start with a vague idea and develop it into a complete PRD through a guided interview
2. Verify PRD — Identify critical gaps and improve quality before anything gets built
3. Extract Features — Transform the verified PRD into organized features with priorities and acceptance criteria
4. Generate Rules — Establish technical guidelines the AI must follow, wired into your agent config (CLAUDE.md, AGENTS.md, or .cursor/rules/)
5. Generate RFCs — Break the project into logical, sequenced implementation units
6. Implement RFCs — One RFC at a time: the AI plans first, you approve, then it codes
7. Code Review — Review each implementation against its RFC, project rules, security, and performance
8. Test Strategy — Generate and execute a comprehensive test plan

When requirements change mid-development, run Change Management to assess impact before touching the docs, then continue. Run Workflow Status anytime to see where you are and what's next.

Available Prompts

Why spec-driven development?

AI coding agents are strong enough now to build entire features unsupervised — which makes what you ask for the bottleneck, not the code. Structured specs fix that:

• Clearer instructions, fewer hallucinations — a PRD and RFCs give the AI precise context and boundaries instead of letting it fill gaps with assumptions
• Scope control — explicitly defined in/out of scope prevents the agent from implementing features nobody asked for
• Incremental verification — sequenced RFCs let you validate at each step instead of reviewing a 5,000-line diff at the end
• Context that fits — focused RFCs work within context limits far better than "here's my whole idea, build it"
• Traceability & knowledge preservation — every implementation traces to a requirement, and the docs outlive any one chat session, team member, or model
• Shared mental model — business stakeholders, developers, and AI tools all work from the same documents

"Doesn't my coding agent already plan?"

Yes — tactically. This workflow shipped in March 2025, before planning modes existed in any AI coding agent, and it solves a different problem than they do:

The two compose rather than compete: /generate-rfcs decides what the next unit of work is, and each /implement-rfc hands your agent's planner a well-scoped, context-sized task — exactly what plan mode is good at.

Sweet spot: greenfield products, multi-week builds, and anyone building something real with AI — where scope creep and forgotten decisions, not code quality, are what kill the project. For a small fix in an existing codebase, your agent alone is fine. For everything bigger, write the spec first.

Examples

The examples/url-shortener folder contains complete sample outputs for each step of the workflow:

• PRD — Product Requirements Document
• Features — Extracted features with MoSCoW prioritization
• Rules — Development standards and guidelines
• RFCs — Implementation units (3 RFCs)

Compatibility

The prompts are plain markdown and work with any modern LLM:

• Claude (Anthropic) — Claude 4 and Claude 5 families
• GPT (OpenAI) — GPT-4o, GPT-5 family
• Gemini (Google) — Gemini 2.5 and later
• Open models — Llama, Mistral, Qwen, DeepSeek (with sufficient context)

Tool support:

• Native slash commands: Claude Code, Cursor (via install.sh)
• Copy-paste: Windsurf, GitHub Copilot, Codex CLI, Cline, Aider, or any chat interface (manually or via ./copy-prompt.sh <prompt-file>)

Quick Tips

• Provide complete documents when possible and answer the AI's clarifying questions
• Review and customize AI outputs before implementation — the approval gate in /implement-rfc exists for a reason
• Implement RFCs strictly in order; each builds on the previous ones
• Keep RULES.md referenced from your agent config so standards stay in context

Contributing

See CONTRIBUTING.md for guidelines on submitting new prompts, quality standards, and testing approach.

Star History

If this workflow saves you time, a ⭐ helps others find it.

License

This project is licensed under the MIT License — see the LICENSE file for details.

Made with care for better product development with AI