/blueprint:prp-execute

Execute a PRP (Product Requirement Prompt) with systematic implementation, validation gates, TDD workflow, and quality assurance.

Usage:

/blueprint:prp-execute [prp-name]

Prerequisites:

PRP exists in
```
docs/prps/[prp-name].md
```
Confidence score >= 7 (if lower, suggest
```
/blueprint:prp-create
```
refinement)

For detailed report templates, deferred items workflow, feature tracker sync, and error handling patterns, see REFERENCE.md.

When to Use This Skill

Use this skill when...	Use alternative when...
Ready to implement a planned feature from a PRP	PRP is not yet ready (confidence < 7)
Want to execute with full validation and TDD workflow	Implementing ad-hoc features without documentation
Need feature tracker and GitHub issue tracking	Working on isolated bug fixes
Want automatic progress reporting and deferred items tracking	Quick prototyping without formal tracking

Context

PRP file path: !

find . -maxdepth 1 -name \'docs/prps/${1:-unknown}.md\' 2>/dev/null

PRP confidence score: !

grep -m1 "^confidence:" docs/prps/${1:-unknown}.md 2>/dev/null

Feature tracker enabled: !

test -f docs/blueprint/feature-tracker.json 2>/dev/null

Current branch: !

git rev-parse --abbrev-ref HEAD 2>/dev/null

Uncommitted changes: !
```
git status --porcelain 2>/dev/null
```

Parameters

Parse

$ARGUMENTS

```
prp-name
```
(required): Name of PRP file in
```
docs/prps/
```
(without .md extension)
- Example:
```
feature-auth-oauth2
```
  → loads
```
docs/prps/feature-auth-oauth2.md
```

Execution

Execute the complete PRP implementation workflow:

Step 1: Load and validate PRP

Read PRP file:
```
docs/prps/{prp-name}.md
```
Extract confidence score from frontmatter
If confidence < 7 → Error: "PRP confidence too low. Run
```
/blueprint:prp-create {prp-name}
```
to refine"
If confidence >= 9 → Offer delegation: "This PRP has high confidence. Execute now (current session) or create work-order for delegation?"
- If work-order chosen → Run
```
/blueprint:work-order --from-prp {prp-name}
```
  and exit
- If delegation to multiple subagents chosen → Create focused work-orders per module from Implementation Blueprint and exit
Continue to Step 2 if executing now OR confidence 7-8
Load all referenced ai_docs entries for context
Parse Implementation Blueprint and create TodoWrite entries ordered by dependencies

Step 2: Establish baseline with validation gates

Run pre-implementation validation gates (see REFERENCE.md) to establish clean starting state:

Linting gate:
```
[command from PRP]
```
- Expected: PASS
Existing tests gate:
```
[command from PRP]
```
- Expected: PASS

If gates fail:

Document existing issues
Decide: fix first or proceed with note
Continue when ready

Step 3: Execute TDD implementation cycle

For each task in Implementation Blueprint:

RED phase: Write failing test matching PRP TDD Requirements
- Create test file if needed
- Run tests → Confirm FAILURE (test is meaningful)
GREEN phase: Implement minimal code to pass test
- Follow Codebase Intelligence patterns from PRP
- Apply patterns from ai_docs references
- Watch for Known Gotchas
- Run tests → Confirm SUCCESS
REFACTOR phase: Improve code while keeping tests green
- Extract common patterns
- Improve naming, add type hints
- Follow project conventions
- Run tests → Confirm PASS
- Run validation gates frequently (not just at end)
Mark progress: Update TodoWrite:
```
✅ Task N: [Description]
```

Step 4: Run comprehensive final validation

Execute all validation gates from PRP (see REFERENCE.md):

Linting:
```
[cmd]
```
- Expected: PASS
Type checking:
```
[cmd]
```
- Expected: PASS
Unit tests:
```
[cmd]
```
- Expected: PASS (all tests)
Integration tests:
```
[cmd]
```
- Expected: PASS (if applicable)
Coverage check:
```
[cmd]
```
- Expected: Meets threshold
Security scan:
```
[cmd]
```
- Expected: No high/critical issues (if applicable)
Performance tests:
```
[cmd]
```
- Expected: Meets baseline (if defined)

Verify each success criterion from PRP.

Step 5: Document deferred items

Identify and track any deferred work:

Review Implementation Blueprint - items not completed
Categorize each deferred item:
- Phase 2 (Required): Must have GitHub issues created
- Nice-to-Have: Optional, no issue required
- Blocked: Cannot complete - document blocker, create issue
Create GitHub issues for all Phase 2 and Blocked items (see REFERENCE.md)
Update PRP with deferred items section linking to GitHub issues
Do NOT proceed to Step 6 until all required issues are created

Step 6: Sync feature tracker (if enabled)

If feature tracker exists (

docs/blueprint/feature-tracker.json

Identify which feature codes (e.g., FR2.1) were addressed from PRP
Update feature tracker for each code:
- Status:
```
complete
```
  (all criteria met) or
```
partial
```
  (some criteria met) or
```
in_progress
```
- Files: List of modified/created files
- Tests: List of test files
- Commits: Commit hashes
- Notes: Implementation notes
Recalculate statistics: completion percentages, phase status
Update TODO.md: Check boxes for completed features
Report feature tracker changes

Step 7: Report results and next steps

Generate comprehensive execution summary report:

Tasks completed: X/Y
Tests added: N
Files modified: [list]
Validation results: Table of all gates (PASS/FAIL status)
Success criteria: All verified
Deferred items summary: Count and GitHub issue numbers
Feature tracker updates: Features updated and percentages
New gotchas discovered: [documented for future reference]
Recommendations: Follow-up work or ai_docs updates

Prompt user for next action:

Commit changes (Recommended) → Run
```
/git:commit
```
Create work-order for follow-up → Run
```
/blueprint:work-order
```
Update ai_docs with patterns → Run
```
/blueprint:curate-docs
```
Continue to next PRP → Run
```
/blueprint:prp-execute [next]
```
Done for now → Exit

Agentic Optimizations

Context	Command
Check PRP exists	`test -f docs/prps/${1}.md && echo "EXISTS" \|\| echo "MISSING"`
Extract confidence	`head -50 docs/prps/${1}.md \| grep -m1 "^confidence:" \| sed 's/^[^:]:[[:space:]]//'`
List all PRPs	`ls docs/prps/*.md 2>/dev/null \| xargs basename -s .md`
Check feature tracker	`test -f docs/blueprint/feature-tracker.json && echo "YES" \|\| echo "NO"`
Fast validation	Run validation gates in parallel when possible

For detailed validation gate definitions, deferred items workflow, error handling procedures, and agent team coordination, see REFERENCE.md.

blueprint-prp-execute

NPX Install

Tags

SKILL.md Content