review-changes

Analyze git changes for plan compliance and engineering issues.

5|3|Updated Oct 23, 2025
One-click install
npx skills add https://github.com/Cygnusfear/claude-stuff --skill review-changes
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-changes
Source: https://github.com/Cygnusfear/claude-stuff/tree/main/skills/review-changes
Command: npx skills add https://github.com/Cygnusfear/claude-stuff --skill review-changes

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solves? Manual code reviews are time-consuming and can miss critical issues like bugs, over-engineering, or deviations from the original plan. This skill automates a thorough code review of current git changes, identifying engineering issues and ensuring quality before merging.

Core Features & Use Cases

  • Comprehensive Git Diff Analysis: Systematically reviews all added, modified, and deleted files in the current working copy.
  • Plan Compliance Verification: Compares changes against existing implementation plans, checking for adherence to design, architecture, and REMOVAL SPEC compliance.
  • Engineering Issue Identification: Flags bad engineering (logic bugs, poor error handling), over-engineering (unnecessary abstraction), and suboptimal solutions (duplication, poor naming).
  • Use Case: Before submitting a pull request, use this skill to get an automated, in-depth review of your changes, ensuring quality, adherence to project standards, and catching critical bugs or architectural flaws early.

Quick Start

See changed files

git status

See detailed diff

git diff

See both staged and unstaged changes

git diff HEAD

Frequently Asked Questions about review-changes

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate code review before submitting a pull request?

Automate code review by analyzing your git changes against your implementation plan. This identifies engineering issues like bugs, validation gaps, and scope creep across all modified files, catching problems before merge.

What engineering issues can a git diff analysis catch?

Git diff analysis flags logic bugs, poor error handling, unnecessary abstraction, code duplication, tight coupling, and deviations from your original design plan—issues that manual review often misses.

How do I verify my changes align with the implementation plan?

Compare your current git changes against existing implementation plans to check design adherence, architecture compliance, and removal spec requirements, ensuring scope stays within original intent.

Can I use this to review staged and unstaged changes?

Yes, you can review all git changes—staged, unstaged, added, modified, and deleted files. Use `git diff HEAD` to see both staged and unstaged changes together before analysis.

What's the best way to catch over-engineering in code changes?

Systematic diff analysis identifies over-engineering by categorizing changes by type and flagging unnecessary abstractions, allowing you to simplify before merge and maintain code quality.

Do I need existing documentation to use code review analysis?

An implementation plan improves review accuracy by enabling plan compliance verification, but the skill also works without one—it still identifies bugs, coupling issues, and engineering problems in your changes.