📋 AI PRD Workflow

RFC-driven development for AI coding agents

Vague idea → verified PRD → features → rules → sequenced RFCs → reviewed, tested code

Quick Start · Workflow · Commands · Why RFCs? · Examples

RFC-driven since March 2025 — before planning modes existed in any AI coding agent.

A lightweight RFC-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 RFC-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. If you've heard of spec-driven development (GitHub Spec Kit, Amazon Kiro), this is the same philosophy — and this workflow predates both — with sequenced RFCs as the unit of work and no framework or CLI to adopt. Structured specs fix the real problems:

• 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 testin