quality-complexity-check
Analyze code complexity metrics including cyclomatic complexity and nesting depth. Use to identify code that needs refactoring.
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.
| name | quality-complexity-check |
|---|---|
| description | Analyze code complexity metrics including cyclomatic complexity and nesting depth. Use to identify code that needs refactoring. |
| mcp_fallback | none |
| category | quality |
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-cleanupfor refactoring guidelines - Related skill:
quality-run-lintersfor complete quality check