Code review
Review code changes using a two-stage process (spec compliance + code quality) with multi-facet analysis and confidence scoring. Use after completing features, before merging, or when stuck.From its SKILL.md
npx -y skills add anderson-0/mighty-powers --skill code-reviewAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 4 stars4 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
4.2 KB, as published. Nobody here has run it
Code Review
Dispatch a code-reviewer subagent to catch issues before they cascade. The reviewer gets precisely crafted context for evaluation — never your session's history.
Core principle: Review early, review often.
When to Request Review
Mandatory:
- After each task in subagent-driven development
- After completing a major feature
- Before merge to main
- At the end of each sprint phase (BUILD → TEST transition)
Optional but valuable:
- When stuck (fresh perspective)
- Before refactoring (baseline check)
- After fixing a complex bug
How to Dispatch
1. Gather context:
BASE_SHA=$(git merge-base HEAD main) # or origin/main
HEAD_SHA=$(git rev-parse HEAD)
DIFF=$(git diff $BASE_SHA..$HEAD_SHA)
2. Dispatch code-reviewer via Agent tool:
Agent tool:
description: "Code review"
model: sonnet (or opus for architecture-heavy changes)
prompt: |
[Include full content of agents/code-reviewer.md]
## Your Task
Review the changes between {BASE_SHA} and {HEAD_SHA}.
The implementation plan is at: {PLAN_PATH}
What was implemented: {DESCRIPTION}
Focus areas: {FOCUS_AREAS — e.g., "new auth middleware, touches 5 files"}
Run `git diff {BASE_SHA}..{HEAD_SHA}` to see the changes.
Read the plan file for spec compliance checking.
3. Read the agent's response and present findings to the user organized by severity.
For parallel review (e.g., at sprint REVIEW gate), dispatch code-reviewer + security-auditor in a single response:
Single message with 2 Agent tool calls:
Agent 1: code-reviewer — reviews code quality and spec compliance
Agent 2: security-auditor — scans for security issues
Both run concurrently. Combine findings when both complete.
Two-Stage Review Process
Stage 1: Spec Compliance
Does the implementation match the plan/requirements?
- Compare implementation against planning document
- Identify deviations — are they justified improvements or problematic departures?
- Verify all planned functionality is implemented
- Check acceptance criteria are met
Stage 2: Code Quality
Is the code clean, tested, and maintainable?
Review across these dimensions:
| Dimension | What to Check |
|---|---|
| Architecture | SOLID principles, separation of concerns, integration with existing systems |
| Security | Input validation, auth checks, injection risks, secrets exposure |
| Performance | N+1 queries, unnecessary allocations, blocking operations |
| Testing | Coverage of new code, test quality, edge cases tested |
| Documentation | Comments where logic isn't self-evident, updated docs |
Confidence Scoring
Every finding gets a confidence score (0-100):
- 90-100: Certain — clear violation or bug
- 70-89: Likely — strong evidence but some ambiguity
- 50-69: Possible — worth investigating
- Below 50: Speculative — don't report
Only present findings with confidence ≥ 80 to reduce noise. Group findings below 80 into a "lower-confidence" appendix if needed.
Finding Severity
Categorize each finding:
- Critical: Must fix before merge — bugs, security vulnerabilities, data loss risks
- Important: Should fix before merge — design issues, missing error handling, test gaps
- Suggestion: Nice to have — style improvements, minor optimizations
Acting on Feedback
- Fix Critical issues immediately
- Fix Important issues before proceeding
- Note Suggestions for later
- Push back if reviewer is wrong (with reasoning)
Integration with Workflows
Subagent-Driven Development: Review after EACH task. Catch issues before they compound.
Executing Plans: Review after each batch (3-5 tasks). Get feedback, apply, continue.
Sprint Pipeline: Review at the REVIEW phase gate. Must pass before SHIP.
Red Flags
Never:
- Skip review because "it's simple"
- Ignore Critical issues
- Proceed with unfixed Important issues
- Argue with valid technical feedback without evidence