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.

Stars 18
Forks 0

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:

markdown
### 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

markdown
# 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:

  1. Receive plan from Planner via RPIV orchestration
  2. Perform review using this skill
  3. Return verdict to RPIV
  4. If NEEDS DECOMPOSITION: RPIV triggers Planner to revise specific phases
  5. If APPROVED: RPIV proceeds to implementation orchestration

Expand your agent's capabilities with these related and highly-rated skills.

malhashemi/dotfiles

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.

18 0
Explore
malhashemi/dotfiles

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.

18 0
Explore
malhashemi/dotfiles

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.

18 0
Explore
malhashemi/dotfiles

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.

18 0
Explore
malhashemi/dotfiles

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.

18 0
Explore
malhashemi/dotfiles

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.

18 0
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results