Skip to main content
skill CX Codex

Self-Review · wrg32786 — Claude Code skill: what it does, how to install

The Self-Review Claude Code skill sends substantial code changes through a focused second review. It targets multi-file edits, hot paths, prompts, and work that still feels uncertain.

MIT ★ 26 updated 2026-11-16

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

What Self-Review does

Self-Review prepares a concise account of the request, the cause of the issue, and the change made. It lists affected files, then asks focused questions tied to a function or line and a possible failure. Edge cases and interactions with code outside the change are part of the review too.

The skill passes this context to a code-reviewer subagent through the Agent tool and requests HIGH, MEDIUM, or LOW ratings with line references. HIGH findings must be fixed before the work is declared done; decisions on MEDIUM and LOW findings are recorded with their reasons. A mechanical one-line edit can be skipped, but the skip must be stated. Running the review requires the Agent tool and a code-reviewer subagent.

What it helps with

  • review a change spanning several files
  • look for regressions in a hot path
  • check edge cases after a code change
  • assess a reviewer’s disputed finding

Example prompts for the agent

  • Review this change separately and identify possible regressions with line references.
  • Check the edits across these files for edge cases and unintended interactions.
  • Before finishing, ask the code-reviewer subagent to inspect the change.

How to install Self-Review

1Skills CLI (Vercel)

npx skills add wrg32786/aigent-os --skill self-review -a claude-code

2Manually: put the files in place

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

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

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

Questions about Self-Review

How do I install Self-Review in Claude Code?

Run npx skills add wrg32786/aigent-os --skill self-review -a claude-code. The skill file is placed at ~/.claude/skills/self-review/SKILL.md.

What does Self-Review do?

It prepares targeted questions about failure modes, edge cases, and regressions, then sends them to a reviewer subagent. Findings receive severity ratings and code-line references.

What changes should trigger Self-Review?

It is meant for changes over 30 lines, multi-file edits, hot paths, user-facing prompts, or work that leaves genuine uncertainty. A trivial one-line edit can be skipped if the skip is stated explicitly.

Source text

SKILL.md · MIT
---
name: Self-Review
description: "Spawn a reviewer with specific verification questions. Use when reviewing code changes over 30 lines, across files, in hot paths or prompts, or with uncertainty."
---

# Self-Review

Run an explicit second-pair-of-eyes pass on non-trivial work before declaring done. Quality of review depends on quality of question.

## When to RUN self-review

- More than ~30 lines OR multi-file change
- Hot path (many requests flow through this code)
- Subtle interactions with code you might have missed
- Prompt or output affecting user-visible content
- Code not worked in recently (mental model might be stale)
- Any genuine uncertainty after writing the change

## When to SKIP self-review

- One-line edit, mechanical fix, obvious diff
- Pure rename or move with no logic change
- Code just written with full context, low blast radius
- Cost-benefit doesn't justify (review takes longer than the fix did)

If skipping, say so explicitly: "Skipping self-review — N-line trivial fix." Don't silently bypass.

## How to execute

### Step 1 — Set context (3-5 lines max)

State, in plain language:
- The bug / feature / what was asked
- The cause (what was actually wrong)
- The fix (what was actually changed)

### Step 2 — List specific changes

```
- path/to/file_one.ts:L123-L145 — replaced regex with structured parser
- path/to/file_two.ts:L56 — added null guard for empty corpus
- path/to/config.json — bumped diversity_threshold 0.6 → 0.75
```

### Step 3 — Ask 4-6 specific verification questions

**Bad asks (do not produce useful answers):**
- "Is this good?"
- "Does this look right?"
- "Any issues?"
- "Did I miss anything?"

**Good asks (concrete, falsifiable, named):**
- "Does the new keyword order ever cause a wrong branch in `routeRequest`?"
- "Does the diversity rule reach the model in the same prompt as the recent-titles list?"
- "Is the early return at line 47 still bypassing this check?"
- "If `recent_titles` is empty (first run), does the sort comparator return stable output?"
- "Does the schema migration handle the existing 12K `null` rows or only new inserts?"

Each question must:
- Reference a specific file:line or function name
- State the failure mode you're worried about
- Be answerable yes/no after a focused read

### Step 4 — Ask explicitly about edge cases, regressions, missed interactions

```
"Edge cases I'm uncertain about:
- What happens when input X is empty?
- Does this break callers Y and Z that I didn't read?
- Any regression on the prior fix from PR #N?"
```

