quick-review
Performs a fast, focused code review checking for common issues, security vulnerabilities, and best practices without over-engineering. Optimized for cost-efficiency by targeting specific concerns rather than broad exploration.
When & Why to Use This Skill
This Claude skill provides a high-speed, cost-effective automated code review process designed to identify critical security vulnerabilities, performance bottlenecks, and common programming errors. By focusing strictly on changed files and actionable issues rather than broad architectural over-engineering, it ensures developers receive immediate, high-impact feedback that improves code quality while minimizing token usage and operational costs.
Use Cases
- Pre-commit sanity checks: Quickly verify local changes before pushing to a repository to catch obvious bugs and logic errors early.
- Automated security auditing: Detect high-risk vulnerabilities such as SQL injection, XSS, and hardcoded credentials within new pull requests.
- Performance optimization: Identify inefficient O(n²) loops, N+1 query patterns, or unnecessary re-renders in database and UI-heavy code.
- Resource leak prevention: Scan for unhandled exceptions, unclosed file connections, or memory leaks in newly implemented features.
- Code quality enforcement: Maintain project standards by flagging excessive function complexity and duplicated logic in recent updates.
| name | quick-review |
|---|---|
| description | Performs a fast, focused code review checking for common issues, security vulnerabilities, and best practices without over-engineering. Optimized for cost-efficiency by targeting specific concerns rather than broad exploration. |
Quick Review
Perform a targeted code review focusing on critical issues without unnecessary elaboration or over-engineering suggestions.
Review Checklist
Security & Safety
- SQL injection vulnerabilities
- XSS vulnerabilities
- Command injection risks
- Hardcoded secrets or credentials
- Unsafe file operations
- Authentication/authorization bypass risks
Common Issues
- Unhandled errors or exceptions
- Resource leaks (files, connections, memory)
- Race conditions or concurrency bugs
- Off-by-one errors
- Null/undefined reference risks
- Type mismatches or coercion issues
Code Quality
- Functions that are too complex (>50 lines)
- Duplicated code blocks
- Misleading variable/function names
- Commented-out code that should be removed
- Console.log or debug statements left in
Performance Red Flags
- N+1 query problems
- Inefficient loops (O(n²) or worse when avoidable)
- Unnecessary re-renders or recalculations
- Missing database indexes for queries
- Large objects in state/props
Guidelines
- Be concise: Report only actual issues found, not theoretical improvements
- Prioritize: Focus on bugs and security issues over style preferences
- No over-engineering: Don't suggest adding abstractions, patterns, or features unless there's a concrete problem
- No unsolicited improvements: Only review what was changed, not surrounding code
- Cost-conscious: Read only the files that changed, not the entire codebase
- Specific: Reference exact line numbers when reporting issues
Output Format
## Issues Found: [N]
### Critical (must fix)
- file.ts:45 - [specific issue with explanation]
### Warnings (should fix)
- file.ts:78 - [specific issue with explanation]
### Notes (optional)
- [minor observations if relevant]
If no issues found: "✓ No critical issues detected in review."
Examples
Good usage:
- Review changes before committing
- Quick sanity check on a new feature
- Verify a bug fix doesn't introduce new issues
Avoid:
- Reviewing entire codebases (use targeted file paths)
- Style/formatting nitpicks (use linters instead)
- Architectural reviews (use separate planning tools)