
Claude Code Skills for Code Review, Tested on Real Diffs
Which Claude Code Skills Actually Improve Code Review? We Tested Them.
The promise of using Claude Code for automated code review is significant. Instead of another linter, you get a partner that understands context, intent, and nuance. But with a growing ecosystem of skills, a practical question arises: which ones actually work? Which ones make your reviews faster, deeper, or more accurate? And which ones are just hype?
At SkillProof, we don’t publish listicles based on READMEs. We install and run every skill on a real-world task. Of 2172 skills tested to date, 1338 passed (62%), 725 required manual setup to run, and 109 earned a fails verdict — either because they could not be run as shipped or because their output scored below a plain Claude baseline. We publish the verdict and the test notes for every single one.
This article examines several Claude Code skills for code review that we’ve tested. It’s crucial to understand our methodology: these skills were not tested against each other in a head-to-head competition. There was no shared codebase or single leaderboard. Each skill was tested independently, on its own dedicated fixture, at different times. We compare what the skill achieved on its test versus what a plain-Claude baseline pass did on that exact same fixture. Our scores out of 10 are based on four published criteria: install, trigger, output, and documentation. You can read the full details on our methodology page.
Skills That Enforce a Review Methodology
Some of the most effective skills don’t just find bugs; they impose a systematic process on the reviewer. They turn an ad-hoc check into a repeatable, auditable discipline. This is a significant step up from just asking the base model to “find problems in this code.”
One of the highest-scoring skills in our entire catalog is Before You Refactor, which earned a 10/10. It enforces a rigid pre-refactor checklist: read the code twice, find and run existing tests, state a one-sentence goal, and—most importantly—add a characterization test for any behavior not already covered. In our test, this process caught a real regression that a naive refactor introduced. An archived record was silently claiming a deduplication ID, causing a later active record to be dropped. The naive rewrite passed all five existing tests; only the skill’s mandate to add a new characterization test for untested behavior caught the bug.
Doubt-Driven Review (9.2/10) offers a different kind of structure. It forces the reviewer into an explicit CLAIM -> CONTRACT -> adversarial-findings loop. We tested it on a real production scenario involving a database column drop. The baseline model gave a decent ad-hoc safety checklist. The skill, however, structured the review to surface a missing-backup gap and a lock-contention-under-load edge case that the baseline only hinted at. The final output was an auditable ‘revise, don’t approve yet’ verdict.
We also built a skill in this category ourselves. Review Discipline (9.2/10) is our own open-source skill (source Skillproofdev/review-discipline), and we must disclose that it was tested under the same protocol as all third-party skills. It enforces a strict order of operations: read the full diff, hunt for all anomalies exhaustively, and only then verify them with a demonstrated failure path. On a benchmark with 21 seeded bugs, our skill caught 18.5 (88%) versus the unguided baseline’s 17 (81%), with zero false positives. You can read more about what Review Discipline actually buys you in our deep-dive post.
Systematic Checklists for Finding Bugs
A common type of checklist skill for Claude Code review provides a structured set of questions to ask about a piece of code, covering areas a human reviewer might forget. These are more than just prompts; they are self-contained methodologies.
Code Review Checklist scored a strong 9.6/10. We ran it against a two-endpoint Express.js snippet. A naive baseline review caught the obvious SQL injection vulnerability. The skill’s systematic checklist, however, surfaced four additional Critical findings the baseline missed entirely: an Insecure Direct Object Reference (IDOR) on the orders route, an unauthenticated password-reset endpoint, plaintext password storage, and a lack of rate limiting. Its 9.6 comes from a single point lost on the output criterion of our four-part rubric.
For API development, API Design Reviewer (8.4/10) walks an implementation through a fixed 10-section checklist covering everything from authentication and resource design to pagination and idempotency. On a deliberately sloppy 4-route Express file, a baseline pass caught the most blatant issues. The skill’s structured approach additionally surfaced problems with API versioning, the lack of an idempotency-key handler for a POST endpoint, and missing rate limits, packaging it all into a prioritized P0-P3 report.
Specialist Skills for Specific Domains
General-purpose reviews are useful, but sometimes you need expertise in a specific framework or problem domain. Several skills provide that focused analysis. It does not always beat a generalist pass on the same code, but it changes what gets checked and how findings are graded.
| Skill | Score | Primary Strength | Test Domain |
|---|---|---|---|
| React Senior Code Review | 9.6/10 | Architectural & A11y issues | React (.tsx) |
| Fortify Change Review | 9.2/10 | Mapping changes to Fortify rules | Java (Security) |
| Concurrency Review | 8.0/10 | Checklist for multithreading safety | Java (Concurrency) |
React Senior Code Review (9.6/10) is a prime example. It focuses on a React feature’s architecture—structure, data flow, performance—not just linting. When we tested it on a deliberately messy TodoList.tsx component, it correctly escalated a mouse-only row toggle to CRITICAL because keyboard users couldn’t interact with it at all. This is a severity judgment the untargeted baseline review completely missed. Every finding it produced came with a file:line citation, a rubric-matched severity, and a real code snippet for the fix.
For security-focused Java teams, Fortify Change Review (9.2/10) maps a code change to relevant Fortify security checks. We tested it against a UserRepo.java file with a planted SQL injection and an unauthenticated admin route. It correctly flagged both the obvious ORDER BY injection and a second, more subtle injection point in a DELETE string that many reviewers would skip. Each finding was emitted with the file, line number, attack path, and Fortify category, ready for triage.
All-Rounders and Tool-Augmented Skills
Some skills aim to be a comprehensive, one-shot tool for automated code review claude code, often by integrating with local developer tools like git.
Code Health Check earned a perfect 10/10 score. It’s important to note the test context: we ran it against the demo application that the skill’s own authors shipped in the same repository—a deliberately buggy Express API. The skill performed flawlessly, catching all eight planted issues, from SQL injection and eval() abuse to hardcoded secrets and dead code, all with correct severity labels and file:line citations.
Another powerful tool-based skill is Review All (9.2/10). It can review uncommitted changes, a commit range, or a GitHub PR. Its key differentiator is verification. During our test, its bundled discover.sh script worked cleanly. It caught a real command-injection bug in a throwaway diff (a child_process.exec call with unsanitized input) and then proved it was exploitable by generating a proof-of-concept that wrote a marker file to /tmp. That’s a verified finding, not a guess.
Even when a skill finds the same bugs as a baseline review, its structure can be the main value. Agentic Code Review (8.8/10) reviewed a diff with a planted auth bug, a privilege escalation, and a raw SQL injection. The baseline prose review also caught all three. The skill’s contribution was formatting them as a prioritized P0-P3 list, turning a wall of text into scannable, actionable findings with exact file:line references, concrete fix code, and a paired suggestion for a regression test.
When Skills Don’t Pass: Failures and Manual Setup
We believe publishing failures is essential. A skill that does not work out of the box wastes a developer’s time. Of the 2172 skills we have run, 109 earned a failing verdict. That does not always mean the skill’s logic is bad. Some cannot be installed as shipped; others install fine and simply do not beat the baseline.
A clear example is Code Review and Quality, which earned a failing verdict on two counts. The first is an install defect: the documented install copies the skill’s folder but silently omits the repo-root references/ directory that the skill’s own SKILL.md points at, so two checklist files have to be copied across by hand. The second is the one that decides the verdict. In an A/B review of a deliberately buggy PR, the skill arm produced a well-structured, severity-labeled review, but the no-skill baseline caught every issue it caught plus one more, an undeclared router. The skill added format discipline, not substance, so fixing the packaging would not by itself earn a pass. It did not hallucinate issues, and as a written reference on review methodology it is solid; it just did not beat the baseline that a capable agent gives you for free.
Beyond outright failures, 725 skills landed in our setup category: they work, but only after configuration, a companion skill, or a connected integration that the install alone does not give you. Understand: Diff (8/10) is one such skill, and it is honest about it — its SKILL.md says upfront that it is inert without a knowledge graph built by a sibling skill the install command does not fetch. Once the graph exists, it earns its keep: in our A/B both arms produced equivalent risk reports, but the skill arm ran its freshness check and caught that the graph predated a login MFA change, which would have made the blast-radius call silently wrong. Our test notes for every setup skill record the exact steps we took to get it running.
Finding the Right Skill for Your Workflow
There is no single best claude skill for code review. The right choice depends on your team’s needs, your tech stack, and the problem you’re trying to solve. A skill that enforces a strict refactoring process like Before You Refactor is invaluable for large-scale changes, while a specialist tool like React Senior Code Review is better for targeted component reviews.
The key is to choose a tool that has been independently verified to work as advertised. A passing verdict on SkillProof means the skill installs cleanly, triggers reliably, and produces output that is better than a baseline model on a real task.
Related reading: The companion piece to this one applies the same testing to repair rather than review: Claude Code skills for debugging, and which ones find the bug. For the wider picture of what passed across the whole coding category, see the best Claude skills for coding.
Finding the right tool for your workflow starts with a catalog that tests them. You can browse all our tested coding skills to see the full list of verdicts and test notes. For those focused on security, the Security & Code Review Pack bundles several verified skills for a one-time $10 purchase.
★ 9.6/10 × 3
The free starter pack
3 skills with our highest test scores plus the install checklist — the setup we'd put on a fresh machine. Free, by email.