Skill

devs:code-review

Comprehensive code review guidance for quality, performance, and architecture across all programming languages. Use when (1) User explicitly requests code review, (2) After writing significant code changes, (3) Before commits/PRs, (4) Reviewing existing codebases, (5) Analyzing code quality, (6) Detecting performance issues, (7) Identifying architectural problems, (8) Finding code smells. Provides automated analysis scripts and manual review checklists for thorough code evaluation.

From devs

Install

Run in your terminal

npx claudepluginhub aaronbassett/agent-foundry --plugin devs

Tool Access

This skill uses the workspace's default tool permissions.

Supporting Assets

View in Repository

references/code-smells.md

references/review-checklist.md

scripts/analyze_complexity.py

scripts/detect_code_smells.py

scripts/generate_review_report.py

scripts/review_code.sh

Skill Content

Similar Skills

skill-lookup

Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.

prompts.chat

157.6k

prompt-lookup

Searches prompts.chat for AI prompt templates by keyword or category, retrieves by ID with variable handling, and improves prompts via AI. Use for discovering or enhancing prompts.

prompts.chat

157.6k

agent-introspection-debugging

Implements structured self-debugging workflow for AI agent failures: capture errors, diagnose patterns like loops or context overflow, apply contained recoveries, and generate introspection reports.

ecc

147.3k

Stats

Parent Repo Stars3

Parent Repo Forks0

Last CommitFeb 5, 2026

Actions

View Source View Plugin View on GitHub View README

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

Run automated review
Check for high-severity issues
Review manual checklist
Ensure tests pass
Commit if approved

Workflow 4: Legacy Code Analysis

Run full review to understand codebase
Identify problematic areas
Prioritize refactoring
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

Review Early - Don't wait until code is "complete"
Focus on Impact - High-severity issues first
Be Constructive - Suggest improvements, not just problems
Consider Context - Performance vs. readability tradeoffs
Automate - Use tools before manual review
Test Changes - Ensure refactoring doesn't break functionality
Document Decisions - Explain WHY, not just WHAT
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:

Address high-severity issues
Refactor complex functions
Remove code smells
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.