code-review-skill

# code-review-skill

Reviews a diff or a commit range statically and writes an auditable report with located findings, severities and a pass or fail gate built from JSON records, without changing your code.

Made by kyy-logs on GitHub. These notes are Mindket's, written from its README; the project's own files and license are in its repository.

## About

What it is: code-review-skill is a skill for Claude Code and Codex that reviews a change and writes a report you can audit. Each finding names where the issue is, which contract or code path it touches, and how severe it is. The pass or fail gate is built from JSON records instead of text the model rewrote.

Who it suits: It suits developers and teams who want a code review that leaves an audit trail they can check.

```table
Industry | Who uses it | How they use it | Example
Software development | Developers using Claude Code or Codex | Review their uncommitted work before it goes into a commit | Staged, unstaged and new files checked against HEAD
Engineering teams | Reviewers of a change set | Review a fixed range of commits | A review of commits abc123..def456
Quality and compliance | Teams that need an audit trail | Read findings that each cite a location and severity, next to JSON records | A report plus four probe JSON files
Developer tooling | Teams building review automation | Read the gate and its counts from JSON, not from prose | A gate decision that matches its JSON
```

Where to use it: It installs into a project and follows the Agent Skills standard.

- Claude Code: installs under .claude/skills/ in your project
- Codex: installs under .agents/skills/ in your project
- Your project: run the install command from inside it

```table
Use case | Who | What they get back
Review local changes | Developers | A report on uncommitted changes, staged or not, including new files
Review a commit range | Reviewers | A report on a fixed range from a base commit to a head commit
Audit a review | Team leads | Findings with location, severity and checkable evidence, plus JSON records
Gate a change | Teams with a merge check | A pass or fail decision rendered from JSON
```

How to set it up: You need a project, an agent and a recent Node.js before you install.

- Node.js 22.20+
- Python 3.9+
- Claude Code or Codex
- A project to install it in

1. Open a terminal inside your project.
2. Run the install command for your agent and your language.
3. Use the claude-code agent option in place of codex if you work in Claude Code.
4. Install one language per project.

English, the default:

```bash
npx -y skills add kyy-logs/code-review-skill --agent codex --skill code-review --yes
```

Chinese:

```bash
npx -y skills add kyy-logs/code-review-skill --agent codex --skill code-review-zh --yes
```

How to use it: Ask your agent in plain words, or call the skill by name.

```text
Review these changes with code-review.
/code-review
Use code-review on commits abc123..def456
```

The skill has two modes. Worktree mode reviews your uncommitted changes against HEAD, and commits mode reviews a fixed range from a base commit to a head commit. The report lands in a folder under docs/work/active/, named for the review.

```table
Tool | What it does
code-review.md | The report for people to read
behavior-review.json | The behavior probe's findings
test-coverage.json | The tests probe's findings
repo-guard.json | The rules probe's findings
impact-analysis.json | The impact probe's findings
```

Example: You ask Claude Code to review your latest changes with code-review. It reads the diff, nearby source, tests and project rules, and needs no build or test run. You get code-review.md, where each finding has a location, a severity of high, medium or low and its evidence, plus four JSON records and a gate decision built from them.

For newcomers and experts: If you are new to AI code review, think of this as a reviewer that has to show its work. Install it in a project, ask for a review of your uncommitted changes, and open code-review.md. Each finding says where the issue is and how serious it is.

Underneath, four probes run in parallel in fresh contexts and cover behavior, tests, rules and impact. Each writes its own JSON. The main executor then syncs the records, checks the high findings against each other, writes the report and applies the gate. All probes use the same model, so it separates duties without being an independent human review. There is no separate verification stage, so raw findings go straight into the report and the gate.

```flow
Scope: pick worktree or commits and record commit IDs
Four probes run in parallel in fresh contexts
Each probe writes its own JSON record
The main executor reconciles high findings
Then it writes the report and applies the gate
```

Good to know:

- Read-only: it never changes the code it reviews
- Limits: it is no substitute for tests, CI or a human reviewer, and passing the gate is not a human sign-off
- Severity: three levels, high, medium and low, and records from the earlier four-level version are rejected by collect-metrics
- Validation: 87 offline tests, which are regression checks, and concurrency-defect detection has not been validated
- Version: v0.1.1 is the latest stable release, and format changes before 1.0 are listed in NEWS
- Language: English and Chinese skills exist, and you install one per project

## On GitHub, 7 November 2026

- Stars: 350
- Forks: 2
- Watching: 1
- Open issues and pull requests: 1
- Language: Shell
- License: MIT
- Topics: agent-skills, ai-code-review, claude-code, code-review, codex, developer-tools, static-analysis

## Links

- Code: https://github.com/kyy-logs/code-review-skill
- Releases: https://github.com/kyy-logs/code-review-skill/releases
- Issues: https://github.com/kyy-logs/code-review-skill/issues
- Star history: https://www.star-history.com/#kyy-logs/code-review-skill&Date

## Get the code

```
git clone https://github.com/kyy-logs/code-review-skill.git
```

Then follow the setup in its README. Nothing in this kit runs by itself.

README.md  6 KB