Using a single command without external references

[IbraheemAlSaady]

I've been using your system for a while, and it's been working magic for me.

One thing I want to brainstorm is the following: due to the referencing of the template file and the PRP README.md file, I have to repeat the same files/commands/templates across all projects I have. Ideally, I'd like to put this in my root .claude and just use it across all my projects. If something needs to change, I just update the root command, something similar to what SuperClaude framework does

What do you think?

[Wirasm]

This is a good idea! i actually am about to scrap the prps/readme and make it into a system prompt addition, in its current form it sometimes is the root of claudes overengineering tendencies.

If you have any ideas of how to make it work you are more than welcome to make a PR @IbraheemAlSaady

[IbraheemAlSaady]

@Wirasm I actually your initial document to become a single prp commands. I'll put it in a comment below as it's a markdown so I can keep formatting. I included a usage snippet part of the command. been using it for 3 weeks now

[IbraheemAlSaady]

---

allowed-tools: [Read, Grep, Glob, Write, Edit]
description: "Create comprehensive PRP enabling one-pass implementation success through systematic research and embedded templates."

/prp:create - Condensed PRP Creation System

Product Requirement Prompt (PRP) Concept

"Over-specifying what to build while under-specifying the context, and how to build it, is why so many AI-driven coding attempts stall at 80%. A Product Requirement Prompt (PRP) fixes that by fusing the disciplined scope of a classic Product Requirements Document (PRD) with the “context-is-king” mindset of modern prompt engineering."

What is a PRP?

Product Requirement Prompt (PRP)
A PRP is a structured prompt that supplies an AI coding agent with everything it needs to deliver a vertical slice of working software—no more, no less.

How it differs from a PRD

A traditional PRD clarifies what the product must do and why customers need it, but deliberately avoids how it will be built.

A PRP keeps the goal and justification sections of a PRD yet adds three AI-critical layers:

Context

• Precise file paths and content, library versions and library context, code snippets examples. LLMs generate higher-quality code when given direct, in-prompt references instead of broad descriptions. Usage of a ai_docs/ directory to pipe in library and other docs.

Implementation Details and Strategy

• In contrast of a traditional PRD, a PRP explicitly states how the product will be built. This includes the use of API endpoints, test runners, or agent patterns (ReAct, Plan-and-Execute) to use. Usage of typehints, dependencies, architectural patterns and other tools to ensure the code is built correctly.

Validation Gates

• Deterministic checks such as pytest, ruff, or static type passes “Shift-left” quality controls catch defects early and are cheaper than late re-work.
  Example: Each new funtion should be individaully tested, Validation gate = all tests pass.

PRP Layer Why It Exists

• The PRP folder is used to prepare and pipe PRPs to the agentic coder.

Why context is non-negotiable

Large-language-model outputs are bounded by their context window; irrelevant or missing context literally squeezes out useful tokens

The industry mantra “Garbage In → Garbage Out” applies doubly to prompt engineering and especially in agentic engineering: sloppy input yields brittle code

In short

A PRP is PRD + curated codebase intelligence + agent/runbook—the minimum viable packet an AI needs to plausibly ship production-ready code on the first pass.

The PRP can be small and focusing on a single task or large and covering multiple tasks.
The true power of PRP is in the ability to chain tasks together in a PRP to build, self-validate and ship complex features.

Core Mission

Create comprehensive PRP enabling one-pass implementation success through systematic research and embedded templates.

Research Process

1. Codebase Analysis: Spawn agents to find similar patterns, existing conventions, test patterns
2. External Research: Spawn agents for library docs, examples, best practices with specific URLs
3. Context Curation: Apply "No Prior Knowledge" test - would someone unfamiliar with codebase succeed?

Embedded Template Structure

# PRP Template - All sections required for implementation success
Goal:
  feature_goal: "[Specific, measurable end state]"
  deliverable: "[Concrete artifact - API endpoint, service class, etc.]"
  success_definition: "[How you'll know this is complete]"

Context:
  documentation:
    - url: "[Complete URL with section anchor]"
      why: "[Specific methods/concepts needed]" 
      critical: "[Key insights preventing errors]"
    - file: "[exact/path/to/pattern.py]"
      pattern: "[Specific pattern to follow]"
      gotcha: "[Known constraints to avoid]"
  
  current_tree: "[Run tree command output]"
  desired_tree: "[Files to add with responsibilities]"
  
  gotchas: |
    # CRITICAL: [Library] requires [specific setup]
    # PATTERN: [Common approach in this codebase]

Implementation:
  data_models: "[Pydantic/ORM models needed]"
  
  tasks:
    - task: "CREATE src/models/{domain}_models.py"
      implement: "[Specific classes/methods]"
      follow: "[Pattern file reference]"
      naming: "[Exact conventions]"
      placement: "[Directory structure]"
    
    # Continue task sequence...
  
  patterns: |
    # Show critical code patterns - focus on non-obvious details
    async def {operation}(request: {Type}) -> {Response}:
        # PATTERN: [Reference existing file]
        # GOTCHA: [Library constraint]
        return {Response}(data=result)

