code-review-expert
sanyuan0704/sanyuan-skills
Expert code review of git changes detecting SOLID violations, security risks, and proposing actionable improvements.
What is code-review-expert?
Perform structured review of current git changes with a senior engineer lens, focusing on SOLID principles, architecture, security risks, and code quality. Use this when you need comprehensive feedback on recent commits before merging, with severity-based findings and optional implementation of fixes.
- Analyzes git diffs for SOLID violations (SRP, OCP, LSP, ISP, DIP) and architecture smells
- Scans for security vulnerabilities including injection, XSS, auth gaps, race conditions, and crypto issues
- Identifies removal candidates and proposes incremental deletion plans with checkpoints
- Checks error handling, performance bottlenecks (N+1 queries, unbounded loops), and boundary conditions
- Categorizes findings by severity (P0 Critical, P1 High, P2 Medium, P3 Low) with actionable fixes
- Provides inline code comments and structured review output before implementing any changes
How to install code-review-expert
npx skills add https://github.com/sanyuan0704/sanyuan-skills --skill code-review-expertHow to use code-review-expert
- 1.Run the skill to analyze current git changes (staged or committed)
- 2.Review the structured findings organized by severity level (P0–P3)
- 3.For each finding, read the description and suggested fix
- 4.Decide how to proceed: fix all issues, fix critical/high only, fix specific items, or skip implementation
- 5.If implementing fixes, confirm your choice and the skill will apply changes; otherwise review is complete
Use cases
- Review pull requests before merge to catch security and design issues early
- Audit refactoring changes to ensure SOLID principles and maintainability improvements
- Identify dead code and technical debt candidates with safe deletion plans
- Validate critical paths (auth, payments, data writes) for correctness and security
- Perform pre-deployment code quality checks on recent commits
- Senior engineers and code reviewers
- Development teams practicing code review discipline
- Projects with security or compliance requirements
- Teams adopting or enforcing SOLID design principles
- Developers preparing changes for merge or production deployment
code-review-expert FAQ
The skill will inform you and ask if you want to review staged changes, a specific commit range, or a different branch.
For diffs over 500 lines, it summarizes by file first, then reviews in batches grouped by logical feature or module rather than file order.
No. It defaults to review-only output and explicitly asks for user confirmation before implementing any changes. You control whether fixes are applied.
XSS, injection (SQL/NoSQL/command), SSRF, path traversal, auth gaps, secret leakage, rate limits, race conditions, unsafe deserialization, weak crypto, and insecure defaults.
Yes. It identifies unused, redundant, or feature-flagged code and distinguishes between safe immediate deletion and deferred removal with a follow-up plan including tests and metrics.
Full instructions (SKILL.md)
Source of truth, from sanyuan0704/sanyuan-skills.
name: code-review-expert description: "Expert code review of current git changes with a senior engineer lens. Detects SOLID violations, security risks, and proposes actionable improvements."
Code Review Expert
Overview
Perform a structured review of the current git changes with focus on SOLID, architecture, removal candidates, and security risks. Default to review-only output unless the user asks to implement changes.
Severity Levels
| Level | Name | Description | Action |
|---|---|---|---|
| P0 | Critical | Security vulnerability, data loss risk, correctness bug | Must block merge |
| P1 | High | Logic error, significant SOLID violation, performance regression | Should fix before merge |
| P2 | Medium | Code smell, maintainability concern, minor SOLID violation | Fix in this PR or create follow-up |
| P3 | Low | Style, naming, minor suggestion | Optional improvement |
Workflow
1) Preflight context
- Use
git status -sb,git diff --stat, andgit diffto scope changes. - If needed, use
rgorgrepto find related modules, usages, and contracts. - Identify entry points, ownership boundaries, and critical paths (auth, payments, data writes, network).
Edge cases:
- No changes: If
git diffis empty, inform user and ask if they want to review staged changes or a specific commit range. - Large diff (>500 lines): Summarize by file first, then review in batches by module/feature area.
- Mixed concerns: Group findings by logical feature, not just file order.
2) SOLID + architecture smells
- Load
references/solid-checklist.mdfor specific prompts. - Look for:
- SRP: Overloaded modules with unrelated responsibilities.
- OCP: Frequent edits to add behavior instead of extension points.
- LSP: Subclasses that break expectations or require type checks.
- ISP: Wide interfaces with unused methods.
- DIP: High-level logic tied to low-level implementations.
- When you propose a refactor, explain why it improves cohesion/coupling and outline a minimal, safe split.
- If refactor is non-trivial, propose an incremental plan instead of a large rewrite.
3) Removal candidates + iteration plan
- Load
references/removal-plan.mdfor template. - Identify code that is unused, redundant, or feature-flagged off.
- Distinguish safe delete now vs defer with plan.
- Provide a follow-up plan with concrete steps and checkpoints (tests/metrics).
4) Security and reliability scan
- Load
references/security-checklist.mdfor coverage. - Check for:
- XSS, injection (SQL/NoSQL/command), SSRF, path traversal
- AuthZ/AuthN gaps, missing tenancy checks
- Secret leakage or API keys in logs/env/files
- Rate limits, unbounded loops, CPU/memory hotspots
- Unsafe deserialization, weak crypto, insecure defaults
- Race conditions: concurrent access, check-then-act, TOCTOU, missing locks
- Call out both exploitability and impact.
5) Code quality scan
- Load
references/code-quality-checklist.mdfor coverage. - Check for:
- Error handling: swallowed exceptions, overly broad catch, missing error handling, async errors
- Performance: N+1 queries, CPU-intensive ops in hot paths, missing cache, unbounded memory
- Boundary conditions: null/undefined handling, empty collections, numeric boundaries, off-by-one
- Flag issues that may cause silent failures or production incidents.
6) Output format
Structure your review as follows:
## Code Review Summary
**Files reviewed**: X files, Y lines changed
**Overall assessment**: [APPROVE / REQUEST_CHANGES / COMMENT]
---
## Findings
### P0 - Critical
(none or list)
### P1 - High
1. **[file:line]** Brief title
- Description of issue
- Suggested fix
### P2 - Medium
2. (continue numbering across sections)
- ...
### P3 - Low
...
---
## Removal/Iteration Plan
(if applicable)
## Additional Suggestions
(optional improvements, not blocking)
Inline comments: Use this format for file-specific findings:
::code-comment{file="path/to/file.ts" line="42" severity="P1"}
Description of the issue and suggested fix.
::
Clean review: If no issues found, explicitly state:
- What was checked
- Any areas not covered (e.g., "Did not verify database migrations")
- Residual risks or recommended follow-up tests
7) Next steps confirmation
After presenting findings, ask user how to proceed:
---
## Next Steps
I found X issues (P0: _, P1: _, P2: _, P3: _).
**How would you like to proceed?**
1. **Fix all** - I'll implement all suggested fixes
2. **Fix P0/P1 only** - Address critical and high priority issues
3. **Fix specific items** - Tell me which issues to fix
4. **No changes** - Review complete, no implementation needed
Please choose an option or provide specific instructions.
Important: Do NOT implement any changes until user explicitly confirms. This is a review-first workflow.
Resources
references/
| File | Purpose |
|---|---|
solid-checklist.md | SOLID smell prompts and refactor heuristics |
security-checklist.md | Web/app security and runtime risk checklist |
code-quality-checklist.md | Error handling, performance, boundary conditions |
removal-plan.md | Template for deletion candidates and follow-up plan |
Related skills
More from sanyuan0704/sanyuan-skills and the wider catalog.

sigma
Personalized 1-on-1 AI tutor using Bloom's 2-Sigma mastery learning with Socratic questioning and adaptive pacing.

skill-forge
Create production-grade skills for Claude Code with expert guidance on architecture, workflow design, and packaging.

skill-review
Quality review and audit for Claude Code skills. Analyzes skill structure, description quality, workflow design, token efficiency, and anti-patterns against best practices. Use when user wants to review a skill, audit a skill, check skill quality, evaluate a skill, critique a skill, lint a skill, or validate a skill. Triggers: 'review skill', 'audit skill', 'skill quality', 'check my skill', 'evaluate skill', 'skill lint', 'validate skill', 'skill review', 'is this skill good', 'improve this skill'.

wiki-ingest
Compile articles, documents, or notes into a structured wiki knowledge base. Use when user says 'ingest to wiki', 'compile to knowledge base', 'update wiki', 'wiki ingest', 'add this to wiki', or invokes /wiki-ingest. Supports single or batch ingest. Triggers: wiki, ingest, knowledge base, compile, digest, index, catalog.

dev-browser
Browser automation with persistent page state for navigation, form filling, screenshots, and web data extraction.

excel-cli
Agent skill from sbroenne/mcp-server-excel.