PRP — Product Requirements Prompt (framework)

Checked 2026-09-30

The PRP approach is maintained in the open-source repo Wirasm/PRPs-agentic-eng (MIT; ~2.3k stars, 605 forks, 263 commits on its development branch, active). It has evolved from copy-paste prompt templates into Claude Code skills (plugin prp-core, or copy into .claude/skills/) with artefacts under ~/.prp/<project-key>/ and commands /prp-prd, /prp-plan, /prp-implement, /prp-loop (autonomous PRD-plan-implement-review loop), /prp-review, /prp-issue, /prp-debug, /prp-codebase-question, /prp-research-team, /prp-maintainer-triage. The “circa 2024” origin below is the original note’s claim and is unverified. The “Status notes” at the bottom (draft / WIP) are stale.

Summary

PRP (Product Requirements Prompt) is a structured framework for encoding product requirements specifically for AI coding assistants. It adapts the discipline of product requirements (PRD) to the needs of large language models by combining three core elements: a concise product requirements document, curated codebase intelligence, and an agent runbook. The goal is to provide the “minimum viable packet of information” that an AI needs to reliably produce production-ready code with fewer iterations.

Definition

PRP = Product Requirements Document (PRD) + Curated Codebase Intelligence + Agent Runbook

• Product Requirements Document: What to build and why (goals, constraints, acceptance criteria) but prepared for machine consumption.
• Curated Codebase Intelligence: Targeted examples, file paths, API snippets, and patterns from the existing repository that demonstrate how to implement features consistently with project conventions.
• Agent Runbook: Step-by-step execution instructions, checks, tests to run, and guardrails for the AI to follow when making changes.

Background & Rationale

Traditional PRDs are written for humans and intentionally avoid implementation details. LLMs, however, perform much better when given explicit technical context and examples. PRP emerged (original note says circa 2024; unverified) from the need to bridge this gap for AI-assisted development on real, mature codebases. Instead of “vibe coding” or ad-hoc prompting, PRP treats the AI like a new team member and provides a compact, high-signal briefing that includes both the why and the how.

Core Components (expanded)

1. Product Requirements (PRD for AI)
   • Objective(s) and high-level user stories
   • Acceptance criteria (clear, testable)
   • Non-functional constraints (performance, security, compatibility)
   • Scope and out-of-scope items
2. Curated Codebase Intelligence
   • Short, relevant code snippets and canonical file locations
   • Patterns and idioms used in the codebase (naming, error-handling, logging)
   • Relevant tests and fixtures
   • Dependency versions and infra notes (DB schema, API contracts)
3. Agent Runbook
   • Step-by-step plan for the AI (what to modify, where, and why)
   • Recommended iterative process (generate → run tests → lint → run integration checks)
   • Safety checks and rollback instructions
   • Suggested commit message templates and PR checklist

How PRP Differs from Traditional PRD and Basic Prompting

• Explicit technical context: PRP embeds code-level examples and references; traditional PRDs do not.
• Actionable execution: The Agent Runbook contains procedural steps, not just goals.
• Optimized for LLMs: Language and structure are chosen to reduce ambiguity for models (e.g., explicit file paths rather than vague references).
• Reduces iteration: By supplying curated context, PRP lowers the number of clarification cycles required.

Implementation: How to write a PRP for an AI coding task

1. Start with a short PRD: 3–5 bullet goals, acceptance criteria, and constraints.
2. Collect curated intelligence: 5–20 short snippets or references to canonical files that the AI should mirror.
3. Write the Agent Runbook: numbered steps the AI should follow, including test commands and validation checks.
4. Add global rules (project-wide) separately: architectural rules, style guides, and persistent conventions.
5. Package everything in a single packet (a structured prompt or a small directory such as ai_docs/): the AI should get the PRP in one shot.
6. Validate: run the generated code against automated tests and review the PR for conformity.

Example PRP skeleton (short)

• Title: Add feature X — server-side pagination for /items
• Goal: Support pagination with cursor tokens to reduce response size and improve UX.
• Acceptance criteria:
  • Endpoint accepts cursor and limit params
  • Returns next_cursor when more results exist
  • Passes existing API integration tests
• Curated code snippets:
  • api/items/handler.py (example of previous cursor-based endpoint)
  • models/item.py (relevant ORM methods)
• Runbook:
  1. Copy existing cursor logic from api/users and adapt to items.
  2. Add unit tests under tests/api/test_items.py following pattern in tests/api/test_users.py.
  3. Run pytest -q and black --check.
  4. If tests fail, iterate once; if still failing, stop and request human review.

Best Practices & Tips

• Keep PRDs concise but complete; more verbosity helps only if it’s high-signal and actionable.
• Provide canonical examples rather than the entire codebase; targeted snippets are more effective.
• Separate project-wide rules (global) from task-specific PRPs to avoid repetition.
• Include test commands and exact CI steps in the runbook so the AI can validate its output.
• Use explicit acceptance criteria framed as automated checks when possible.

Limitations & Risks

• Overtrust: PRP can lead to overreliance on AI-generated code; human review is still essential.
• Staleness: Curated intelligence must be kept up-to-date or the AI will follow outdated patterns.
• Security & privacy: Ensure sensitive secrets or credentials are never embedded in prompts.
• Complexity ceiling: For extremely novel designs or ambiguous requirements, PRP may not eliminate iteration.

Tools & Supporting Platforms

PRP is a framework rather than a product. It is most effective when used with AI assistants that support persistent context, explicit file references, and agentic flows. Examples of tools and capabilities that help:

• Assistants with project-context windows or workspace awareness (editor-integrated or IDE copilots)
• Repositories with ai_docs/ or structured developer docs to export curated intelligence
• CI systems that can be invoked from runbooks for validation

Further reading / search terms

Search for:

• “Product Requirements Prompt” or “PRP” framework
• “context engineering” + “AI coding”
• “PRP = PRD + Curated Codebase Intelligence + Agent Runbook”

Suggested sources (search these titles to find current articles and repos):

• Articles on PRP framework and context engineering (summer 2024 origin)

• Posts titled “PRP Framework — code reliably 10x faster with AI” and related GitHub repos

---

Status notes

• Created as draft (WIP) for review. Once approved, I can set status: OK and share: true, and add explicit reference links to primary sources.

Sources

• https://github.com/Wirasm/PRPs-agentic-eng (accessed 2026-09-30)