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 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.
| 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 |
| agent | test-engineer |
| user-invocable | false |
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