Code Review Skill

When to Use This Skill

Use this skill when:

• The user requests a code review or asks to review code
• A pull request needs to be examined
• Code quality, security, or performance analysis is needed
• The user mentions terms like "review", "check my code", "code quality", or "find bugs"

Review Process

Follow this systematic approach for code reviews:

1. Initial Assessment

• Read through the entire code change to understand the intent
• Identify the type of change (bug fix, feature, refactor, etc.)
• Note the programming language and framework being used

2. Functionality Review

• Verify the code does what it's supposed to do
• Check for logical errors or edge cases
• Ensure error handling is appropriate
• Validate input/output handling

3. Security Analysis

Use the security checklist in references/CHECKLIST.md:

• SQL injection vulnerabilities
• XSS (Cross-Site Scripting) risks
• Authentication and authorization issues
• Sensitive data exposure
• Insecure dependencies
• Command injection risks

4. Performance Review

• Identify potential bottlenecks
• Check for inefficient algorithms (O(n²) where O(n) is possible)
• Look for unnecessary database queries or API calls
• Review memory usage patterns
• Check for resource leaks

5. Code Quality

• Readability: Is the code easy to understand?
• Maintainability: Can it be easily modified?
• DRY principle: Avoid code duplication
• SOLID principles adherence
• Appropriate use of design patterns
• Proper naming conventions

6. Testing

• Are there adequate unit tests?
• Do tests cover edge cases?
• Are integration tests needed?
• Is test coverage sufficient?

Output Format

Structure your review using the template in assets/review-template.md:

Summary

Brief overview of the changes and overall assessment.

Critical Issues 🔴

Issues that must be fixed (security vulnerabilities, breaking bugs).

Important Issues 🟡

Significant concerns (performance problems, poor error handling).

Suggestions 🟢

Nice-to-have improvements (refactoring opportunities, better naming).

Positive Notes ✅

Call out well-written code and good practices.

Common Patterns to Check

Anti-patterns

• God classes (classes doing too much)
• Magic numbers (unexplained constants)
• Deep nesting (more than 3 levels)
• Long functions (more than 50 lines)
• Catch and ignore exceptions
• Hard-coded credentials or secrets

Best Practices

• Single Responsibility Principle
• Meaningful variable names
• Consistent formatting
• Appropriate comments
• Proper error messages
• Logging important events

Language-Specific Considerations

Python

• PEP 8 compliance
• Type hints usage
• Context managers for resources
• List comprehensions vs loops
• Async/await usage

JavaScript/TypeScript

• Const/let over var
• Async/await over callbacks
• Type safety (TypeScript)
• Proper promise handling
• Memory leak prevention

Java

• Exception handling patterns
• Resource management (try-with-resources)
• Thread safety
• Collection usage
• Null safety

Example Review

For code like this:

def process_users(users):
    result = []
    for user in users:
        if user['active']:
            result.append(user['name'].upper())
    return result

Review output: 🟡 Suggestions:

• Use list comprehension for better readability and performance
• Add type hints for better code documentation
• Consider KeyError handling if 'active' or 'name' might be missing

Improved version:

from typing import List, Dict, Any

def process_users(users: List[Dict[str, Any]]) -> List[str]:
    """Extract and uppercase names of active users."""
    return [
        user['name'].upper() 
        for user in users 
        if user.get('active', False)
    ]

Tips for Effective Reviews

1. Be constructive: Frame feedback positively
2. Be specific: Point to exact lines and explain why
3. Prioritize: Distinguish between critical issues and suggestions
4. Educate: Explain the reasoning behind recommendations
5. Acknowledge good work: Highlight excellent code
6. Be consistent: Apply the same standards throughout

When to Request Human Review

Some situations require human judgment:

• Major architectural decisions
• Trade-offs between conflicting requirements
• Business logic validation
• Regulatory compliance questions
• Significant performance optimizations