Code Reviewer Skill

Purpose

Provide comprehensive, actionable code reviews that elevate code quality, maintainability, and performance.

Activation Triggers

Automatic Activation

• •After implementing a logical chunk of code (feature, bug fix, refactoring)
• •When code changes are ready for review before committing
• •When requested explicitly ("レビューして", "review this code")

Manual Activation

• •User explicitly requests code review
• •Before creating pull requests
• •After refactoring critical modules

Core Review Areas

1. •

   Code Quality & Best Practices

   • •Language-specific idioms and conventions
   • •SOLID principles and design patterns
   • •DRY principle and code duplication elimination
   • •Proper error handling and edge case coverage
   • •Early return patterns to reduce nesting
2. •

   Type Safety & Correctness

   • •Proper type annotations and type safety
   • •Null/undefined handling
   • •Boundary conditions and off-by-one errors
   • •Logic correctness and algorithmic efficiency
3. •

   Performance & Efficiency

   • •Unnecessary allocations or copies
   • •Opportunities for parallelization (Promise.all, goroutines, etc.)
   • •Efficient data structures and algorithms
   • •Resource management (memory, connections, file handles)
4. •

   Security & Safety

   • •Input validation and sanitization
   • •SQL injection, XSS, and other common vulnerabilities
   • •Secrets and sensitive data handling
   • •Authentication and authorization checks
5. •

   Testing & Maintainability

   • •Test coverage for new code paths
   • •Edge cases and boundary value testing
   • •Clear, self-documenting code
   • •Appropriate comments for complex logic
6. •

   Project-Specific Standards

   • •Compliance with CLAUDE.md guidelines
   • •Consistency with existing codebase patterns
   • •Proper file organization (co-location, feature-based architecture)
   • •Naming conventions and code style

Review Process

Phase 1: Context Gathering

1. •

   Identify changes

   • •Use git status and git diff to see modified files
   • •Read user description or commit messages
   • •Understand the purpose of the changes
2. •

   Read project documentation

   • •Check project-specific CLAUDE.md for standards
   • •Review README.md for project context
   • •Identify related test files
3. •

   Examine the changes

   • •Read modified source files
   • •Review corresponding test files
   • •Check for related documentation updates

Phase 2: Code Analysis

1. •

   Correctness check

   • •Verify logical correctness
   • •Check for potential bugs
   • •Identify edge cases and error conditions
2. •

   Quality assessment

   • •Adherence to established patterns
   • •Code duplication
   • •Complexity and readability
   • •Performance implications
3. •

   Security review

   • •Input validation
   • •Vulnerability checks (SQL injection, XSS, etc.)
   • •Secrets handling

Phase 3: Test Verification

1. •

   Coverage check

   • •Verify tests exist for new functionality
   • •Check edge cases and boundary conditions
   • •Ensure tests are co-located with code
2. •

   Test quality

   • •Test assertions match implementation
   • •Test descriptions are clear
   • •No false positives/negatives
3. •

   Run diagnostics

   • •Use mcp__ide__getDiagnostics for linting errors
   • •Check for type errors
   • •Verify build success

Phase 4: Provide Feedback

Structure review using templates/review-report.md format:

1. •

   Critical Issues (must fix)

   • •Bugs, security vulnerabilities, breaking changes
   • •Provide file location and suggested fix
2. •

   Important Suggestions (should address)

   • •Performance issues, maintainability problems
   • •Explain reasoning and benefits
3. •

   Minor Improvements (nice to have)

   • •Style improvements, documentation
   • •Low-priority optimizations
4. •

   Positive Highlights

   • •What was done well
   • •Good practices observed
5. •

   Next Steps

   • •Recommended actions before commit
   • •Priority order for fixes

Decision-Making Framework

• •Prioritize correctness over cleverness: Simple, readable code is better
• •Consider project context: CLAUDE.md standards override general best practices
• •Be specific and actionable: Provide concrete examples and code snippets
• •Balance pragmatism with idealism: Not everything needs immediate implementation
• •Verify before criticizing: Check if tests validate unusual approaches

Quality Control

• •Run linters and tests to verify observations
• •Check test coverage for critical paths
• •Verify assumptions with evidence
• •Consider false positives (if tests pass, investigate why)

Escalation Strategy

If encountering:

• •Insufficient context: Ask user for clarification
• •Complex architectural decisions: Highlight trade-offs, recommend discussion
• •Potential breaking changes: Call out impact, suggest migration strategies
• •Missing critical tests: Strongly recommend adding tests first

Integration with Other Skills

• •refactoring-assistant: Suggest when code smells are detected
• •test-executor: Recommend running tests after fixes
• •doc-maintainer: Flag missing or outdated documentation

Usage Tips

For User

• •Request review after logical chunks, not after every line
• •Provide context about the purpose of changes
• •Specify if particular areas need focus

For Claude

• •Be direct and specific about issues
• •Provide constructive, actionable feedback
• •Reference specific standards from CLAUDE.md
• •Include file paths and line numbers
• •Balance criticism with positive feedback

Supporting Files

• •templates/review-report.md: Structured template for review output

Maintenance

Update this Skill when:

• •New review criteria are established
• •Project-specific standards change
• •New security vulnerabilities are discovered
• •Team feedback suggests improvements