Agent skill
plan-review
Catch oversized phases BEFORE implementation begins! This skill reviews plans for sizing, dependencies, and completeness - flagging phases that need decomposition before a single line of code is written. Load this when validating plans pre-implementation.
Install this agent skill to your Project
npx add-skill https://github.com/malhashemi/dotfiles/tree/main/dot_config/opencode/skill/plan-review
SKILL.md
Plan Review
Overview
Review implementation plans before execution to catch sizing issues, dependency problems, and gaps that would cause implementation failures. This is a pre-flight check that prevents wasted effort.
When to Use
- After a Planner creates an implementation plan
- Before handing off a plan to implementation
- When RPIV requests plan validation before proceeding
- When user asks to review/validate a plan
Review Checklist
1. Phase Sizing Assessment
For each phase, evaluate:
| Factor | Acceptable | Concerning | Flag for Decomposition |
|---|---|---|---|
| File changes | 1-3 files | 4-6 files | 7+ files |
| New functions/classes | 1-5 | 6-10 | 10+ |
| Test additions | 1-10 tests | 11-20 tests | 20+ tests |
| Estimated context | <30% | 30-40% | >40% |
Context estimation heuristic:
- Each file read: ~2-5% context (depending on size)
- Each code generation: ~5-10% context
- Each test run + analysis: ~3-5% context
2. Dependency Analysis
For each phase, verify:
- Phases are correctly ordered (no forward dependencies)
- Each phase builds on previous phases' outputs
- No circular dependencies
- Optional/parallel phases are clearly marked
3. Completeness Check
For each phase, verify it includes:
- Clear description of what to implement
- Specific files to create/modify
- Success criteria (automated and manual separated)
- Any code snippets or patterns to follow
4. Gap Analysis
Identify missing elements:
- Are there phases that should exist but don't?
- Are there implicit steps that should be explicit?
- Are error cases and edge cases addressed?
- Is there a testing strategy for each phase?
Review Process
Step 1: Read Full Plan
Read the entire plan without making judgments. Understand:
- What is being built
- Why it's structured this way
- What the end state looks like
Step 2: Phase-by-Phase Assessment
For each phase, create an assessment:
### Phase N: [Title]
**Sizing**: ✓ Acceptable / ⚠️ Borderline / ✗ Too Large
- Estimated files: X
- Estimated context: Y%
**Dependencies**: ✓ Clear / ⚠️ Implicit / ✗ Circular
**Completeness**: ✓ Complete / ⚠️ Missing details / ✗ Insufficient
**Notes**: [Any specific concerns or suggestions]
Step 3: Synthesize Verdict
Based on all assessments:
APPROVED - Plan is ready for implementation
- All phases are appropriately sized
- Dependencies are clear and logical
- Each phase has sufficient detail
NEEDS DECOMPOSITION - Specific phases must be broken down
- List which phases need decomposition
- Explain why (too large, too complex, etc.)
- Suggest how to split if obvious
NEEDS REVISION - Plan has structural issues
- List what needs to be fixed
- Dependencies need reordering
- Gaps need to be addressed
Output Template
# Plan Review: [Plan Name]
## Overview
[1-2 sentence summary of what the plan implements]
## Phase Assessments
### Phase 1: [Title]
**Sizing**: ✓ / ⚠️ / ✗
**Dependencies**: ✓ / ⚠️ / ✗
**Completeness**: ✓ / ⚠️ / ✗
**Notes**: ...
[Repeat for each phase]
## Dependency Graph
Phase 1 → Phase 2 → Phase 3 ↘ Phase 4 (parallel)
## Issues Found
### Must Fix Before Implementation
- [Critical issue 1]
- [Critical issue 2]
### Recommendations (Optional)
- [Suggestion 1]
- [Suggestion 2]
## Verdict
**[APPROVED / NEEDS DECOMPOSITION / NEEDS REVISION]**
[Explanation of verdict with specific action items if not approved]
Integration with RPIV
When operating within RPIV:
- Receive plan from Planner via RPIV orchestration
- Perform review using this skill
- Return verdict to RPIV
- If NEEDS DECOMPOSITION: RPIV triggers Planner to revise specific phases
- If APPROVED: RPIV proceeds to implementation orchestration
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
phase-execution
Your bulletproof guide to executing implementation phases! Handles commits, detects when phases are too big, and knows when to bail cleanly. Load this whenever you're implementing a phase - it provides clean commit protocol and signals the orchestrator when things go sideways.
parallel-research
Research scope too big? This skill decomposes large questions into independent parts, spawns parallel researchers, and synthesizes findings. Essential when comprehensive research would overflow a single context window.
brand-palette
Brand color discovery and palette generation skill. This skill should be used when helping users create brand color palettes, design systems, or Tailwind color configs. It guides through hue selection (RYB color wheel), chroma/tone decisions, and generates Obsidian-compatible palette reports with APCA accessibility validation. Supports starting from hex color or OKLCH values for refinement workflows. Triggers: "brand colors", "palette", "color scheme", "design system colors", "Tailwind colors", "generate palette from hex", "generate palette from OKLCH", or when users describe brand values that imply color decisions.
pr-review-orchestration
Automated PR review cycle for RPIV orchestration. Waits for Gemini reviews, assesses feedback, implements fixes, and manages the review loop. Used by Planner agent after RPIV opens PRs. This skill is triggered automatically by RPIV when entering the PR Review phase.
pr-review
This skill provides a complete workflow for handling GitHub Pull Request reviews, specifically optimized for @gemini-code-assist automated reviews. This skill should be used when addressing PR review comments, responding to reviewers, resolving threads, requesting re-reviews, or merging PRs after feedback is addressed. Triggers include: /pr-review command, "address PR feedback", "handle review comments", "respond to gemini", or any PR review lifecycle management request.
plan-validation
Validates implementation plan execution by verifying success criteria and identifying deviations. This skill should be used after a phase or plan has been implemented and committed. It runs automated checks (tests, types, lint), compares actual changes against the plan's specifications, and generates a validation report documenting what was completed, what deviated, and what needs manual testing.
Didn't find tool you were looking for?