Skill82.2k repo starsupdated 2d ago

deep-review

Multi-dimensional code review. Use when the user asks to review, evaluate, or audit a PR, diff, branch, or pasted change — including informal review asks like "look at this change for problems" — via light mode: one independent reviewer against the dimension quick checklists. Not for explain-only questions about what a change does or why. Deep mode runs only on explicit invocation (/deep-review), and normally at most once per logical requirement.

View source Repository: lobehub

Install in Claude Code

Copy

git clone --depth 1 https://github.com/lobehub/lobehub /tmp/deep-review && cp -r /tmp/deep-review/.agents/skills/deep-review ~/.claude/skills/deep-review

Then start a new Claude Code session; the skill loads automatically.

Definition

SKILL.md

# Deep Review

Multi-dimensional code review built on independent reviewers. Review breadth comes from parallel
dimension coverage; precision comes from adversarial verification and global duplicate
consolidation before findings reach the report.

## Core principles

Every design choice below serves one of these. When unsure how to execute a step, come back here.

1. **Anti-hallucination** — reviewers that only see diff fragments invent bugs. Candidate findings are therefore falsified one by one by an **independent verify subagent** that reads full context and returns a three-way verdict (`confirmed` / `false_positive` / `need_more_context`). Three-way verdicts beat confidence percentages: calibrated-sounding scores are unreliable as hard filters.
2. **Anti self-approval** — an agent that just wrote the code is grading its own homework and will pass it. Both modes use an **independent reviewer** with a third-party stance. Light: one reviewer that is not the main agent. Deep: independent subagents per the environment manual. Never silently degrade either mode to "the main agent reviews the diff itself".
3. **Rules over model** — review quality comes from fine-grained, executable dimension rules, not from a smarter model. Subagents run on balanced/fast model tiers; each dimension file tells them exactly how to check, what counts, and what does not.
4. **Calibrate to codebase and lifespan** — hold the diff to the standard the codebase already meets, not an idealized one. If a pattern is widespread in the existing code and this diff does not make it worse, it is not a finding. Declared-temporary code (time-boxed campaign, experiment, one-off script) is judged against its lifespan: hardcoding and low-extensibility shortcuts are the intended trade-off for shipping fast, and "delete the code at expiry" is a valid plan — do not demand configurability from code built to be deleted. (Security is exempt from all calibration — see the dimension file.)
5. **Speed is a feature** — one wave of parallel reviewers, verification pipelined per dimension (never a global barrier), irrelevant dimensions pruned up front.

## Two entry modes

| Mode | Trigger | What runs |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Light** (default) | Any ordinary review ask: "review this PR", an informal "look at this change for problems", a diff pasted for review — but not explain-only questions about a change | One independent reviewer against the **Quick checklist** of each applicable dimension. Prefer a different-vendor harness when the session can dispatch to one; otherwise one same-harness subagent. No verify pass. The main agent does not review. |
| **Deep** | Explicit only: `/deep-review`, "run deep review", "full multi-agent review" | Full orchestration: dimension review agents → pipelined verification → global consolidation → structured report → interactive fix flow. |

Do not auto-escalate light to deep. Do not run deep mode for a casual "看看这个改动" — that is light mode.

### Deep-mode budget

Within one logical requirement (the same requirement, PR, or branch), run Deep mode at most once by
default. Follow-up reviews after fixes, CI work, rebases, cleanup, context compaction, or a resumed
session use Light mode, even when they review the whole diff again. These events do not reset the
budget, and the review/verify/consolidate waves inside one Deep run all count as that single run.

Run Deep again only when the user explicitly requests another Deep pass, or when a genuinely new
logical requirement begins. A casual follow-up such as "review again", "复核一下", or "再看看" is a
Light request, not implicit authorization for another Deep run.

## Dimensions

Rules live in one place: [`references/dimensions/`](references/dimensions/), one file per dimension.
Both modes use the same files. The light reviewer reads the full `Quick checklist` section,
including nested example subsections; deep-mode agents read the full dimension file plus only the
rule sources and routed references applicable to the touched surface.

| Dimension | id prefix | Covers | Verified? |
| --------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------- |
| [ai-coding-bad-habits](references/dimensions/ai-coding-bad-habits.md) | `ai` | narrow special cases in generic code, partial refactors, redundant type