dev-code-review

Evaluate uncommitted git changes for style, correctness, completeness, and dead code.

5|Updated Apr 29, 2026
One-click install
npx skills add https://github.com/Jason-chen-coder/dev-skills --skill dev-code-review
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dev-code-review
Source: https://github.com/Jason-chen-coder/dev-skills/tree/main/skills/dev-code-review
Command: npx skills add https://github.com/Jason-chen-coder/dev-skills --skill dev-code-review

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps developers review uncommitted code changes across five axes to catch issues before they enter version control, ensuring higher code quality and team consistency.

Core Features & Use Cases

  • Focused Pre-commit Review: Analyze current git changes for standards, functionality, completeness, comments, and dead code.
  • Issue Flagging: Identifies style violations, potential bugs, untracked unused symbols, and leftover debugging statements.
  • Use Case: When preparing a commit, automatically review all staged and unstaged changes to ensure adherence to project standards and avoid common pitfalls.

Quick Start

Run the skill in your project directory to review all pending git changes and catch issues before committing.

Frequently Asked Questions about dev-code-review

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

FAQPage Schema
How do I review uncommitted git changes for code quality and style violations?

To review uncommitted git changes, you can run this skill in your project directory to analyze staged and unstaged code for style violations, potential bugs, and leftover debugging statements before committing.

What is a pre-commit code review and how does it catch dead code?

A pre-commit code review evaluates pending git changes across five axes—style, correctness, completeness, comments, and dead code—to identify untracked unused symbols and leftover statements before they enter version control.

Does this pre-commit review work across multiple programming languages?

Yes, this pre-commit review applies across multiple programming languages, checking for best practices, file cleanliness, and potential issues in integration scenarios regardless of the specific tech stack.

What's the best way to check for potential bugs and completeness before a git commit?

The best way to check for bugs before a git commit is to perform an axis-based review of current git changes, evaluating code correctness, completeness, and adherence to project standards automatically.

Can I use static analysis to flag leftover debugging statements in my code?

Yes, you can use static analysis to flag leftover debugging statements, style violations, and untracked unused symbols by evaluating your uncommitted code changes before they are committed.

Why should I run a pre-commit review instead of checking code manually?

Running a pre-commit review ensures higher software quality and team consistency by automatically catching style violations, potential bugs, and dead code across your uncommitted changes, avoiding common pitfalls that manual checks miss.