quality-complexity-check

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

⭐8stars🔀4forks📁View on GitHub🕐Updated Jan 3, 2026

When & Why to Use This Skill

This Claude skill automates the analysis of code complexity metrics, such as cyclomatic complexity and nesting depth, to help developers identify technical debt and streamline the refactoring process. By providing actionable insights into code structure, it ensures higher maintainability and reduces the risk of bugs in complex software projects.

Use Cases

  • Automated Code Audits: Automatically scan source code during the review process to flag functions that exceed complexity thresholds (e.g., CC > 15).
  • Refactoring Prioritization: Identify 'spaghetti code' with deep nesting levels to prioritize which modules require immediate structural simplification.
  • Technical Debt Management: Generate comprehensive complexity reports to track code health over time and justify refactoring tasks to stakeholders.
  • Pre-release Quality Gates: Use as a final check before major releases to ensure that new features haven't introduced unmanageable logic or overly long functions.
  • Coding Standards Enforcement: Monitor function length and decision points to ensure the development team adheres to project-specific clean code guidelines.
namequality-complexity-check
descriptionAnalyze code complexity metrics including cyclomatic complexity and nesting depth. Use to identify code that needs refactoring.
mcp_fallbacknone
categoryquality
agenttest-engineer
user-invocablefalse

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