Prompt file imported from SpreadZhao/codex-ecc (.codex/prompts/ecc-prp-implement.md). Fill in {{arguments}} before use. Copyright stays with the author.

ECC Command Prompt: /prp-implement

Name: ecc-prp-implement
Author: SpreadZhao

Source: /nix/store/7bmy0z0ymx3hgjbhiiixxi0f43djs56c-source/commands/prp-implement.md

Use this prompt to run the ECC prp-implement workflow in Codex.

Adapted from PRPs-agentic-eng by Wirasm. Part of the PRP workflow series.

PRP Implement

Execute a plan file step-by-step with continuous validation. Every change is verified immediately — never accumulate broken state.

Core Philosophy: Validation loops catch mistakes early. Run checks after every change. Fix issues immediately.

Golden Rule: If a validation fails, fix it before moving on. Never accumulate broken state.

Phase 0 — DETECT

Package Manager Detection

File Exists	Package Manager	Runner
`bun.lockb`	bun	`bun run`
`pnpm-lock.yaml`	pnpm	`pnpm run`
`yarn.lock`	yarn	`yarn`
`package-lock.json`	npm	`npm run`
`pyproject.toml` or `requirements.txt`	uv / pip	`uv run` or `python -m`
`Cargo.toml`	cargo	`cargo`
`go.mod`	go	`go`

Validation Scripts

Check package.json (or equivalent) for available scripts:

# For Node.js projects
cat package.json | grep -A 20 '"scripts"'

Note available commands for: type-check, lint, test, build.

Phase 1 — LOAD

Read the plan file:

cat "{{arguments}}"

Extract these sections from the plan:

Summary — What is being built
Patterns to Mirror — Code conventions to follow
Files to Change — What to create or modify
Step-by-Step Tasks — Implementation sequence
Validation Commands — How to verify correctness
Acceptance Criteria — Definition of done

If the file doesn't exist or isn't a valid plan:

Error: Plan file not found or invalid.
Run /prp-plan <feature-description> to create a plan first.

CHECKPOINT: Plan loaded. All sections identified. Tasks extracted.

Phase 2 — PREPARE

Git State

git branch --show-current
git status --porcelain

Branch Decision

Current State	Action
On feature branch	Use current branch
On main, clean working tree	Create feature branch: `git checkout -b feat/{plan-name}`
On main, dirty working tree	STOP — Ask user to stash or commit first
In a git worktree for this feature	Use the worktree

Sync Remote

git pull --rebase origin $(git branch --show-current) 2>/dev/null || true

CHECKPOINT: On correct branch. Working tree ready. Remote synced.

Phase 3 — EXECUTE

Process each task from the plan sequentially.

Per-Task Loop

For each task in Step-by-Step Tasks:

Read MIRROR reference — Open the pattern file referenced in the task's MIRROR field. Understand the convention before writing code.
Implement — Write the code following the pattern exactly. Apply GOTCHA warnings. Use specified IMPORTS.
Validate immediately — After EVERY file change:
```
# Run type-check (adjust command per project)
[type-check command from Phase 0]
```
If type-check fails → fix the error before moving to the next file.
Track progress — Log: [done] Task N: [task name] — complete

Handling Deviations

If implementation must deviate from the plan:

Note WHAT changed
Note WHY it changed
Continue with the corrected approach
These deviations will be captured in the report

CHECKPOINT: All tasks executed. Deviations logged.

Phase 4 — VALIDATE

Run all validation levels from the plan. Fix issues at each level before proceeding.

Level 1: Static Analysis

# Type checking — zero errors required
[project type-check command]

# Linting — fix automatically where possible
[project lint command]
[project lint-fix command]

If lint errors remain after auto-fix, fix manually.

Level 2: Unit Tests

