Perform comprehensive code reviews by orchestrating sub-agents to analyze code from multiple perspectives.
Install
mkdir -p .claude/skills/deep-review && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/4246" && unzip -o skill.zip -d .claude/skills/deep-review && rm skill.zipInstalls to .claude/skills/deep-review
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Sub-agent powered code reviews spanning correctness, tests, consistency, and fitKey capabilities
- →Spawn 2-5 specialized sub-agents for parallel analysis
- →Evaluate code correctness, test coverage, and architectural consistency
- →Assess UX, accessibility, and performance impacts
- →Categorize findings by severity levels P0 through P4
- →Generate a validation plan with specific commands
How it works
The skill identifies the scope of changes and spawns multiple sub-agents to analyze the code from different perspectives before synthesizing their findings into a single report.
Inputs & outputs
When to use deep-review
- →Review code logic
- →Check test coverage
- →Audit architectural consistency
About this skill
Deep Review Mode
Provide an excellent code review by defaulting to parallelism.
You should use sub-agents to review the change from multiple angles (correctness, tests, consistency, UX, performance, safety). Each sub-agent should have a focused mandate and return actionable findings with file paths.
Step 0: Establish the review surface
Before reviewing, gather context:
- Identify the change scope:
git diff --name-only(or the file list the user provides). - Skim the diff for intent and risk:
git diff. - Note which layers are touched:
- UI (React/components/styles)
- Main process / backend services
- IPC boundary / shared types
- Tooling/scripts
- Docs
- Tests
If the change is large, split review by module and prioritize high-risk paths.
Spawn the right sub-agents (change-type aware)
Spawn 2–5 sub-agents depending on scope. Tailor them to the change.
Suggested sub-agent set
- Correctness & edge cases (always)
- Goal: find logic bugs, missing error handling, race conditions, broken invariants.
- Tests & verification (always)
- Goal: evaluate test coverage, propose missing tests, suggest commands to validate.
- Consistency & architecture (usually)
- Goal: ensure changes match existing patterns, abstractions, and boundaries.
- UX & accessibility (when UI changed)
- Goal: keyboard flows, a11y, visual consistency, empty/loading/error states.
- Performance & reliability (when hot paths / streaming / IO changed)
- Goal: latency, unnecessary work, blocking calls, memory growth, resilience.
- Docs & developer experience (when docs/scripts/public API changed)
- Goal: clarity, correctness, navigation updates, link integrity.
Synthesize into a single excellent review
When sub-agent results arrive, produce a consolidated review with:
- Summary (what changed + overall risk)
- Issues
- Questions (unknown intent; ask for clarification)
- Suggested validation plan (commands + manual checks)
Issues should have a severity in form of:
| Severity | Description | Example |
|---|---|---|
| P0 | Change must not be merged until resolved | Change would permanently break core workflows if merged. |
| P1 | Change should not be merged | New code will not work as expected due to severe bugs |
| P2 | Consideration required before merging | The change creates inconsistency / fragility |
| P3 | Minor issue | The change introduces a minor issue that may be addressed later |
| P4 | Long-term issue | The change raises concerns about long-term maintainability or may break under rare conditions |
Review rubric
Use this rubric to avoid blind spots:
- Correctness: invariants, edge cases, error handling, races
- Fitness: does it meet the user goal, and does it match product constraints?
- Tests: coverage of new logic, regression tests, deterministic behavior
- Consistency: patterns, naming, types, boundaries, IPC typing
- Maintainability: complexity, duplication, readability
- Performance: hot paths, streaming, excessive re-renders/IO
- Safety: secrets, path traversal, injection risks, filesystem safety
- DX: logs, error messages, debuggability
Clean up delegated review work
After consolidating the findings, remember that completed review sub-agents remain as inactive child workspaces. Keep any child that still needs follow-up; otherwise remove completed review children in one deepest-first task_remove batch. Use task_stop only for review work that is still active but no longer needed.
Anti-patterns
- Single-threaded review of a large change (spawn sub-agents).
- Vague feedback (“looks good”) without actionable items and file paths.
- Non-verifiable suggestions (always include a validation plan).
- Scope creep disguised as review (focus on minimal changes unless risk demands more).
When not to use it
- →For trivial, single-line changes where parallel analysis is unnecessary
- →When the user requires a single-threaded review
Limitations
- →Requires clear file scope to effectively spawn sub-agents
- →Feedback must be actionable with file paths to be valid
How it compares
It replaces single-threaded manual reviews with a parallelized, multi-perspective analysis that ensures coverage of logic, tests, and architecture.
Compared to similar skills
deep-review side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| deep-review (this skill) | 1 | 6mo | No flags | Advanced |
| effective-go | 323 | 9mo | No flags | Beginner |
| architect-review | 109 | 4mo | No flags | Advanced |
| resolve-conflicts | 81 | 8mo | Review | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by coder
View all by coder →You might also like
effective-go
openshift
Apply Go best practices, idioms, and conventions from golang.org/doc/effective_go. Use when writing, reviewing, or refactoring Go code to ensure idiomatic, clean, and efficient implementations.
architect-review
sickn33
Master software architect specializing in modern architecture patterns, clean architecture, microservices, event-driven systems, and DDD. Reviews system designs and code changes for architectural integrity, scalability, and maintainability. Use PROACTIVELY for architectural decisions.
resolve-conflicts
antinomyhq
Use this skill immediately when the user mentions merge conflicts that need to be resolved. Do not attempt to resolve conflicts directly - invoke this skill first. This skill specializes in providing a structured framework for merging imports, tests, lock files (regeneration), configuration files, and handling deleted-but-modified files with backup and analysis.
solid-principles
SmidigStorm
Enforce SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) in object-oriented design. Use when writing or reviewing classes and modules.
python-testing-patterns
wshobson
Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites, or implementing testing best practices.
codex
Lucklyric
Invoke Codex CLI for complex coding tasks requiring high reasoning capabilities. This skill should be invoked when users explicitly mention "Codex", request complex implementation challenges, advanced reasoning, or need high-reasoning model assistance. Automatically triggers on codex-related requests and supports session continuation for iterative development.