Validation:
  level_1: "[Syntax commands: ruff, mypy, format]"
  level_2: "[Unit test commands: pytest specific paths]" 
  level_3: "[Integration: curl, service startup, health checks]"
  level_4: "[Domain-specific: MCP, performance, security tests]"
  
  checklist:
    technical: "[All validation levels pass]"
    feature: "[Success criteria met]"
    quality: "[Patterns followed, anti-patterns avoided]"

Anti_Patterns:
  - "Don't create new patterns when existing work"
  - "Don't skip validation - fix failures"
  - "Don't ignore async/sync mismatches"

Condensed Creation Logic

Research Strategy (Embedded)

RESEARCH_PATTERNS = {
    "api": ["@app.route", "@router", "FastAPI", "endpoint"],
    "database": ["Model", "Session", "query", "ORM", "migration"],
    "auth": ["jwt", "token", "login", "middleware", "decorator"],
    "testing": ["pytest", "fixture", "mock", "assert"]
}

VALIDATION_COMMANDS = {
    "syntax": "ruff check {files} --fix && mypy {files} && ruff format {files}",
    "unit": "uv run pytest {test_path} -v",
    "integration": "curl -f http://localhost:8000/health",
    "domain": "# Project-specific commands based on feature type"
}

Quality Gates (Essential Only)

QUALITY_CHECKS = [
    "Passes 'No Prior Knowledge' test",
    "All references are specific and actionable", 
    "Tasks include exact naming and placement",
    "Validation commands are project-specific",
    "Implementation tasks follow dependency order"
]

Single Command Usage

Auto-Generate Complete PRP

/prp:create "user authentication with JWT" --research-depth deep --template embedded

Execution Flow (Condensed)

1. Analyze: Feature complexity → determine agent count
2. Research: Parallel agent execution using embedded patterns
3. Generate: Fill embedded template with research findings
4. Validate: Apply embedded quality gates
5. Output: Complete, actionable PRP file

Template Population Logic

def create_prp(feature_description):
    # Step 1: Complexity analysis
    complexity = analyze_complexity(feature_description)
    
    # Step 2: Spawn research agents
    agents = spawn_agents(complexity, RESEARCH_PATTERNS)
    results = await gather_research(agents)
    
    # Step 3: Fill template
    prp = EMBEDDED_TEMPLATE.format(
        feature_goal=extract_goal(results),
        documentation=format_docs(results.external),
        tasks=generate_tasks(results.codebase),
        patterns=extract_patterns(results.codebase),
        validation=customize_validation(results.project_type)
    )
    
    # Step 4: Quality validation
    validate_against_gates(prp, QUALITY_CHECKS)
    
    return prp

Context Optimization Strategies

1. Reference Compression

Instead of:

- url: https://fastapi.tiangolo.com/tutorial/dependencies/dependencies-in-path-operation-decorators/
  why: Understanding how to implement dependency injection for database sessions in FastAPI endpoints
  critical: Must use Depends() for proper session management and automatic cleanup

Use:

- url: https://fastapi.tiangolo.com/tutorial/dependencies/#dependencies-in-path-operation-decorators
  why: "Dependency injection for DB sessions"
  critical: "Use Depends() for session cleanup"

2. Pattern Essentials Only

Instead of verbose explanations, use:

# PATTERN: src/services/user_service.py - async service class structure
# GOTCHA: Always use async/await with database operations
# NAMING: {Domain}Service class, create_*/get_*/update_*/delete_* methods

3. Task Compression

Task 1: "CREATE src/models/auth_models.py"
  impl: "UserRequest/Response Pydantic models"  
  follow: "src/models/user_model.py"
  naming: "CamelCase classes, snake_case fields"

4. Validation Shortcuts

# L1: ruff check src/ --fix && mypy src/ && ruff format src/
# L2: uv run pytest src/services/tests/ -v  
# L3: curl -f localhost:8000/health && test endpoints
# L4: # Domain-specific based on feature type

Embedded Documentation (Minimal)

Common Patterns (Essential Only)

# FastAPI Endpoint Pattern
@router.post("/resource", response_model=Response)
async def create(req: Request, db: Session = Depends(get_db)):
    return await service.create(req, db)

# Service Pattern  
class ResourceService:
    async def create(self, req: Request, db: Session) -> Response:
        # Input validation → Business logic → Return response
        
# Test Pattern
def test_create_success():
    # Arrange → Act → Assert

Critical Gotchas (Project-Specific)

# MCP: Use @app.tool() decorator for tool functions
# FastAPI: Always async for database operations  
# Pydantic: Use Field() for validation constraints
# Testing: Use AsyncClient for API testing

Benefits of Condensed Approach

1. Reduced Context Size: ~70% smaller while maintaining all essential information
2. Faster Processing: Less text for Claude Code to parse and understand
3. Focused Content: Only actionable information, no explanatory fluff
4. Pattern Recognition: Compressed patterns easier to match and apply
5. Single Source: Everything needed in one condensed command

Arguments

• feature - The feature that needs to be created, either as a text or as a file
• --verbose - Enable detailed build output

Usage

/prp:create "add user profile image upload" 

/prp:create @task1/feature1.md

/prp:create @feature.md --think --focus architecture --mcp-context7
# → Spawns 2-3 agents, uses file upload patterns, generates minimal PRP