What makes a good code review skill
Code review splits into two very different jobs that get lumped under one label: judging whether an approach is sound, and mechanically checking a diff against a known set of standards, style, test coverage, duplication, backward compatibility, whether a release is actually safe to ship. Agents are genuinely good at the second job and shouldn't be trusted alone with the first. The strongest skills in this category commit fully to the mechanical half: they name a specific check, run it the same way every time, and produce output a human can act on quickly rather than a vague "looks good."
The weak version of a code-review skill is one that just says "reviews code" and leaves the actual standard undefined. That's not a skill, it's a restatement of what any agent already attempts by default. Every entry below does something narrower and more concrete: checking for duplicated logic specifically, triaging an existing review thread, auditing a release candidate against the previous tag.
How this list is ordered
Broadest applicability first. Quality Playbook Generator leads because it's language-agnostic and addresses the full review surface rather than one slice of it. Review Duplication and Async PR Review follow. Both come from Gemini CLI and apply to any codebase or PR workflow, not one company's internal tooling. From there the list moves toward skills scoped to a specific platform (GitHub Copilot's own review comments, a Paperclip AI instance's PRs) and finally to skills tied to one project's internal conventions (VS Code's tool-naming rules, Supabase Studio's testing strategy, a specific repository's release process). Popularity and repo activity broke ties inside each tier, but scope match came first.
| Skill | Best for | Requires |
|---|---|---|
| Quality Playbook Generator | Full-codebase quality audit, any language | Python, shell |
| Review Duplication | Catching reinvented logic during review | Nothing extra |
| Async PR Review | Background PR checks without blocking work | Shell |
| Copilot PR Autopilot | Triaging GitHub Copilot's own review comments | Nothing extra |
| PR Gardening | Auditing merge-readiness of an AI instance's PRs | Node.js, shell |
| Tool Rename Deprecation | Backward-compatible tool renames | Nothing extra |
| Studio Testing Strategy | Deciding what test type a change needs | Nothing extra |
| Unit Test Vue Pinia | Reviewing Vue 3 + Pinia unit tests | Nothing extra |
| Final Release Review | Auditing a release candidate before shipping | Shell |
The nine skills
Quality Playbook Generator
From GitHub's awesome-copilot collection (38,000 stars), this runs a genuinely comprehensive audit: it derives behavioral requirements from the code itself, generates spec-traced functional tests, runs a three-pass review with regression tests, executes a multi-model "Council of Three" spec audit, and produces a consolidated bug report with TDD-verified patches. It's built to catch the class of real defects (the skill's own materials cite roughly 35% of them) that structural review alone misses.
Who it's for: teams that want a deep, occasional audit rather than a lightweight per-PR check, and are willing to spend the time a genuinely thorough pass takes. Requires Python and shell access, and is marked advanced complexity. Caveat, from the skill itself: not worth it for very small codebases where a manual review is already sufficient. MIT licensed.
Review Duplication
From Google's gemini-cli repository (106,000 stars), this skill does one thing during a review: proactively investigates the codebase for duplicated functionality, reinvented logic, or a failure to reuse existing project utilities and established patterns.
Who it's for: any team that wants duplication caught systematically rather than relying on a reviewer happening to remember a similar utility exists elsewhere. No runtime requirements beyond the agent's normal codebase access. Caveat: not useful for reviewing entirely new features with nothing existing to duplicate, or for a young codebase with little established pattern to check against. Apache-2.0 licensed.
Async PR Review
Also from gemini-cli, this starts a background PR review (running preflight checks and generating an assessment without blocking the requester's workflow) and can also check the status of a review already in progress.
Who it's for: teams working through enough PRs at once that blocking on each review's completion is a real cost. Requires shell access to drive the background job. Caveat, stated directly: skip it for small projects or when immediate feedback is genuinely required, since the asynchronous design trades latency for throughput. Apache-2.0 licensed.
Copilot PR Autopilot
An awesome-copilot skill built around a specific, common frustration: GitHub Copilot leaves a pile of review comments on a PR, half of them nits, and working through fix-reply-resolve-re-request cycles by hand eats hours. This skill auto-triggers Copilot's review via GraphQL, triages every open thread with a fix/decline/escalate rubric, dispatches parallel fix subagents that respect the repo's build/test/lint conventions, commits per iteration, and replies and resolves citing the pushed commit SHA.
Who it's for: teams that already use GitHub Copilot's automated review and are drowning in the resulting comment volume. No bundled-script requirement beyond GitHub API access. Caveat: not appropriate for a PR still being designed, or when you specifically want human review rather than automated triage. MIT licensed.
PR Gardening
From paperclipai/paperclip (76,000 stars), this discovers the pull requests a Paperclip AI instance opened (never community contributions) reports what each one is for and how confident the assessment is that it's merge-ready, and drives non-ready PRs back toward green using /prepare-paperclip-pr, all without ever merging anything itself.
Who it's for: teams running a Paperclip instance that opens PRs autonomously and need a systematic way to track their readiness. Requires Node.js and shell access. Caveat: it operates strictly in read-only mode by design, so it's not suitable for managing community contributions or any workflow that requires it to actually merge. MIT licensed.
Tool Rename Deprecation
From microsoft/vscode (189,000 stars), this ensures that when a built-in tool reference gets renamed, the old name is preserved in a legacy array (legacyToolReferenceFullNames for tools, legacyFullNames for tool sets) so existing configurations, prompt files, and saved references don't silently break.
Who it's for: teams maintaining a codebase with a tool-registration system where names get referenced elsewhere, and want a review check specifically for backward compatibility on rename. No runtime requirements. Caveat: entirely unnecessary if you're not renaming tools or tool sets, or if nothing references the old names. MIT licensed. Worth reading as a pattern even outside VS Code, for any project where public identifiers get renamed.
Studio Testing Strategy
From supabase/supabase (108,000 stars), this documents Supabase Studio's testing strategy: when a change needs tests and which kind, how to extract logic from React components into testable utility functions, and criteria for choosing between unit, component, and E2E tests.
Who it's for: teams reviewing PRs against Supabase Studio's specific testing conventions, or anyone looking for a well-reasoned worked example of test-type selection criteria to adapt. No runtime requirements. Caveat: scoped to the Supabase Studio context specifically, and the skill says so directly. Apache-2.0 licensed.
Unit Test Vue Pinia
An awesome-copilot skill for writing and reviewing unit tests in Vue 3 + TypeScript + Vitest + Pinia codebases: mocking Pinia with createTestingPinia, applying Vue Test Utils patterns, and enforcing black-box assertions over implementation details as a review standard.
Who it's for: teams reviewing Vue component, composable, and store tests who want a consistent, behavior-first standard applied rather than each reviewer improvising one. No runtime requirements. Caveat: not useful for non-Vue applications, or where integration tests rather than unit tests are what's actually needed. MIT licensed.
Final Release Review
From openai/openai-agents-python (29,000 stars), this handles pre-release planning and final release-candidate review by comparing the target against the previous remote tag, determining the minimum compatible release type, auditing regressions and contract changes, checking open documentation PR coverage, drafting minor-release key changes, and calling the ship/block decision.
Who it's for: teams with a structured, tag-based release process who want a consistent audit run before every release rather than an ad hoc final check. Requires shell access to inspect git history and tags. Caveat: not suitable for projects without a structured release process, or teams that don't need detailed change auditing before shipping. MIT licensed.
How to install these skills
Every skill here installs the same way, via the skills CLI:
npx skills add github/awesome-copilot/quality-playbook --agent claude-code
npx skills add google-gemini/gemini-cli/review-duplication --agent claude-code
Swap in the exact install coordinate from each skill's page at getclaudeskills.com/skills. Code review skills are usually a project-scope decision, Review Duplication, Studio Testing Strategy and Tool Rename Deprecation all encode standards the whole team should apply consistently, so committing the skill folder into the repo is the right default rather than installing it just for yourself.
For the mechanics of scope and manual installation, see how to install skills in Claude Code and how to install skills in GitHub Copilot.
Combining review skills into one pipeline
These skills naturally split across a PR's lifecycle rather than competing for the same moment. Review Duplication and Unit Test Vue Pinia (or an equivalent test-standard skill) fit during the review itself; Copilot PR Autopilot or Async PR Review fit around triggering and triaging that review; Final Release Review fits at the very end, once a batch of PRs is ready to ship together. Installing several at once rarely causes overlap, because each targets a distinct trigger phrase and moment.
The one thing worth checking before combining them: skills like Copilot PR Autopilot commit code on your behalf as part of triaging comments. Confirm your agent's permissions and any required approvals are configured the way you want before letting a review-triage skill push commits automatically. That's a meaningfully bigger blast radius than a skill that only reads and reports.
Why isn't my skill activating?
The most common cause is a phrasing mismatch, a skill like Review Duplication triggers on "check for duplicated logic" more reliably than on a vague "review this PR." Check the skill's literal description for the terms it's watching for before assuming it's broken.
A second cause, specific to Copilot PR Autopilot and Async PR Review: both assume an existing platform integration (GitHub Copilot's review, or Gemini CLI's background job runner) that has to actually be configured and authenticated first. A skill can't create that integration for you. It can only operate once it exists.
A third cause, relevant to the VS Code- and Supabase-sourced skills here (Tool Rename Deprecation, Studio Testing Strategy): they're scoped to that project's specific conventions and won't fire usefully on an unrelated codebase's generic review request, because their descriptions are deliberately narrow.
Where to go next
The rest of the code review category, including the three skills not covered here, is at getclaudeskills.com/categories/development/code-review. For adjacent ground, see the best debugging and testing skills and the best security skills, security review and code review overlap more than the category split suggests. Browse everything at getclaudeskills.com/skills, and if your team has a review standard specific enough that nothing here fits, how to write your own agent skill covers building one, usually a short exercise for a single well-defined check.
