Code Review

Comprehensive code review for quality, performance, and architecture across all languages.

Quick Start

Automated Review

Run complete analysis:

./scripts/review_code.sh /path/to/code

This runs:

• •Language-specific linters (ESLint, Pylint, Clippy)
• •Complexity analysis
• •Code smell detection
• •Report generation

Manual Review

Use comprehensive checklist:

• •See review-checklist.md for complete checklist

Individual Analyzers

Complexity analysis:

./scripts/analyze_complexity.py /path/to/code

Code smells:

./scripts/detect_code_smells.py /path/to/code

When to Use

Trigger this skill when:

• •User says "review this code" or similar
• •After significant code implementation
• •Before committing/creating PRs
• •Analyzing unfamiliar codebases
• •Investigating quality issues
• •Optimizing performance
• •Refactoring

What This Skill Provides

Automated Analysis Scripts

review_code.sh - Complete review orchestrator

• •Detects project type (JS/TS/Python/Rust)
• •Runs appropriate linters
• •Analyzes complexity
• •Detects code smells
• •Generates comprehensive report

analyze_complexity.py - Complexity metrics

• •Cyclomatic complexity
• •Function length
• •Nesting depth
• •Identifies problematic functions

detect_code_smells.py - Code smell detection

• •Long parameter lists
• •Magic numbers
• •Duplicated code
• •Deep nesting
• •God classes

generate_review_report.py - Report generation

• •Aggregates all findings
• •Prioritizes issues
• •Provides recommendations

Manual Review Guidance

review-checklist.md - Complete review checklist

• •Code quality checks
• •Performance considerations
• •Architecture review
• •Security checklist
• •Testing coverage

code-smells.md - Code smell catalog

• •Common smells by category
• •Detection strategies
• •Refactoring solutions

Review Focus Areas

1. Code Quality

• •Naming and readability
• •DRY (Don't Repeat Yourself)
• •YAGNI (You Aren't Gonna Need It)
• •Consistent style
• •Proper comments

2. Performance

• •Algorithmic complexity
• •Unnecessary loops/nesting
• •Database query optimization
• •Memory management
• •Caching opportunities

3. Architecture

• •Modularity and organization
• •SOLID principles
• •Coupling and cohesion
• •Dependency management
• •Design patterns

4. Code Smells

• •Bloaters (long methods, large classes)
• •Object-orientation abusers
• •Change preventers
• •Dispensables (dead code, duplication)
• •Couplers (tight coupling)

Common Workflows

Workflow 1: Complete Project Review

# Run automated analysis
./scripts/review_code.sh /path/to/project

# Review output
cat .code-review-output/REVIEW.md

# Manual checklist review
# Consult references/review-checklist.md

# Address findings
# Refactor based on recommendations

Workflow 2: Quick Complexity Check

# Analyze complexity
./scripts/analyze_complexity.py /path/to/code

# Identify complex functions
# Refactor functions with complexity >10

Workflow 3: Pre-Commit Review

1. •Run automated review
2. •Check for high-severity issues
3. •Review manual checklist
4. •Ensure tests pass
5. •Commit if approved

Workflow 4: Legacy Code Analysis

1. •Run full review to understand codebase
2. •Identify problematic areas
3. •Prioritize refactoring
4. •Address incrementally

Understanding Results

Complexity Metrics

Cyclomatic Complexity:

• •1-5: Simple, easy to test
• •6-10: Moderate complexity
• •11-20: High complexity, consider refactoring
• •21+: Very high, definitely refactor

Function Length:

• •≤20 lines: Excellent
• •21-50 lines: Good
• •51-100 lines: Consider splitting
• •100+ lines: Refactor

Nesting Depth:

• •1-2 levels: Good
• •3-4 levels: Acceptable
• •5+ levels: Refactor

Code Smell Severity

High - Address immediately:

• •God classes
• •Duplicated critical logic
• •Deep nesting in hot paths

Medium - Address soon:

• •Long parameter lists
• •Feature envy
• •Duplicated code

Low - Address when convenient:

• •Magic numbers
• •Minor duplication
• •Speculative generality

Language Support

Detected Automatically

JavaScript/TypeScript:

• •ESLint integration
• •TypeScript compiler checks
• •Complexity analysis
• •Code smell detection

Python:

• •Pylint integration
• •Flake8 support
• •MyPy type checking
• •Complexity analysis

Rust:

• •Clippy integration
• •Cargo check
• •Basic complexity analysis

Additional Languages

For languages not automatically detected:

• •Manual checklist still applies
• •Use language-specific linters
• •Complexity principles are universal

Best Practices

1. •Review Early - Don't wait until code is "complete"
2. •Focus on Impact - High-severity issues first
3. •Be Constructive - Suggest improvements, not just problems
4. •Consider Context - Performance vs. readability tradeoffs
5. •Automate - Use tools before manual review
6. •Test Changes - Ensure refactoring doesn't break functionality
7. •Document Decisions - Explain WHY, not just WHAT
8. •Iterate - Re-review after changes

Integration

CI/CD Integration

Add to GitHub Actions:

- name: Code Review
  run: |
    ./scripts/review_code.sh .
    # Fail if high-severity issues found

Pre-commit Hook

#!/bin/bash
./scripts/review_code.sh . --quick

Editor Integration

Most linters integrate with VS Code, IntelliJ, etc.

Limitations

• •Static Analysis Only - Doesn't catch runtime issues
• •Heuristic-Based - Some false positives possible
• •Language Coverage - Best for JS/TS/Python/Rust
• •No Business Logic - Can't evaluate correctness
• •Context Unaware - Doesn't understand project-specific conventions

Getting Help

For specific issues:

• •Complexity problems → See complexity thresholds above
• •Code smells → See code-smells.md
• •General quality → See review-checklist.md

After review:

1. •Address high-severity issues
2. •Refactor complex functions
3. •Remove code smells
4. •Re-run review to verify

Example Output

# Code Review Report

## Executive Summary
- Total Functions Analyzed: 127
- Code Smells Detected: 23
  - High Severity: 3
  - Medium Severity: 15
  - Low Severity: 5

## Complexity Analysis
- Average Complexity: 4.2
- Maximum Complexity: 18
- Functions Needing Attention: 8

## Recommendations
- Refactor 3 highly complex functions
- Address 3 high-severity code smells
- Extract duplicated code in 5 locations

Note: This skill provides guidance and automated checks. Final decisions on code quality depend on project context, team conventions, and business requirements.