quality-complexity-check

Analyze code complexity metrics including cyclomatic complexity and nesting depth. Use to identify code that needs refactoring.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

This Claude skill automates code quality assessments by analyzing critical metrics such as cyclomatic complexity, nesting depth, and function length. It empowers developers to proactively identify technical debt, streamline refactoring efforts, and ensure long-term codebase maintainability through data-driven insights.

Use Cases

  • Automated Code Reviews: Integrate complexity checks into the PR process to automatically flag overly complex logic or deep nesting before merging.
  • Technical Debt Identification: Scan legacy codebases to pinpoint high-risk functions that exceed complexity thresholds and require immediate refactoring.
  • Pre-release Quality Gates: Use as a final audit tool before major releases to ensure code meets project standards for readability and maintainability.
  • Developer Self-Correction: Provide real-time feedback to engineers, helping them flatten nested structures and implement cleaner coding patterns like early returns.
namequality-complexity-check
descriptionAnalyze code complexity metrics including cyclomatic complexity and nesting depth. Use to identify code that needs refactoring.
mcp_fallbacknone
categoryquality

Complexity Check Skill

Analyze and report code complexity metrics.

When to Use

  • Code review process
  • Identifying refactoring candidates
  • Maintaining code quality
  • Before major releases

Quick Reference

# Analyze Python code
./scripts/check_complexity.py

# Generate full report
./scripts/complexity_report.sh > complexity.txt

# Check Mojo code
./scripts/check_mojo_complexity.sh

Complexity Metrics

Cyclomatic Complexity (CC)

Measures decision points (if, for, while):

CC Range Assessment Action
1-10 Simple Keep as is
11-20 Moderate Consider refactoring
21+ Complex Needs refactoring

Nesting Depth

Maximum levels of nesting in function:

Depth Assessment Action
1-3 Good Keep as is
4-5 High Consider flattening
6+ Very High Refactor required

Function Length

Lines of code in function:

LOC Assessment Action
1-20 Good Keep as is
21-50 Acceptable Monitor
51+ Too long Consider splitting

Refactoring Patterns

Extract Function (High CC)

# Before (CC: 15)
def process(data):
    if condition1:
        if condition2:
            if condition3:
                for item in data:
                    if item.valid:
                        # process

# After (CC: 5)
def process(data):
    if not is_valid(data):
        return
    filtered = filter_valid_items(data)
    return process_items(filtered)

Flatten Nesting

Replace nested ifs with early returns:

# Before (depth: 5)
fn process(data):
    if check1(data):
        if check2(data):
            if check3(data):
                # complex logic

# After (depth: 2)
fn process(data):
    if not check1(data): return
    if not check2(data): return
    if not check3(data): return
    # complex logic

Workflow

# 1. Analyze code
./scripts/check_complexity.py

# 2. Review high-complexity functions
grep "CC:" complexity.txt | grep -E "CC: [2-9][0-9]|CC: [1-9][0-9]{2}"

# 3. Plan refactoring
# ... extract functions, flatten nesting ...

# 4. Re-analyze
./scripts/check_complexity.py

# 5. Verify improved
git diff complexity.txt

Error Handling

Issue Fix
Script not found Check scripts/ directory
Syntax errors Fix code syntax before analyzing
No output Verify source files exist

Thresholds

Project thresholds:

  • Max CC per function: 15
  • Max nesting depth: 4
  • Max function length: 50 LOC
  • Minimum test coverage: 80%

References

  • Related skill: phase-cleanup for refactoring guidelines
  • Related skill: quality-run-linters for complete quality check