Skip to main content
skill CX Codex

code-review · josstei — Claude Code skill: review and install

The code-review skill sets a review workflow, ranks findings by severity, and reports each issue with a file, line, and proposed fix. Use it to review diffs or new files.

Apache-2.0 ★ 489 updated 2026-10-26

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add josstei/maestro-orchestrate --skill code-review -a claude-code
Open on GitHub

What code-review does

The skill selects a review scope from user-provided paths, staged changes, or the latest commit, in that order. It asks the user to confirm the scope before proceeding. When a scoped file has no diff, its current contents are included; the reviewer also receives nearby code and detected language and framework details.

Findings appear in a table, grouped as Critical, Major, Minor, or Suggestion, followed by a summary. Each finding must point to a file and line, be checked against the actual code, and include a concrete action. Speculative issues and comments outside the review scope are excluded. Repeated root causes found across three or more files are consolidated into one systemic finding.

New files get a full review, while refactors are checked for behavior changes. Scope confirmation is required; if no paths or usable diff are available, the skill asks the user to choose what to review.

What it helps with

  • choose which changes belong in a review
  • locate security flaws and bugs by file and line
  • rank findings by severity
  • consolidate recurring issues across files
  • check that refactoring preserves behavior

Example prompts for the agent

  • Review the staged changes and confirm the scope before proceeding.
  • Review the new file src/auth.ts and report verified findings with fixes.
  • Check the latest commit for regressions and consolidate repeated issues.

How to install code-review

1Skills CLI (Vercel)

npx skills add josstei/maestro-orchestrate --skill code-review -a claude-code

2Manually: put the files in place

~/.claude/skills/code-review/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/code-review/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about code-review

How do I install code-review in Claude Code?

Run npx skills add josstei/maestro-orchestrate --skill code-review -a claude-code. The skill is installed at ~/.claude/skills/code-review/SKILL.md.

What does the code-review skill do?

It selects review scope, passes context to the code-reviewer agent, and formats verified findings by severity. Each finding needs a file, line, and concrete fix.

How does the skill choose what to review?

It checks user-provided paths first, then staged changes, then the latest commit. It confirms the selected scope with the user before starting.

Source text

SKILL.md · Apache-2.0
---
name: code-review
description: Standalone code review methodology for structured, severity-classified code assessment
---

# Code Review Skill

Activate this skill when performing standalone code reviews via the runtime-specific Maestro review entrypoint or during orchestration quality gates (the final completion gate). This skill provides the methodology for scoping, executing, and reporting code reviews.

## Scope Detection Protocol

Determine review scope using the following priority order:

1. **User-specified paths**: If the user provides file paths or glob patterns, expand glob patterns using the `glob` tool to resolve them to concrete file paths before delegating to the `code-reviewer` agent
2. **Staged changes**: If `git diff --staged` produces output, review staged changes
3. **Last commit diff**: If no staged changes exist, review the last commit via `git diff HEAD~1`
4. **Fallback**: If none of the above yield content, ask the user to specify scope

Always confirm the detected scope with the user before proceeding.

If scope is provided as file paths and a git diff is empty for some paths (for example, new unstaged files), include those files' current contents directly in review context so they are still reviewed.

## Review Orchestration

### Delegation Flow

1. Detect review scope using the protocol above
2. Gather the full diff content for the detected scope, and include current file contents when diff content is unavailable for scoped files
3. Delegate to the `code-reviewer` agent with:
   - The full diff content
   - File paths involved
   - Any user-provided focus areas or concerns
4. Process the agent's Task Report
5. Present findings to the user in the structured output format below

### Context Enrichment

When delegating to the `code-reviewer` agent, include:
- The diff content (not just file names)
- Surrounding context for modified sections (10 lines before/after when available)
- Project language and framework information (detected from package.json, Cargo.toml, go.mod, etc.)

## Severity Classification

### Critical
Issues that could cause security vulnerabilities, data loss, or system crashes:
- SQL/NoSQL injection vectors
- Authentication/authorization bypasses
- Unvalidated user input at system boundaries
- Resource leaks (unclosed connections, file handles)
- Race conditions with data corruption potential

### Major
Issues that cause bugs, design flaws, or significant maintainability problems:
- Logic errors in business rules
- Missing error handling on external calls
- SOLID principle violations that impact extensibility
- Incorrect API contracts or type mismatches
- Missing null/undefined checks on external data

### Minor
Issues related to style, naming, or minor convention violations:
- Naming inconsistencies
- Code style deviations from project conventions
- Suboptimal but correct implementations
- Missing type annotations where inference is insufficient

### Suggestion
Optional improvements that enhance readability or maintainability:
- Alternative patterns that improve clarity
- Performance optimizations with marginal impact
- Structural improvements for future extensibility

## Output Format

Present findings in a structured table followed by a summary:

```
## Code Review Results

**Scope**: [description of what was reviewed]
**Files Reviewed**: [count]
**Total Findings**: [count by severity]

### Findings

| # | Severity | File | Line | Description | Suggested Fix |
|---|----------|------|------|-------------|---------------|
| 1 | Critical | path/to/file.ts | 42 | [description] | [fix] |
| 2 | Major | path/to/file.ts | 87 | [description] | [fix] |

### Summary

[1-2 paragraph summary of overall code quality, patterns observed, and priority actions]
```

## Verification Rule

Every finding **must**:
- Reference a specific file and line number
- Be verified against the actual code (not assumed from patterns)
- Include a concrete suggested fix or action
- Be classified with a severity that matches the classification criteria above

Do NOT report:
- Speculative issues based on assumptions about runtime behavior
- Style preferences not established by the project's conventions
- Issues in code outside the review scope

## Review Scope Calibration

Calibrate the depth and focus of review based on the type of change being reviewed:

