prd · sethgammon — Claude Code skill for app requirements
prd turns an app idea into a structured product requirements document, asking about decisions that affect its shape. Use it before handing a project plan to Archon.
MIT ★ 937 updated 2026-10-29
/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-localWhat prd does
The skill turns a plain-language app or feature brief into a PRD with users, core features, technical choices, architecture, and completion checks. For an existing codebase, it inspects the file tree and package manifest first, then treats the current stack as fixed and documents integration points. Feature plans also include checks for existing tests and type errors.
The document goes to .planning/prd-{slug}.md. When a concept has established examples, the skill can use /research to look at reference apps; simple ideas such as a landing page skip that step. It presents the main choices for review before the PRD is ready for Archon. Version-one scope is capped at five core features, and completion conditions must be machine-verifiable. If .planning/ cannot be created, the skill presents the PRD inline and suggests /do setup.
What it helps with
- turn an app brief into a structured requirements document
- surface questions that could change the architecture
- set version-one boundaries and verifiable completion checks
- map a new feature onto an existing codebase
Example prompts for the agent
- /prd Draft requirements for a personal expense-tracking app from scratch.
- /prd Plan an authentication feature in this existing project; inspect its files and keep the current stack.
- /prd Create a PRD for a booking service and research established apps with similar features.
How to install prd
1Plugin marketplace
/plugin marketplace add SethGammon/Citadel/plugin install citadel@citadel-localThis installs the whole citadel plugin with all its skills
2Skills CLI (Vercel)
npx skills add SethGammon/Citadel --skill prd -a claude-code3Manually: put the files in place
~/.claude/skills/prd/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/prd/
1Skills CLI (Vercel)
npx skills add SethGammon/Citadel --skill prd -a codex2Manually: put the files in place
.agents/skills/prd/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add SethGammon/Citadel --skill prd -a cursor2Manually: put the files in place
.cursor/skills/prd/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install SethGammon/Citadel skills/prd2Manually: put the files in place
.github/skills/prd/SKILL.md1Skills CLI (Vercel)
npx skills add SethGammon/Citadel --skill prd -a gemini-cli2Platform CLI
gemini skills install https://github.com/SethGammon/Citadel --path skills/prdManually: put the files in place
.devin/skills/prd/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about prd
How do I install prd in Claude Code?
Add the marketplace with /plugin marketplace add SethGammon/Citadel, then install the plugin with /plugin install citadel@citadel-local.
What does the prd skill do?
It asks about an app or feature brief and writes a PRD covering scope, technical choices, architecture, and completion checks. The document can guide work in Archon.
How does prd handle an existing project?
It checks the project structure and package manifest, keeps the existing stack in place, and describes where the feature connects to the code. Its completion checks include passing existing tests and avoiding new type errors.
Source text
SKILL.md · MIT
---
name: prd
license: MIT
description: >-
Generates a Product Requirements Document from a natural language app description.
Asks clarifying questions, researches similar apps, defines scope, stack, architecture,
and produces a structured PRD that Archon can decompose into a campaign.
user-invocable: true
auto-trigger: false
trigger_keywords:
- prd
- requirements
- spec
- plan an app
- design an app
effort: high
---
# /prd — Product Requirements Document Generator
## When to Use
**Don't use when:** architecture is already defined and you need implementation (use /architect then /archon); adding a small feature to an existing app (use /marshal directly).
- User describes an app or feature to build (greenfield or feature mode)
- Before any Archon campaign for a new project or feature
## Mode Detection
Before starting, determine the mode:
**Greenfield mode**: No existing source files, or user explicitly says "new app" / "from scratch."
Produces a full PRD as described below.
**Feature mode**: The project already has source files (check for `src/`, `app/`, `lib/`,
`package.json` with dependencies, or similar). The user describes a feature to add, not a
whole app ("add auth", "add a dashboard", "add payment processing").
In feature mode:
- Read the existing file tree and `package.json`/equivalent before asking questions
- The existing stack is a given — don't recommend alternatives
- "Architecture" section describes integration points with existing code, not standalone shape
- End conditions MUST include regression checks: "existing tests still pass", "typecheck has no new errors"
- "Out of Scope" is relative to the feature, not the whole app
- Technical Decisions only covers decisions the feature introduces (new dependencies, new patterns)
The PRD template below works for both modes. Feature mode just scopes it tighter.
## Protocol
### Step 1: UNDERSTAND
Determine mode (greenfield vs feature). Identify core functionality, target user, and success criteria (greenfield) or integration points and existing stack (feature). Ask up to 3 questions — only those that would change the architecture. Do not ask about tech stack in greenfield mode; in feature mode, the stack is already decided.
### Step 2: RESEARCH (Optional)
If the concept has well-known implementations, run /research to identify 2-3 reference apps and common expected features. Skip for simple concepts (landing page, personal tool, CRUD).
### Step 3: DEFINE
Produce a structured PRD. Write to `.planning/prd-{slug}.md`:
```markdown
# PRD: {App Name or Feature Name}
> Description: {One sentence}
> Author: {user}
> Date: {ISO date}
> Status: draft
> Mode: {greenfield | feature}
## Problem
{What problem does this solve? Why does the user want it?}
## Users
{Who uses this? One or two user types max.}
## Core Features
{Numbered list. Maximum 5 for v1. Each feature is one sentence.}
1. {Feature}: {what it does}
2. ...
## Out of Scope (v1)
{Things the user might expect but should NOT be built yet.
Being explicit about what's out prevents scope creep.}
## Technical Decisions
- **Frontend**: {recommendation with reasoning}
- **Backend**: {recommendation with reasoning, or "none" for static apps}
- **Database**: {recommendation with reasoning, or "none"}
- **Auth**: {recommendation, or "none" if no user accounts}
- **Deployment**: {recommendation}
{In feature mode, only list decisions the feature introduces.
Existing stack decisions are inherited, not re-evaluated.}
## Architecture
{High-level description. 3-5 sentences max. How the pieces connect.
NOT a file tree. NOT implementation details. Just the shape.}
{In feature mode: describe integration points with existing code.
"The new auth middleware hooks into the existing Express router at
src/routes/index.ts. User model extends the existing Prisma schema."}
## Integration Points (feature mode only)
{Skip this section in greenfield mode.}
- **Existing files modified**: {list of files the feature will touch}
- **New files created**: {list of new files}
- **Dependencies added**: {new packages, if any}
- **Patterns followed**: {existing patterns in the codebase this feature should match}
## End Conditions (Definition of Done)
{Machine-verifiable conditions that mean the feature/app is complete.}
- [ ] {condition 1: e.g., "Landing page renders at localhost:3000"}
- [ ] {condition 2: e.g., "User can create account and log in"}
- [ ] {condition 3: e.g., "Core feature X works end-to-end"}
{In feature mode, ALWAYS include these regression conditions:}
- [ ] Existing tests pass with 0 new failures
- [ ] Typecheck passes with 0 new errors
## Open Questions
{Anything the PRD author couldn't decide. These become questions
for the user before the campaign starts.}
```
### Step 4: REVIEW
Present: core features, tech stack decisions, out of scope, end conditions. Ask if it matches. On approval: PRD is ready for Archon. On changes: update and re-present changed sections only.
## Contextual Gates
**Disclosure:** "Generating PRD for [description]. Creates `.planning/prd-{name}.md`."
**Reversibility:** green — creates `.planning/prd-{slug}.md` only; undo by deleting the file.
**Trust gates:**
- Any: full PRD generation, clarifying questions, review cycle.
## Quality Gates
- Every Core Feature is one sentence
- Every technical decision has a reasoning ("because")
- End conditions are machine-verifiable
- Out of Scope has at least 2 items
- No more than 5 core features for v1
## Fringe Cases
**Vague description**: Ask up to 3 clarifying questions. Never produce a PRD with placeholder end conditions.
**Feature mode but no existing code**: Confirm with the user — switch to greenfield if confirmed.
**User says "skip the PRD"**: Even a minimal PRD is needed. Offer a 1-page express PRD (Tier 4 style).
**If .planning/ does not exist**: Create it before writing. If not possible, present inline and suggest `/do setup`.
## Exit Protocol
```
---HANDOFF---
- PRD: {app name}
- Document: .planning/prd-{slug}.md
- Status: {approved | needs-revision}
- Next: Run `/do build {app name}` or `/archon` with the PRD as direction
- Reversibility: green — delete .planning/prd-{slug}.md to undo
---
```
## Stack Selection Principles
Make opinionated recommendations with reasoning. Defaults: Next.js + Tailwind + shadcn/ui for web; Node/Express for JS backends, FastAPI for Python; SQLite for simple, PostgreSQL for multi-user; simplest auth for the stack. Always explain why.
Deployment defaults: static → Vercel/Netlify; full-stack with DB → Railway; API only → Railway or Fly.io; not deploying yet → local only. See `.planning/_templates/deploy/` for platform details.
© SethGammon · MIT · SethGammon/Citadel
Similar skills
SKILL.md skills catalog →prd by other authors comes first.