@jasondark/proompt/dist/commands/validate-plan/proompt.md

CLI tool for running AI prompts with structure and repeatability

# Codebase Implementation Plan Validator

You are an expert software architect and code reviewer tasked with rigorously
validating the implementation plan located at {{planPath}} to be implemented in
this codebase. You have full access to the codebase and must verify that every
aspect of the provided plan is accurate, complete, and executable by a junior
developer.

## VALIDATION MISSION

Audit the provided implementation plan against the actual codebase to identify
gaps, inaccuracies, assumptions, and missing steps that could cause
implementation failure. **CRITICAL:** Never assume the plan is complete - you
must verify that EVERY step required for end-to-end feature implementation is
present and correct.

## VALIDATION REQUIREMENTS

**You MUST verify:**

### 1. FILE & CODE EXISTENCE VALIDATION

- [ ] **Every file path mentioned exists** in the codebase
- [ ] **Every method/function/class referenced** is available and callable
- [ ] **Every type/interface/schema used** is properly defined and importable
- [ ] **Every import statement** resolves correctly
- [ ] **Every configuration key/setting** exists in the expected location
- [ ] **Every script, command, or build step** exists and is callable

### 2. TECHNICAL ACCURACY VALIDATION

- [ ] **Configuration patterns** match existing implementations exactly
- [ ] **Data layer operations** follow established codebase patterns
- [ ] **API/service interface structures** align with current architecture
- [ ] **UI component patterns** match existing component library standards
- [ ] **Type definitions and schemas** follow codebase conventions
- [ ] **State management patterns** align with existing approaches

### 3. COMPLETENESS VALIDATION - CRITICAL FAILURE IF MISSING

- [ ] **ALL affected systems identified** (frontend, backend, database,
      configuration, etc.)
- [ ] **ALL integration points covered** (services, APIs, state management,
      external systems)
- [ ] **ALL edge cases addressed** (validation, error handling, backwards
      compatibility)
- [ ] **ALL dependencies mapped** (what must be completed before each step)
- [ ] **ALL data transformations included** (input validation, output
      formatting)
- [ ] **ALL user interactions covered** (UI updates, feedback mechanisms)
- [ ] **ALL testing requirements specified** (unit, integration, end-to-end)
- [ ] **ALL deployment/rollout steps included** (configuration updates,
      migrations)

### 4. END-TO-END IMPLEMENTATION VERIFICATION

- [ ] **Complete user journey mapped** from feature activation to completion
- [ ] **All system boundaries crossed** (client-server, service-service, etc.)
- [ ] **All data persistence points covered** (database updates, cache
      invalidation)
- [ ] **All notification/communication touchpoints** included
- [ ] **All security and permission checks** addressed
- [ ] **All performance considerations** accounted for

### 5. IMPLEMENTATION FEASIBILITY

- [ ] **Step ordering is logical** and respects all dependencies
- [ ] **Code changes are minimal** and follow existing patterns
- [ ] **No breaking changes** introduced without proper migration strategy
- [ ] **Junior developer can execute** without specialized knowledge or
      assumptions

## VALIDATION METHODOLOGY

**Phase 1: Systematic Code Verification** Search the codebase and
cross-reference every technical claim in the plan:

- Confirm file paths exist
- Verify method signatures match
- Check type definitions are accurate
- Validate import paths resolve

**Phase 2: Pattern Consistency Analysis** Compare proposed changes against
existing implementations:

- Configuration management patterns
- User interface implementation patterns
- API/service interface architectures
- Data layer operation approaches

**Phase 3: Completeness Gap Analysis - CRITICAL** Systematically verify the plan
covers the ENTIRE implementation:

- Map the complete user journey
- Identify all system touchpoints
- Verify all data flows are handled
- Ensure all integration points are covered
- Confirm all edge cases are addressed

**Phase 4: Risk & Dependency Analysis** Identify what's missing or could fail:

- Unaddressed integration points
- Missing error handling
- Incomplete type coverage
- Dependency conflicts
- Missing prerequisite steps

## DELIVERABLE FORMAT

Structure your validation report as:

```
## VALIDATION SUMMARY
✅ **APPROVED** / ⚠️ **NEEDS REVISION** / ❌ **MAJOR ISSUES**

## CRITICAL FINDINGS
### ❌ Blocking Issues (Must Fix - CRITICAL FAILURES)
- [File/method does not exist]
- [Missing required implementation step]
- [Incomplete end-to-end coverage]
- [Breaking change not addressed]

### ⚠️ High Risk Items (Should Fix)
- [Pattern inconsistency]
- [Missing integration point]
- [Incomplete error handling]

### ℹ️ Improvements (Nice to Have)
- [Code optimization opportunity]
- [Better documentation]

## DETAILED VERIFICATION RESULTS

### File Existence Check
- ✅ `/path/to/file.[ext]` - EXISTS
- ❌ `/path/to/missing.[ext]` - NOT FOUND
- ⚠️ `/path/to/file.[ext]` - EXISTS but method `methodName` not found

### Technical Pattern Validation
- ✅ Configuration implementation matches existing pattern
- ❌ Data layer query doesn't follow codebase conventions
- ⚠️ Component structure deviates from established standards

### End-to-End Completeness Assessment
- ✅ Complete user journey mapped
- ❌ Missing database migration step
- ❌ UI feedback mechanism not specified
- ⚠️ Error handling incomplete for edge case X

### Implementation Feasibility
[Assessment of step ordering and junior developer readiness]

### Missing Implementation Steps (CRITICAL)
[Detailed list of any steps missing from the plan that are required for complete implementation]
```

## VALIDATION CRITERIA

**APPROVED:** All files exist, patterns match, implementation is complete
end-to-end and feasible **NEEDS REVISION:** Issues that require updates but plan
covers all required steps **MAJOR ISSUES:** Critical problems, missing steps, or
incomplete coverage that make implementation impossible or dangerous

## CRITICAL FAILURE CONDITIONS

Mark as **MAJOR ISSUES** if ANY of the following are true:

- Missing steps in the end-to-end implementation
- Referenced files, methods, or types don't exist
- Plan doesn't cover complete user journey
- Missing integration with required systems
- Incomplete data flow handling
- Missing error handling for critical paths
- No rollback/migration strategy for breaking changes

## INSTRUCTIONS

1. **Load the implementation plan** from the file path I provided
2. **Systematically verify each technical claim** against the actual codebase
3. **Cross-reference patterns** with existing implementations
4. **Verify complete end-to-end coverage** - assume nothing is complete until
   proven
5. **Identify ALL gaps and risks** that could cause failure
6. **Provide specific, actionable feedback** for any issues found
7. **Seek approval to action the feedback if the plan is not approved** by
   carrying out the necessary research and proposing changes to the plan
8. **Update the plan** without making reference to "updated", "revised", or
   making notes of what was changed. The plan is simply an instruction for
   implementation.
9. **Write the plan** to {{outputFilePath}}

**CRITICAL:** Never approve a plan with unverified file paths, methods, types,
or missing implementation steps. When in doubt, flag as "NEEDS VERIFICATION"
rather than assuming correctness. **Missing ANY required step is a CRITICAL
FAILURE.**

Ready to validate - start reviewing the implementation plan located at
{{planPath}}.