### Step 5 — Request severity ratings + line references

```
"Please rate findings as HIGH / MEDIUM / LOW with concrete line references."
```

### Step 6 — Spawn the reviewer subagent

Use the Agent tool with a code-reviewer subagent_type (or equivalent). Pass the full context block (steps 1-5) as the prompt. Set model to whatever is appropriate for the review depth.

### Step 7 — Process findings

- **HIGH severity** → fix before declaring done
- **MEDIUM severity** → fix unless you have a specific reason not to. If skipping, document why.
- **LOW severity** → judgment call. Often fold into a follow-up note.
- **Reviewer misread** → trust your own reading, but re-verify before dismissing. A misread is a signal the code might need clarity.

The reviewer is a **second pair of eyes, not an authority.** Evaluate every suggestion. Blindly applying every note is as bad as ignoring them all.

## Output format

After review completes, append to your delivery message:

```
**Self-review:** {APPROVED — severity X} / {N findings applied} / {N deferred — listed below}
- {finding} → {fix applied OR reason deferred}
```

© wrg32786 · MIT · wrg32786/aigent-os

Similar skills

All skills for Code review and refactoring →

Self-Review by other authors comes first.

self-review lingzhi227 The self-review skill reviews an academic paper with the NeurIPS form, three reviewer roles, and score aggregation. Use it to assess a draft before submission. CX Codex +1 1,700installs self-review sammcj self-review — a skill that critically reviews your recent changes and fixes what it finds. Small edits it handles itself; larger ones go to a sub-agent. CX Codex +1 ★ 173repo stars tooluniverse-self-review mims-harvard tooluniverse-self-review evaluates current work against original requirements and surfaces verified gaps, risks, and next fixes without scoring. CX Codex +1 111installs self-eval Alireza Rezvani The self-eval skill rates AI work on two axes, checks for inflated scores, and keeps an evaluation history. Use it after a task, code review, or work session. CX Codex +1 575installs self-improvement-ci pskoett self-improvement-ci — a CI-only skill that groups recurring pull request check failures and proposes rules so the same breakage stops coming back. CX Codex +1 550installs paper-self-review Galaxy-Dawn paper-self-review is a Claude Code skill that checks academic paper structure, reasoning, and whether evidence supports its claims. It runs for self-review before a journal or conference submission. CX Codex +1 702installs performance-review-self-assessment thedesignproject The performance-review-self-assessment Claude Code skill guides employees through a quarterly self-assessment. It covers accomplishments, challenges, leadership principles, and progress on development goals. CX Codex +1 ★ 107repo stars self-improve Yeachan-Heo self-improve is a Claude Code skill that runs an autonomous code-improvement loop with tournament selection, spawning agents to benchmark and choose changes. CX Codex +1 809installs

From the same set58

The whole set →
Skill Audit The Skill Audit Claude Code skill checks skill usage and whether descriptions match the prompts that trigger them. It also flags idle skills and recurring work with no matching skill. CX Codex +1 ★ 26repo stars ship-adapter The ship-adapter Claude Code skill turns schemas and API contracts into adapters. It runs for database adapters, API client wrappers, interface adapters, and data transformers. CX Codex +1 ★ 26repo stars setup This Claude Code skill configures aigent-OS identity, priorities, and authority boundaries. Run /setup to configure the system or revise specific sections later. CX Codex +1 ★ 26repo stars semantic-search The semantic-search Claude Code skill searches an Obsidian vault by meaning using local embeddings. It runs for finding related notes or recalling what you wrote about a topic. CX Codex +1 ★ 26repo stars scout-vault The scout-vault Claude Code skill finds related vault notes, links, and code definitions. It runs for note discovery, vault inventory, or call-chain searches. CX Codex +1 ★ 26repo stars Sandbox Routing Sandbox Routing — a skill for Claude Code routes large-file analysis and lengthy command output through sandbox tools. It activates when an agent needs a small detail without pulling the full output into context. CX Codex +1 ★ 26repo stars resume Restores context for unfinished work. Run /resume to compare the saved capsule with live memory and take the next step. CX Codex +1 ★ 26repo stars research-deep The research-deep Claude Code skill combines vault notes, web sources, and GitHub research into a cited briefing with evidence and a recommendation. It runs on requests to investigate a topic or compare sources. CX Codex +1 ★ 26repo stars

Project sponsors

Companies that keep this analytics open