home / skills / anthonylee991 / gemini-superpowers-antigravity / superpowers-review

superpowers-review skill

This skill reviews code changes for correctness, edge cases, security, and maintainability, providing actionable severity-based feedback before finalizing.

npx playbooks add skill anthonylee991/gemini-superpowers-antigravity --skill superpowers-review

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1009 B

---
name: superpowers-review
description: Reviews changes for correctness, edge cases, style, security, and maintainability with severity levels (Blocker/Major/Minor/Nit). Use before finalizing changes.
---

# Review Skill

## When to use this skill
- before delivering final code changes
- after implementing a planned set of steps
- before merging or shipping

## Severity levels
- **Blocker**: wrong behavior, security issue, data loss risk, broken tests/build
- **Major**: likely bug, missing edge cases, poor reliability
- **Minor**: style, clarity, small maintainability issues
- **Nit**: optional polish

## Checklist
1. Correctness vs requirements
2. Edge cases & error handling
3. Tests (adequate coverage, meaningful assertions)
4. Security (secrets, auth, injection, unsafe defaults)
5. Performance (obvious hotspots, N+1, unnecessary work)
6. Readability & maintainability
7. Docs / comments updated if needed

## Output format
- Blockers
- Majors
- Minors
- Nits
- Overall summary + next actions

Overview

This skill reviews code changes for correctness, edge cases, style, security, and maintainability, assigning severity levels (Blocker/Major/Minor/Nit). Use it as a final gate before merging or shipping to catch regressions, security problems, and gaps in tests. It produces a prioritized list of findings and clear next actions.

How this skill works

The reviewer inspects diffs and related context against requirements and tests, checking behavior, error handling, and test coverage. It flags issues with severity levels: Blocker for safety or broken behavior, Major for likely bugs or missing edge cases, Minor for maintainability and style, and Nit for optional polish. The output lists findings grouped by severity and ends with an overall summary and recommended next steps.

When to use it

Before merging feature branches into main or release branches
After implementing a planned set of changes or refactors
Before delivering final code to QA or production
When tests or builds are flaky or failing
When security-sensitive changes are introduced

Best practices

Run tests and linters locally and include failing output with the review
Reference the relevant requirements, design doc, or issue when assessing correctness
Prioritize Blockers and Majors in the fix backlog; annotate PR with focused suggestions
Check for secrets, unsafe defaults, and dependency upgrades in every review
Require tests for new behavior and meaningful assertions for edge cases

Example use cases

Review a feature PR that touches authentication and data access for security issues
Assess a refactor that changes data flow for regressions and missing tests
Validate new API endpoints for input validation, error handling, and performance pitfalls
Check bugfix PRs to ensure they include regression tests and consider uncommon inputs
Audit dependency updates for compatibility and potential vulnerabilities

FAQ

What counts as a Blocker?

A Blocker is an issue that causes wrong behavior, data loss, security exposure, or a broken build/tests—anything that must be fixed before release.

How do you judge test coverage?

Look for tests that exercise new logic, meaningful assertions for edge cases, and that CI runs the tests reliably; request tests when behavior is unverified.