home / skills / duc01226 / easyplatform / plan-review

plan-review skill

safe

This skill critically reviews a planning plan to ensure structure, logic, patterns, completeness, and best practices before coding begins.

npx playbooks add skill duc01226/easyplatform --skill plan-review

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.6 KB

---
name: plan-review
description: "[Planning] Self-review plan for validity, correctness, and best practices"
argument-hint: [plan-path]
infer: true
---

> **CRITICAL:** Do NOT use `EnterPlanMode` tool — it blocks Write/Edit/Task tools. Follow the workflow below.

## Your Mission

Critically self-review the implementation plan to ensure quality before coding begins.

## Plan Resolution

1. If `$ARGUMENTS` provided → Use that path
2. Else check `## Plan Context` → Use active plan path
3. If no plan found → Error: run `/plan` first

## Review Checklist

| Category           | Check                                                      |
| ------------------ | ---------------------------------------------------------- |
| **Structure**      | Has plan.md with YAML frontmatter (title, status, effort)? |
| **Structure**      | Phases numbered and linked correctly?                      |
| **Logic**          | Dependencies between phases mapped?                        |
| **Logic**          | Risk assessment present with mitigations?                  |
| **Patterns**       | Uses platform patterns (not custom solutions)?             |
| **Patterns**       | Files in correct project locations?                        |
| **Completeness**   | Success criteria defined and measurable?                   |
| **Completeness**   | All edge cases considered?                                 |
| **Best Practices** | Follows YAGNI/KISS/DRY principles?                         |
| **Best Practices** | No over-engineering or premature abstraction?              |

## Review Process

1. **Read** plan.md and all phase-*.md files
2. **Evaluate** each checklist item
3. **Identify** issues with specific locations and fixes
4. **Output** approval or revision requirements

## Output Format

**If Plan Passes:**
```
✅ Plan Review: APPROVED

- Structure: Valid
- Logic: Sound
- Patterns: Compliant
- Completeness: Adequate
- Best Practices: Followed

Proceeding to implementation...
```

**If Issues Found:**
```
⚠️ Plan Review: NEEDS REVISION

Issues:
1. [Category] [File:Line] Issue description → Fix suggestion
2. [Category] [File:Line] Issue description → Fix suggestion

Update plan before proceeding.
```

## IMPORTANT Task Planning Notes

- Always plan and break many small todo tasks
- Always add a final review todo task to review the works done at the end to find any fix or enhancement needed

## Important Notes

- Focus on **major issues** that would impact implementation
- Don't nitpick formatting or style unless it affects clarity
- If plan is simple and solid, approve quickly
- Always provide actionable fix suggestions for issues

Overview

This skill performs a critical self-review of a development plan to validate structure, logic, completeness, and alignment with best practices before coding begins. It reads the active plan and phase files, evaluates them against a focused checklist, and issues either an approval or a list of concrete revision items. The goal is to catch major implementation risks and ensure the plan is actionable.

How this skill works

The skill locates the active plan (or a provided plan path), opens plan.md and all phase-*.md files, and evaluates them against a compact review checklist covering structure, dependencies, risk, patterns, completeness, and best practices. For each failing check it identifies the file and approximate location, explains the impact, and suggests an actionable fix. If all major items pass, it emits a concise approval message so implementation can proceed.

When to use it

Before writing any production code to validate the design and scope.
When handoff occurs between planning and implementation teams.
After major plan edits to confirm no new risks were introduced.
When onboarding a new contributor who will execute the plan.
Prior to scheduling sprints to ensure tasks are actionable and sized.

Best practices

Require a single source plan.md with YAML frontmatter including title, status, and effort.
Number and link phases so sequence and dependencies are explicit.
Include measurable success criteria and clear exit conditions for each phase.
Map dependencies and risk mitigations for high-impact items only.
Prefer platform patterns over custom solutions and avoid premature abstraction.
Break work into small tasks and add a final review task to validate delivered work.

Example use cases

A product manager validating a multi-phase feature rollout plan before dev begins.
A developer verifying that edge cases and success criteria are defined before implementation.
A tech lead reviewing contractor deliverables to ensure they follow platform patterns.
A team running a pre-sprint checklist to catch missing dependencies or risks.
A project owner confirming the plan is small-task friendly and includes a final review task.

FAQ

What if no plan is found?

The reviewer reports an error and requests running the plan creation step first or supplying a plan path.

Will the review list every minor stylistic issue?

No. The review focuses on major issues that impact implementation and only flags style when it affects clarity or correctness.