### Calibration Rules
- **New files**: Full review across all dimensions — architecture fit, pattern compliance, security, naming conventions, error handling, testability, dependency direction
- **Modified files (behavior change)**: Focus on the diff — correctness of new behavior, regression risk, contract compliance with existing interfaces, edge case handling in new code paths
- **Modified files (refactoring)**: Focus on behavior preservation — verify same inputs produce same outputs, no unintended side effects introduced, no behavior changes disguised as refactoring
- **Deleted files**: Dependency verification — confirm no remaining code imports from, references, or depends on the deleted files. Check for orphaned tests that tested the deleted code.
- **Configuration changes**: Environment impact assessment — does this change affect production? Staging? Local development? All environments? Are there secrets or credentials involved?

### Application
When reviewing a diff that contains multiple change types (new files + modifications + deletions), apply the appropriate calibration to each file independently. Do not apply "new file" depth to a file that only had a minor modification.

## Finding Deduplication Protocol

When reviewing multiple files, identify and consolidate findings that share the same root cause.

### Deduplication Rules
- If the same pattern violation appears in 3+ files, report it **once** as a systemic finding with the list of all affected locations — not as N separate findings
- A systemic finding includes: the pattern being violated, why it matters, the full list of affected file:line locations, and a single remediation recommendation that addresses all instances
- Unique findings (appearing in only 1-2 files) are reported individually as normal

### Deduplication Format
```
### Systemic Finding: [Pattern Violation Name]
- **Severity**: [Critical | Major | Minor | Suggestion]
- **Description**: [What the pattern violation is and why it matters]
- **Affected Locations**:
  - `path/to/file1.ext:line` — [brief context]
  - `path/to/file2.ext:line` — [brief context]
  - `path/to/file3.ext:line` — [brief context]
- **Remediation**: [Single recommendation that addresses all instances]
```

This produces cleaner, more actionable review output by surfacing systemic issues as patterns rather than repeating the same finding across multiple files.

© josstei · Apache-2.0 · josstei/maestro-orchestrate

Similar skills

All skills for Code review and refactoring →

code-review by other authors comes first.

code-review Matt Pocock code-review evaluates code diffs along two parallel tracks: project standards and issue specifications. Uses isolated sub-agents to keep findings clean. CX Codex +1 789,521installs code-review official anthropics The code-review skill reviews diffs and pull requests for security, performance and correctness. Useful when a change needs a look before merging. CX Codex +1 10,300installs code-review agno-team code-review is a Claude Code skill that checks code for style issues, bugs, and vulnerabilities. It runs a linter and provides structured feedback by severity. CX Codex +1 478installs code-review vectorize-io The code-review skill checks changed code against project rules, including tests, dead code, typing, linting, and conventions. Run it after implementation work. CX Codex +1 178installs code-review coderabbitai code-review is a Claude Code skill that runs CodeRabbit reviews and explains its findings. It activates for code, pull request, quality, and security review requests. CX Codex +1 16,700installs review-pr-lite dyoshikawa review-pr-lite is a Claude Code skill that reviews pull requests for code defects and security risks without subagents. It also checks GitHub Actions after reviewing changes. CX Codex +1 ★ 1,636repo stars review SethGammon This skill reviews code in five passes, covering correctness, security, performance, readability, and consistency. Use it on a file, directory, or Git diff. CX Codex +1 ★ 937repo stars codex-review Sateezg codex-review is a Claude Code skill that asks OpenAI Codex to review code changes independently. It runs on requests to inspect a PR, branch, or module, and before a substantial commit or merge. CX Codex +1 ★ 195repo stars pull-request-review autohandai pull-request-review — a skill that reviews a pull request or branch diff: checks the change against the issue, hunts correctness and security defects, and returns prioritized comments. CX Codex +1 ★ 219repo stars review-pr SeifBenayed review-pr walks a branch diff against a checklist: bugs, security, performance, tests. Ends with a verdict — approve, request changes or discuss. CX Codex +1 ★ 116repo stars production-readiness-review vaibhav-space production-readiness-review is a Claude Code prompt for auditing repository changes before a commit or deployment. It checks diffs, code, tests, and integration points. GP ChatGPT ★ 336repo stars

From the same set40

The whole set →
data-engineer data-engineer designs database schemas, optimizes SQL queries, and builds ETL pipelines. Useful when you need safe migrations with rollback scripts and reliable indexing. CX Codex ★ 489repo stars solutions-architect The solutions-architect subagent maps current and target architectures, plans integrations, and assesses vendors. Use it when a design spans multiple systems or teams. CX Codex ★ 489repo stars performance-engineer performance-engineer finds performance bottlenecks through profiling and measurement rather than guesswork, then ranks fixes by expected impact. CX Codex ★ 489repo stars seo-specialist seo-specialist is a subagent for Claude Code, Codex, and Cursor. It audits SEO, checks crawlability, and generates JSON-LD schema markup. CX Codex ★ 489repo stars technical-writer technical-writer writes README files, API references, ADRs and JSDoc after reading the actual code, so docs match real behavior instead of intent. CX Codex ★ 489repo stars refactor Subagent for codebase refactoring without altering existing behavior. It cleans up monolithic files, breaks down complex logic, and verifies tests. CX Codex ★ 489repo stars devops-engineer devops-engineer automates work on CI/CD, containers, and infrastructure. Use it to configure a build pipeline, write a Docker setup, or prepare deployment scripts. CX Codex ★ 489repo stars security-engineer security-engineer — a subagent for checking code against OWASP Top 10 vulnerabilities, auditing authentication, and scanning dependencies. Builds threat models and delivers prioritized remediation reports. CX Codex ★ 489repo stars

Project sponsors

Companies that keep this analytics open