RE

Validates project plans against codebases and standards to catch architectural mistakes early.

Install

mkdir -p .claude/skills/review-plan-hawkyre && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/19446" && unzip -o skill.zip -d .claude/skills/review-plan-hawkyre && rm skill.zip

Installs to .claude/skills/review-plan-hawkyre

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Stress-test a plan file before committing to implementation. Catches architectural mistakes, convention violations, and missing dependencies while changes are still cheap. Invoked directly, not routed from coding-process.
221 charsno explicit “when” trigger
Intermediate

Key capabilities

  • Analyze plan files for technical soundness
  • Verify dependency ordering between increments
  • Check plan compliance with project standards
  • Validate plan fidelity against conversation history
  • Assess increment implementability and done criteria

How it works

The skill reads plan files and associated notes to evaluate architectural decisions, dependency sequences, and convention adherence. It uses big-output discipline to process large logs and file contents efficiently.

Inputs & outputs

You give it
Plan files in HTML or Markdown format
You get back
Summary of findings categorized as MUST FIX, SHOULD FIX, or CONSIDER

When to use review-plan

  • Validate multi-PR architectural plan files
  • Check dependency ordering for code increments
  • Ensure planned changes comply with project standards
  • Verify plan fidelity against recent chat history

About this skill

Review a Plan

Process

  1. Load the plan and its context: Read the plan file(s) and any siblings. Plans are HTML — .plans/<slug>/plan.html (single-PR) or the overview.html / data-model.html / plan.html / decisions.html / verification.html / contracts.html set (multi-PR), plus inc-<N>-notes.md. Legacy plans may still be Markdown (*.md) — read whichever exists. Machine fields live on data-* attributes (increments: data-inc, data-size, data-depends, data-files, data-done); read those when checking dependency ordering and done-criteria. Read the relevant .agents/standards/ files that apply to the planned work.

  2. Review for technical soundness:

    • Are the architectural decisions correct given the codebase?
    • Are the dependencies between increments properly ordered?
    • Are there missing increments or gaps in the sequence?
    • Will each increment actually pass CI independently?
  3. Review for convention compliance:

    • Does the plan follow the project's standards?
    • Are files placed in the right directories?
    • Does the naming follow conventions?
    • Are there patterns in .agents/common-mistakes/ that the plan risks repeating?
  4. Review for conversation fidelity: If reviewing a plan produced during an active conversation, check whether all decisions, constraints, and answered questions from the discussion are captured in the plan. A correct plan that doesn't match what was agreed is worse than a slightly imperfect plan that does. Skip this step if reviewing a plan file without conversation context.

  5. Review for implementability:

    • Is each increment scoped tightly enough to implement in one session?
    • Are the "done criteria" specific and verifiable?
    • Are there ambiguities that will force the implementer to make undocumented decisions?
  6. Summarize findings:

    • MUST FIX — Issues that would cause implementation failure or architectural problems
    • SHOULD FIX — Issues that would cause friction or technical debt
    • CONSIDER — Suggestions for improvement

Rules

  • Reviewing a plan is 10x cheaper than fixing a bad implementation
  • The best time to catch a missing dependency is before any code exists
  • Convention compliance in the plan prevents convention violations in the code
  • An adversarial reviewer should argue against the plan — not just validate it
  • Big-output discipline. Heavy command output (project check, full git diff, repo-wide search, long log, large fetch) goes to /tmp/hawk-<skill>-<step>.log, then rg -n '<pattern>' /tmp/hawk-<skill>-<step>.log | head -50 extracts what you need. Read the file only with offset/limit. See README → Big-output discipline.

When not to use it

  • Routing to coding-process
  • Reviewing plans without conversation context when fidelity is required

Limitations

  • Requires specific file paths like .plans/<slug>/plan.html
  • Heavy command output must be redirected to /tmp/hawk-<skill>-<step>.log

How it compares

Unlike manual review, this skill performs an adversarial check against project standards and dependency logic before any code is written.

Compared to similar skills

review-plan side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
review-plan (this skill)029dNo flagsIntermediate
confidence-check134moReviewBeginner
specification-architect138moReviewAdvanced
drift-analysis24moNo flagsIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

confidence-check

SuperClaude-Org

Pre-implementation confidence assessment (≥90% required). Use before starting any implementation to verify readiness with duplicate check, architecture compliance, official docs verification, OSS references, and root cause identification.

13114

specification-architect

adrianpuiu

A rigorous, traceability-first system that generates five interconnected architectural documents (blueprint.md, requirements.md, design.md, tasks.md, and validation.md) with complete requirements-to-implementation traceability. Use this skill when users need to architect systems, create technical specifications, or develop structured project documentation with guaranteed traceability.

1388

drift-analysis

avifenesh

This skill should be used when the user asks about "plan drift", "reality check", "comparing docs to code", "project state analysis", "roadmap alignment", "implementation gaps", or needs guidance on identifying discrepancies between documented plans and actual implementation state.

213

flow-next-plan-review

gmickel

Carmack-level plan review via RepoPrompt or Codex. Use when reviewing Flow epic specs or design docs. Triggers on /flow-next:plan-review.

11

rfc-check

meta-pytorch

Determine if proposed changes require an RFC. Use when planning significant changes, before starting major work, or when asked whether an RFC is needed.

11

feature-planning

mhattingpete

Break down feature requests into detailed, implementable plans with clear tasks. Use when user requests a new feature, enhancement, or complex change.

10

Search skills

Search the agent skills registry