Skip to main content
skill CX Codex

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

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local
Open on GitHub

What 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-local

This installs the whole citadel plugin with all its skills

2Skills CLI (Vercel)

npx skills add SethGammon/Citadel --skill prd -a claude-code

3Manually: put the files in place

~/.claude/skills/prd/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/prd/

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.

prd official github Turns a feature idea into a structured PRD with user stories, technical requirements, and risks. Use it when planning a software feature or an AI-powered one. CX Codex +1 24,035installs prd snarktank prd generates a structured Product Requirements Document for a new feature and saves it to markdown. It clarifies scope with quick questions before any code gets written. CX Codex +1 1,500installs prd smallnest prd turns a feature description into a Product Requirements Document: asks clarifying questions, drafts user stories with acceptance criteria, saves the file under tasks/. CX Codex +1 548installs bmad-prd bmad-code-org bmad-prd is a Claude Code skill that creates, updates, and validates PRDs at the needed level of detail, organizing product requirements into a working document. CX Codex +1 14,600installs create-prd phuryn create-prd — a skill that generates a concise, decision-ready Product Requirements Document using an eight-section template: summary, contacts, background, objective, market segments, value propositions (JTBD-based), solution, and release. CX Codex +1 11,300installs breakdown-feature-prd official github breakdown-feature-prd creates a feature PRD from a parent Epic and a team request. Use it when requirements need to be set before a technical specification is written. CX Codex +1 10,022installs prd-creator pageai The prd-creator skill turns a rough app idea into a PRD with verifiable pass criteria, then breaks it into JSON tasks. Useful when a feature needs writing down before code starts. CX Codex +1 5,600installs prd-development deanpeters prd-development guides you through writing a structured PRD from discovery notes and user research for engineering handoff. Best for major product initiatives. CX Codex +1 4,900installs 3-prd challengepost 3-prd turns an approved scope into a product definition through a focused interview. Sets up interface behavior without discussing code. CX Codex +1 1,800installs

From the same set55

The whole set →
architect architect turns a PRD or task outline into an implementation plan with file trees, data models, and phased build steps. CX Codex +1 ★ 937repo stars cost See token usage and costs for sessions, campaigns, and time periods. Use it to check where spend is going and how quickly it is rising. CX Codex +1 ★ 937repo stars merge-review merge-review scans the fleet worktree merge queue, flags files touched by more than one branch, and suggests a merge order before anything lands in main. CX Codex +1 ★ 937repo stars deploy-steward deploy-steward serializes PR merges into main, tracks CI gates, triggers deploys, and files repair tasks when checks fail. CX Codex +1 ★ 937repo stars organize organize — a skill that audits and corrects project structure: checks file placement, moves files to match conventions, updates imports. Leaves code inside files untouched. CX Codex +1 ★ 937repo stars create-app create-app — a skill for Claude Code and Codex that builds applications from a single prompt. It routes work across five distinct tiers, passing through PRD, architecture, and verified execution phases. CX Codex +1 ★ 937repo stars postmortem The postmortem skill reviews completed campaigns or incidents using project files, telemetry, and Git history. It shows what failed and which safeguards caught it. CX Codex +1 ★ 937repo stars map map generates a JSON index of a repository's files, exports, imports and dependency graph so an agent can locate relevant code without extra Glob or Grep calls. CX Codex +1 ★ 937repo stars

Project sponsors

Companies that keep this analytics open