Index of every page on this site: llms.txt
All skills
Run it yourself

Use when creating, updating, validating, or phasing a PRD. Drives interactive discovery, technical architecture, phasing DAG, TDD protocol, and dependency analysis. Keywords: PRD, product requirements, feature planning, acceptance criteria, MoSCoW, phasing, requirements document. Triggers on "create PRD" or "update requirements".

Requires /orchestrate
Use this Skill: https://skilld.dev/gh/acedergren/agentic-tools/prd

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈84 tokens for metadata: the name and description. ≈1.1k when used: this file. ≈2.5k more on demand in 3 files.

Description uses 4.2% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈337 characters, or 4.2%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

PRD Skill

When to Use

Load this skill when the user request matches the frontmatter description for PRD Skill.

Produce drift-proof Product Requirements Documents through iterative discovery.

Output: .claude/reference/PRD.md (living requirements document for the project).

Do NOT load when

  • user has a final spec and only wants implementation planning (use /orchestrate or /prd --to-plan)
  • task is a code review or repo health check
  • request is a lightweight note or issue, not a full requirements document

NEVER

  • Never generate a PRD without scanning the codebase first — requirements that contradict existing architecture produce unimplementable specs
  • Never write acceptance criteria as "should work correctly" — use Given/When/Then; untestable criteria cannot be verified at phase completion
  • Never skip dependency analysis — untracked dependencies produce phases that can't be parallelized safely
  • Never batch all discovery questions into one wall of text — max 4 questions per round; users disengage from interrogations
  • Never assume a library version — check package.json and npm; version assumptions produce broken phase plans
  • Never write phasing without dependency arrows — phases must be a DAG; implicit ordering creates unmergeable parallel work
  • Never leave [NEEDS CLARIFICATION] markers in a finalized PRD — they signal a spec that cannot drive implementation

Mode routing

Argument Mode Description
(empty) Create Interactive PRD creation from scratch
<feature text> Create Start with context, then iterate
--update Update Incremental update to existing PRD
--validate Validate Run validation checklist on existing PRD
--audit-deps Audit Dependency/drift analysis only
--to-plan Plan Generate orchestrate-ready task plan

Create mode

Phase 1 — Codebase scan (automatic, before any questions)

Launch an Explore agent to map relevant codebase areas. Read roadmap/changelog for prior decisions. Check for outdated dependencies in scope. This prevents asking questions the codebase already answers.

Phase 2 — Interactive discovery (2–4 rounds, max 4 questions each)

  • Round 1: Problem, who, success criteria, personas
  • Round 2: MoSCoW priorities, explicit out-of-scope, interactions
  • Round 3: Architecture constraints, database, auth, performance
  • Round 4 (if needed): Phasing, parallelization risks

Never draft before Round 2. Never ask what the codebase scan already answered.

Phase 3 — Draft

Read template.md. Write to .claude/reference/PRD.md. Mark gaps [NEEDS CLARIFICATION: ...]. Populate Architecture Decisions (AD-N entries). Build phasing DAG with explicit arrows.

Phase 4 — Validation

Read validation.md, run every check. Present pass/fail. Iterate until critical gates pass.

Phase 5 — Finalize

Remove all markers. Commit: docs(prd): add <feature-name> requirements.

Update mode (--update)

  1. Read existing PRD
  2. Ask what changed (new requirement, scope change, dependency update)
  3. Launch Explore agent to detect codebase drift since last PRD update
  4. Generate diff-style updates: [ADDED], [CHANGED], [REMOVED], [DRIFT DETECTED]
  5. Present for approval, apply, re-validate

Plan mode (--to-plan)

Transforms PRD phasing into an /orchestrate-ready task plan at docs/plans/<feature-name>-plan.md.

Wave assignment rules:

  • Wave 1: Schemas, types, migrations, config (foundation)
  • Wave 2: Routes, services, repositories (implementation)
  • Wave 3: Wiring, UI, end-to-end flows (integration)
  • Wave 4: Error handling, edge cases, docs (polish)

Agent assignment rules:

  • haiku: Type definitions, config, simple CRUD, test writing
  • sonnet: Business logic, complex integrations, security-sensitive code

Requires V5 (DAG) validation to pass before generating the plan.

Validate mode (--validate)

Read validation.md and run all gates. Print pass/fail with line references.

Audit-deps mode (--audit-deps)

Read drift-prevention.md and run dependency freshness + architectural drift checks.

Scripts

bash scripts/check-prd-assets.sh skills/prd
node scripts/list-prd-phases.js .claude/reference/PRD.md

Arguments

  • /prd — interactive creation
  • /prd Workflow Designer — start with context
  • /prd --update — incremental update
  • /prd --validate — run validation only
  • /prd --audit-deps — dependency audit only
  • /prd --to-plan — generate orchestrate-ready task plan

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning7mo5 checks · Risk SAFE
  • Gen Agent Trust Hub8mo

    The skill manages Product Requirements Documents (PRDs) and includes features for creation, validation, and task planning. A low-severity risk of indirect prompt injection exists because the skill reads content from a PRD file to generate task plans that include verification commands. If the PRD file is maliciously crafted by an external actor, it could influence the generated commands or validation reports.

  • Socket8mo

    No alerts

  • Snyk8mo

    Risk: MEDIUM · 1 issue

  • Runlayer8mo

    1/6 files flagged

  • ZeroLeaks7mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at 641a79b. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last month.

Steadyupdated 6 months ago

README badge

README badge for acedergren/agentic-tools/prd