Write tests for every new function (as specified in the plan's Testing Strategy).

[project test command for affected area]

Every function needs at least one test
Cover edge cases listed in the plan
If a test fails → fix the implementation (not the test, unless the test is wrong)

Level 3: Build Check

[project build command]

Build must succeed with zero errors.

Level 4: Integration Testing (if applicable)

# Start server, run tests, stop server
[project dev server command] &
SERVER_PID=$!

# Wait for server to be ready (adjust port as needed)
SERVER_READY=0
for i in $(seq 1 30); do
  if curl -sf http://localhost:PORT/health >/dev/null 2>&1; then
    SERVER_READY=1
    break
  fi
  sleep 1
done

if [ "$SERVER_READY" -ne 1 ]; then
  kill "$SERVER_PID" 2>/dev/null || true
  echo "ERROR: Server failed to start within 30s" >&2
  exit 1
fi

[integration test command]
TEST_EXIT=$?

kill "$SERVER_PID" 2>/dev/null || true
wait "$SERVER_PID" 2>/dev/null || true

exit "$TEST_EXIT"

Level 5: Edge Case Testing

Run through edge cases from the plan's Testing Strategy checklist.

CHECKPOINT: All 5 validation levels pass. Zero errors.

Phase 5 — REPORT

Create Implementation Report

mkdir -p .claude/PRPs/reports

Write report to .claude/PRPs/reports/{plan-name}-report.md:

# Implementation Report: [Feature Name]

## Summary
[What was implemented]

## Assessment vs Reality

| Metric | Predicted (Plan) | Actual |
|---|---|---|
| Complexity | [from plan] | [actual] |
| Confidence | [from plan] | [actual] |
| Files Changed | [from plan] | [actual count] |

## Tasks Completed

| # | Task | Status | Notes |
|---|---|---|---|
| 1 | [task name] | [done] Complete | |
| 2 | [task name] | [done] Complete | Deviated — [reason] |

## Validation Results

| Level | Status | Notes |
|---|---|---|
| Static Analysis | [done] Pass | |
| Unit Tests | [done] Pass | N tests written |
| Build | [done] Pass | |
| Integration | [done] Pass | or N/A |
| Edge Cases | [done] Pass | |

## Files Changed

| File | Action | Lines |
|---|---|---|
| `path/to/file` | CREATED | +N |
| `path/to/file` | UPDATED | +N / -M |

## Deviations from Plan
[List any deviations with WHAT and WHY, or "None"]

## Issues Encountered
[List any problems and how they were resolved, or "None"]

## Tests Written

| Test File | Tests | Coverage |
|---|---|---|
| `path/to/test` | N tests | [area covered] |

## Next Steps
- [ ] Code review via `/code-review`
- [ ] Create PR via `/prp-pr`

Update PRD (if applicable)

If this implementation was for a PRD phase:

Update the phase status from in-progress to complete
Add report path as reference

Archive Plan

mkdir -p .claude/PRPs/plans/completed
mv "{{arguments}}" .claude/PRPs/plans/completed/

CHECKPOINT: Report created. PRD updated. Plan archived.

Phase 6 — OUTPUT

Report to user:

## Implementation Complete

- **Plan**: [plan file path] → archived to completed/
- **Branch**: [current branch name]
- **Status**: [done] All tasks complete

### Validation Summary

| Check | Status |
|---|---|
| Type Check | [done] |
| Lint | [done] |
| Tests | [done] (N written) |
| Build | [done] |
| Integration | [done] or N/A |

### Files Changed
- [N] files created, [M] files updated

### Deviations
[Summary or "None — implemented exactly as planned"]

### Artifacts
- Report: `.claude/PRPs/reports/{name}-report.md`
- Archived Plan: `.claude/PRPs/plans/completed/{name}.plan.md`

### PRD Progress (if applicable)
| Phase | Status |
|---|---|
| Phase 1 | [done] Complete |
| Phase 2 | [next] |
| ... | ... |

> Next step: Run `/prp-pr` to create a pull request, or `/code-review` to review changes first.

Handling Failures

Type Check Fails

Read the error message carefully
Fix the type error in the source file
Re-run type-check
Continue only when clean

Tests Fail

Identify whether the bug is in the implementation or the test
Fix the root cause (usually the implementation)
Re-run tests
Continue only when green

Lint Fails

Run auto-fix first
If errors remain, fix manually
Re-run lint
Continue only when clean

Build Fails

Usually a type or import issue — check error message
Fix the offending file
Re-run build
Continue only when successful

Integration Test Fails

Check server started correctly
Verify endpoint/route exists
Check request format matches expected
Fix and re-run

Success Criteria

TASKS_COMPLETE: All tasks from the plan executed
TYPES_PASS: Zero type errors
LINT_PASS: Zero lint errors
TESTS_PASS: All tests green, new tests written
BUILD_PASS: Build succeeds
REPORT_CREATED: Implementation report saved
PLAN_ARCHIVED: Plan moved to completed/

Next Steps

Run /code-review to review changes before committing
Run /prp-commit to commit with a descriptive message
Run /prp-pr to create a pull request
Run /prp-plan <next-phase> if the PRD has more phases

# ECC Command Prompt: /prp-implement Source: /nix/store/7bmy0z0ymx3hgjbhiiixxi0f43djs56c-source/commands/prp-implement.md Use this prompt to run the ECC `prp-implement` workflow in Codex. > Adapted from PRPs-agentic-eng by Wirasm. Part of the PRP workflow series. # PRP Implement Execute a plan file step-by-step with continuous validation. Every change is verified immediately — never accumulate broken state. **Core Philosophy**: Validation loops catch mistakes early. Run checks after every change. Fix issues immediately. **Golden Rule**: If a validation fails, fix it before moving on. Never accumulate broken state. --- ## Phase 0 — DETECT ### Package Manager Detection | File Exists | Package Manager | Runner | |---|---|---| | `bun.lockb` | bun | `bun run` | | `pnpm-lock.yaml` | pnpm | `pnpm run` | | `yarn.lock` | yarn | `yarn` | | `package-lock.json` | npm | `npm run` | | `pyproject.toml` or `requirements.txt` | uv / pip | `uv run` or `python -m` | | `Cargo.toml` | cargo | `cargo` | | `go.mod` | go | `go` | ### Validation Scripts Check `package.json` (or equivalent) for available scripts: ```bash # For Node.js projects cat package.json | grep -A 20 '"scripts"' ``` Note available commands for: type-check, lint, test, build. --- ## Phase 1 — LOAD Read the plan file: ```bash cat "{{arguments}}" ``` Extract these sections from the plan: - **Summary** — What is being built - **Patterns to Mirror** — Code conventions to follow - **Files to Change** — What to create or modify - **Step-by-Step Tasks** — Implementation sequence - **Validation Commands** — How to verify correctness - **Acceptance Criteria** — Definition of done If the file doesn't exist or isn't a valid plan: ``` Error: Plan file not found or invalid. Run /prp-plan <feature-description> to create a plan first. ``` **CHECKPOINT**: Plan loaded. All sections identified. Tasks extracted. --- ## Phase 2 — PREPARE ### Git State ```bash git branch --show-current git status --porcelain ``` ### Branch Decision | Current State | Action | |---|---| | On feature branch | Use current branch | | On main, clean working tree | Create feature branch: `git checkout -b feat/{plan-name}` | | On main, dirty working tree | **STOP** — Ask user to stash or commit first | | In a git worktree for this feature | Use the worktree | ### Sync Remote ```bash git pull --rebase origin $(git branch --show-current) 2>/dev/null || true ``` **CHECKPOINT**: On correct branch. Working tree ready. Remote synced. --- ## Phase 3 — EXECUTE Process each task from the plan sequentially. ### Per-Task Loop For each task in **Step-by-Step Tasks**: 1. **Read MIRROR reference** — Open the pattern file referenced in the task's MIRROR field. Understand the convention before writing code. 2. **Implement** — Write the code following the pattern exactly. Apply GOTCHA warnings. Use specified IMPORTS. 3. **Validate immediately** — After EVERY file change: ```bash # Run type-check (adjust command per project) [type-check command from Phase 0] ``` If type-check fails → fix the error before moving to the next file. 4. **Track progress** — Log: `[done] Task N: [task name] — complete` ### Handling Deviations If implementation must deviate from the plan: - Note **WHAT** changed - Note **WHY** it changed - Continue with the corrected approach - These deviations will be captured in the report **CHECKPOINT**: All tasks executed. Deviations logged. --- ## Phase 4 — VALIDATE Run all validation levels from the plan. Fix issues at each level before proceeding. ### Level 1: Static Analysis ```bash # Type checking — zero errors required [project type-check command] # Linting — fix automatically where possible [project lint command] [project lint-fix command] ``` If lint errors remain after auto-fix, fix manually. ### Level 2: Unit Tests Write tests for every new function (as specified in the plan's Testing Strategy). ```bash [project test command for affected area] ``` - Every function needs at least one test - Cover edge cases listed in the plan - If a test fails → fix the implementation (not the test, unless the test is wrong) ### Level 3: Build Check ```bash [project build command] ``` Build must succeed with zero errors. ### Level 4: Integration Testing (if applicable) ```bash # Start server, run tests, stop server [project dev server command] & SERVER_PID=$! # Wait for server to be ready (adjust port as needed) SERVER_READY=0 for i in $(seq 1 30); do if curl -sf http://localhost:PORT/health >/dev/null 2>&1; then SERVER_READY=1 break fi sleep 1 done if [ "$SERVER_READY" -ne 1 ]; then kill "$SERVER_PID" 2>/dev/null || true echo "ERROR: Server failed to start within 30s" >&2 exit 1 fi [integration test command] TEST_EXIT=$? kill "$SERVER_PID" 2>/dev/null || true wait "$SERVER_PID" 2>/dev/null || true exit "$TEST_EXIT" ``` ### Level 5: Edge Case Testing Run through edge cases from the plan's Testing Strategy checklist. **CHECKPOINT**: All 5 validation levels pass. Zero errors. --- ## Phase 5 — REPORT ### Create Implementation Report ```bash mkdir -p .claude/PRPs/reports ``` Write report to `.claude/PRPs/reports/{plan-name}-report.md`: ```markdown # Implementation Report: [Feature Name] ## Summary [What was implemented] ## Assessment vs Reality | Metric | Predicted (Plan) | Actual | |---|---|---| | Complexity | [from plan] | [actual] | | Confidence | [from plan] | [actual] | | Files Changed | [from plan] | [actual count] | ## Tasks Completed | # | Task | Status | Notes | |---|---|---|---| | 1 | [task name] | [done] Complete | | | 2 | [task name] | [done] Complete | Deviated — [reason] | ## Validation Results | Level | Status | Notes | |---|---|---| | Static Analysis | [done] Pass | | | Unit Tests | [done] Pass | N tests written | | Build | [done] Pass | | | Integration | [done] Pass | or N/A | | Edge Cases | [done] Pass | | ## Files Changed | File | Action | Lines | |---|---|---| | `path/to/file` | CREATED | +N | | `path/to/file` | UPDATED | +N / -M | ## Deviations from Plan [List any deviations with WHAT and WHY, or "None"] ## Issues Encountered [List any problems and how they were resolved, or "None"] ## Tests Written | Test File | Tests | Coverage | |---|---|---| | `path/to/test` | N tests | [area covered] | ## Next Steps - [ ] Code review via `/code-review` - [ ] Create PR via `/prp-pr` ``` ### Update PRD (if applicable) If this implementation was for a PRD phase: 1. Update the phase status from `in-progress` to `complete` 2. Add report path as reference ### Archive Plan ```bash mkdir -p .claude/PRPs/plans/completed mv "{{arguments}}" .claude/PRPs/plans/completed/ ``` **CHECKPOINT**: Report created. PRD updated. Plan archived. --- ## Phase 6 — OUTPUT Report to user: ``` ## Implementation Complete - **Plan**: [plan file path] → archived to completed/ - **Branch**: [current branch name] - **Status**: [done] All tasks complete ### Validation Summary | Check | Status | |---|---| | Type Check | [done] | | Lint | [done] | | Tests | [done] (N written) | | Build | [done] | | Integration | [done] or N/A | ### Files Changed - [N] files created, [M] files updated ### Deviations [Summary or "None — implemented exactly as planned"] ### Artifacts - Report: `.claude/PRPs/reports/{name}-report.md` - Archived Plan: `.claude/PRPs/plans/completed/{name}.plan.md` ### PRD Progress (if applicable) | Phase | Status | |---|---| | Phase 1 | [done] Complete | | Phase 2 | [next] | | ... | ... | > Next step: Run `/prp-pr` to create a pull request, or `/code-review` to review changes first. ``` --- ## Handling Failures ### Type Check Fails 1. Read the error message carefully 2. Fix the type error in the source file 3. Re-run type-check 4. Continue only when clean ### Tests Fail 1. Identify whether the bug is in the implementation or the test 2. Fix the root cause (usually the implementation) 3. Re-run tests 4. Continue only when green ### Lint Fails 1. Run auto-fix first 2. If errors remain, fix manually 3. Re-run lint 4. Continue only when clean ### Build Fails 1. Usually a type or import issue — check error message 2. Fix the offending file 3. Re-run build 4. Continue only when successful ### Integration Test Fails 1. Check server started correctly 2. Verify endpoint/route exists 3. Check request format matches expected 4. Fix and re-run --- ## Success Criteria - **TASKS_COMPLETE**: All tasks from the plan executed - **TYPES_PASS**: Zero type errors - **LINT_PASS**: Zero lint errors - **TESTS_PASS**: All tests green, new tests written - **BUILD_PASS**: Build succeeds - **REPORT_CREATED**: Implementation report saved - **PLAN_ARCHIVED**: Plan moved to `completed/` --- ## Next Steps - Run `/code-review` to review changes before committing - Run `/prp-commit` to commit with a descriptive message - Run `/prp-pr` to create a pull request - Run `/prp-plan <next-phase>` if the PRD has more phases

{ "prompt": "# ECC Command Prompt: /prp-implement\n\nSource: /nix/store/7bmy0z0ymx3hgjbhiiixxi0f43djs56c-source/commands/prp-implement.md\n\nUse this prompt to run the ECC `prp-implement` workflow in Codex.\n\n\n> Adapted from PRPs-agentic-eng by Wirasm. Part of the PRP workflow series.\n\n# PRP Implement\n\nExecute a plan file step-by-step with continuous validation. Every change is verified immediately — never accumulate broken state.\n\n**Core Philosophy**: Validation loops catch mistakes early. Run checks after every change. Fix issues immediately.\n\n**Golden Rule**: If a validation fails, fix it before moving on. Never accumulate broken state.\n\n---\n\n## Phase 0 — DETECT\n\n### Package Manager Detection\n\n| File Exists | Package Manager | Runner |\n|---|---|---|\n| `bun.lockb` | bun | `bun run` |\n| `pnpm-lock.yaml` | pnpm | `pnpm run` |\n| `yarn.lock` | yarn | `yarn` |\n| `package-lock.json` | npm | `npm run` |\n| `pyproject.toml` or `requirements.txt` | uv / pip | `uv run` or `python -m` |\n| `Cargo.toml` | cargo | `cargo` |\n| `go.mod` | go | `go` |\n\n### Validation Scripts\n\nCheck `package.json` (or equivalent) for available scripts:\n\n```bash\n# For Node.js projects\ncat package.json | grep -A 20 '\"scripts\"'\n```\n\nNote available commands for: type-check, lint, test, build.\n\n---\n\n## Phase 1 — LOAD\n\nRead the plan file:\n\n```bash\ncat \"{{arguments}}\"\n```\n\nExtract these sections from the plan:\n- **Summary** — What is being built\n- **Patterns to Mirror** — Code conventions to follow\n- **Files to Change** — What to create or modify\n- **Step-by-Step Tasks** — Implementation sequence\n- **Validation Commands** — How to verify correctness\n- **Acceptance Criteria** — Definition of done\n\nIf the file doesn't exist or isn't a valid plan:\n```\nError: Plan file not found or invalid.\nRun /prp-plan <feature-description> to create a plan first.\n```\n\n**CHECKPOINT**: Plan loaded. All sections identified. Tasks extracted.\n\n---\n\n## Phase 2 — PREPARE\n\n### Git State\n\n```bash\ngit branch --show-current\ngit status --porcelain\n```\n\n### Branch Decision\n\n| Current State | Action |\n|---|---|\n| On feature branch | Use current branch |\n| On main, clean working tree | Create feature branch: `git checkout -b feat/{plan-name}` |\n| On main, dirty working tree | **STOP** — Ask user to stash or commit first |\n| In a git worktree for this feature | Use the worktree |\n\n### Sync Remote\n\n```bash\ngit pull --rebase origin $(git branch --show-current) 2>/dev/null || true\n```\n\n**CHECKPOINT**: On correct branch. Working tree ready. Remote synced.\n\n---\n\n## Phase 3 — EXECUTE\n\nProcess each task from the plan sequentially.\n\n### Per-Task Loop\n\nFor each task in **Step-by-Step Tasks**:\n\n1. **Read MIRROR reference** — Open the pattern file referenced in the task's MIRROR field. Understand the convention before writing code.\n\n2. **Implement** — Write the code following the pattern exactly. Apply GOTCHA warnings. Use specified IMPORTS.\n\n3. **Validate immediately** — After EVERY file change:\n ```bash\n # Run type-check (adjust command per project)\n [type-check command from Phase 0]\n ```\n If type-check fails → fix the error before moving to the next file.\n\n4. **Track progress** — Log: `[done] Task N: [task name] — complete`\n\n### Handling Deviations\n\nIf implementation must deviate from the plan:\n- Note **WHAT** changed\n- Note **WHY** it changed\n- Continue with the corrected approach\n- These deviations will be captured in the report\n\n**CHECKPOINT**: All tasks executed. Deviations logged.\n\n---\n\n## Phase 4 — VALIDATE\n\nRun all validation levels from the plan. Fix issues at each level before proceeding.\n\n### Level 1: Static Analysis\n\n```bash\n# Type checking — zero errors required\n[project type-check command]\n\n# Linting — fix automatically where possible\n[project lint command]\n[project lint-fix command]\n```\n\nIf lint errors remain after auto-fix, fix manually.\n\n### Level 2: Unit Tests\n\nWrite tests for every new function (as specified in the plan's Testing Strategy).\n\n```bash\n[project test command for affected area]\n```\n\n- Every function needs at least one test\n- Cover edge cases listed in the plan\n- If a test fails → fix the implementation (not the test, unless the test is wrong)\n\n### Level 3: Build Check\n\n```bash\n[project build command]\n```\n\nBuild must succeed with zero errors.\n\n### Level 4: Integration Testing (if applicable)\n\n```bash\n# Start server, run tests, stop server\n[project dev server command] &\nSERVER_PID=$!\n\n# Wait for server to be ready (adjust port as needed)\nSERVER_READY=0\nfor i in $(seq 1 30); do\n if curl -sf http://localhost:PORT/health >/dev/null 2>&1; then\n SERVER_READY=1\n break\n fi\n sleep 1\ndone\n\nif [ \"$SERVER_READY\" -ne 1 ]; then\n kill \"$SERVER_PID\" 2>/dev/null || true\n echo \"ERROR: Server failed to start within 30s\" >&2\n exit 1\nfi\n\n[integration test command]\nTEST_EXIT=$?\n\nkill \"$SERVER_PID\" 2>/dev/null || true\nwait \"$SERVER_PID\" 2>/dev/null || true\n\nexit \"$TEST_EXIT\"\n```\n\n### Level 5: Edge Case Testing\n\nRun through edge cases from the plan's Testing Strategy checklist.\n\n**CHECKPOINT**: All 5 validation levels pass. Zero errors.\n\n---\n\n## Phase 5 — REPORT\n\n### Create Implementation Report\n\n```bash\nmkdir -p .claude/PRPs/reports\n```\n\nWrite report to `.claude/PRPs/reports/{plan-name}-report.md`:\n\n```markdown\n# Implementation Report: [Feature Name]\n\n## Summary\n[What was implemented]\n\n## Assessment vs Reality\n\n| Metric | Predicted (Plan) | Actual |\n|---|---|---|\n| Complexity | [from plan] | [actual] |\n| Confidence | [from plan] | [actual] |\n| Files Changed | [from plan] | [actual count] |\n\n## Tasks Completed\n\n| # | Task | Status | Notes |\n|---|---|---|---|\n| 1 | [task name] | [done] Complete | |\n| 2 | [task name] | [done] Complete | Deviated — [reason] |\n\n## Validation Results\n\n| Level | Status | Notes |\n|---|---|---|\n| Static Analysis | [done] Pass | |\n| Unit Tests | [done] Pass | N tests written |\n| Build | [done] Pass | |\n| Integration | [done] Pass | or N/A |\n| Edge Cases | [done] Pass | |\n\n## Files Changed\n\n| File | Action | Lines |\n|---|---|---|\n| `path/to/file` | CREATED | +N |\n| `path/to/file` | UPDATED | +N / -M |\n\n## Deviations from Plan\n[List any deviations with WHAT and WHY, or \"None\"]\n\n## Issues Encountered\n[List any problems and how they were resolved, or \"None\"]\n\n## Tests Written\n\n| Test File | Tests | Coverage |\n|---|---|---|\n| `path/to/test` | N tests | [area covered] |\n\n## Next Steps\n- [ ] Code review via `/code-review`\n- [ ] Create PR via `/prp-pr`\n```\n\n### Update PRD (if applicable)\n\nIf this implementation was for a PRD phase:\n1. Update the phase status from `in-progress` to `complete`\n2. Add report path as reference\n\n### Archive Plan\n\n```bash\nmkdir -p .claude/PRPs/plans/completed\nmv \"{{arguments}}\" .claude/PRPs/plans/completed/\n```\n\n**CHECKPOINT**: Report created. PRD updated. Plan archived.\n\n---\n\n## Phase 6 — OUTPUT\n\nReport to user:\n\n```\n## Implementation Complete\n\n- **Plan**: [plan file path] → archived to completed/\n- **Branch**: [current branch name]\n- **Status**: [done] All tasks complete\n\n### Validation Summary\n\n| Check | Status |\n|---|---|\n| Type Check | [done] |\n| Lint | [done] |\n| Tests | [done] (N written) |\n| Build | [done] |\n| Integration | [done] or N/A |\n\n### Files Changed\n- [N] files created, [M] files updated\n\n### Deviations\n[Summary or \"None — implemented exactly as planned\"]\n\n### Artifacts\n- Report: `.claude/PRPs/reports/{name}-report.md`\n- Archived Plan: `.claude/PRPs/plans/completed/{name}.plan.md`\n\n### PRD Progress (if applicable)\n| Phase | Status |\n|---|---|\n| Phase 1 | [done] Complete |\n| Phase 2 | [next] |\n| ... | ... |\n\n> Next step: Run `/prp-pr` to create a pull request, or `/code-review` to review changes first.\n```\n\n---\n\n## Handling Failures\n\n### Type Check Fails\n1. Read the error message carefully\n2. Fix the type error in the source file\n3. Re-run type-check\n4. Continue only when clean\n\n### Tests Fail\n1. Identify whether the bug is in the implementation or the test\n2. Fix the root cause (usually the implementation)\n3. Re-run tests\n4. Continue only when green\n\n### Lint Fails\n1. Run auto-fix first\n2. If errors remain, fix manually\n3. Re-run lint\n4. Continue only when clean\n\n### Build Fails\n1. Usually a type or import issue — check error message\n2. Fix the offending file\n3. Re-run build\n4. Continue only when successful\n\n### Integration Test Fails\n1. Check server started correctly\n2. Verify endpoint/route exists\n3. Check request format matches expected\n4. Fix and re-run\n\n---\n\n## Success Criteria\n\n- **TASKS_COMPLETE**: All tasks from the plan executed\n- **TYPES_PASS**: Zero type errors\n- **LINT_PASS**: Zero lint errors\n- **TESTS_PASS**: All tests green, new tests written\n- **BUILD_PASS**: Build succeeds\n- **REPORT_CREATED**: Implementation report saved\n- **PLAN_ARCHIVED**: Plan moved to `completed/`\n\n---\n\n## Next Steps\n\n- Run `/code-review` to review changes before committing\n- Run `/prp-commit` to commit with a descriptive message\n- Run `/prp-pr` to create a pull request\n- Run `/prp-plan <next-phase>` if the PRD has more phases", "variables": [ "arguments" ], "notes": "Source: /nix/store/7bmy0z0ymx3hgjbhiiixxi0f43djs56c-source/commands/prp-implement.md", "metadata": { "source": { "provider": "github-codex-prompts", "repository": "https://github.com/SpreadZhao/codex-ecc", "path": ".codex/prompts/ecc-prp-implement.md", "ref": "42e5e807d9f32faeb4bd991bf7c77e050a917126", "url": "https://github.com/SpreadZhao/codex-ecc/blob/42e5e807d9f32faeb4bd991bf7c77e050a917126/.codex/prompts/ecc-prp-implement.md", "key": "SpreadZhao/codex-ecc/.codex/prompts/ecc-prp-implement.md" } } }

ecc-prp-implement

About