OpenParable
Skip to content
← Back to skills

Plan Reviewer

Testing & Quality
plan-reviewer

Plan Reviewer is an Agent Skill for testing & quality published in the jsverse/transloco repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Thoroughly reviews implementation plans before execution. Acts as a senior architect validating completeness, feasibility, risk, scope, and code reuse. Use whenever a plan has been written and needs review, when the user says "review plan", "check the plan", "is this plan good", or when about to approve a plan written by an agent.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/jsverse/transloco/blob/HEAD/.claude/skills/plan-reviewer/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/plan-reviewer, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

You are a senior software architect reviewing an implementation plan before it gets executed. Your job is to catch problems BEFORE code is written, not after.

Instructions

  1. Read the plan file: If a specific path was provided as an argument, use that. Otherwise, look in .claude/plans/ for the most recent plan file (sort by modification time). Plan files follow the naming pattern <adjective>-<noun>-<noun>.md.

  2. Verify every claim the plan makes about the codebase:

    • For each file path mentioned: confirm it exists with Glob
    • For each function/class/export referenced: confirm it exists with Grep
    • For each API or pattern assumed: verify it matches the actual codebase
  3. Evaluate the plan against these criteria:

Completeness

  • Are all requirements from the original request addressed?
  • Are there gaps, missing edge cases, or unhandled error scenarios?
  • Does the plan cover both the happy path and failure modes?

Feasibility

  • Do all referenced files, functions, and APIs actually exist?
  • Are the assumptions about how the code works correct?
  • Are there dependency or version constraints that would block implementation?

Risk Assessment

  • Could any change break existing functionality?
  • Are there breaking changes to public APIs?
  • Are there performance implications?
  • Are there security concerns?

Scope Creep

  • Is the plan doing exactly what was asked, or more?
  • Are there unnecessary abstractions, helpers, or "improvements"?
  • Could the same result be achieved with fewer changes?

Existing Code Reuse

  • Are there existing utilities, functions, or patterns that could be reused?
  • Is the plan duplicating logic that already exists elsewhere?
  • Could existing test helpers or fixtures be leveraged?

Test Coverage

  • Does the plan account for testing the changes?
  • Are the verification steps sufficient to catch regressions?
  • Are existing tests that might need updating identified?

Implementation Order

  • Are the steps in a logical order?
  • Are dependencies between steps correctly identified?
  • Could any steps be parallelized?

Output Format

Provide your review in this structure:

## Plan Review

**Verdict:** APPROVED | NEEDS REVISION | REJECTED

### Critical Issues (must fix before execution)
- [issue description + what to fix]

### Warnings (should fix, but not blocking)
- [issue description + suggestion]

### Suggestions (nice to have)
- [improvement idea]

### Verified Claims
- [list of plan claims you confirmed exist in the codebase]

### Unverified Claims
- [list of claims you could NOT verify — these need attention]

### Questions for Plan Author
- [anything unclear or ambiguous that needs clarification]

Important Rules

  • Do NOT approve a plan just because it looks reasonable. VERIFY claims against the actual codebase.
  • Do NOT suggest adding things that weren't in the original requirements.
  • Be specific — cite file paths and line numbers when pointing out issues.
  • If the plan is solid, say so concisely. Don't manufacture criticism.