skills.rest
robotijn
robotijnCOMMUNITY
Explore all skills by this author →
GitHub

complexity-analyzer

Measure cyclomatic, cognitive, NPath, Halstead, and structural complexity across programming languages.

3|2|Updated Jan 23, 2026
Search Tags:#code quality#static analysis#refactoring#maintainability#technical debt#cyclomatic complexity#code complexity
One-click install
npx skills add https://github.com/robotijn/ctoc --skill complexity-analyzer-robotijn
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: complexity-analyzer
Source: https://github.com/robotijn/ctoc/tree/main/skills/quality/complexity-analyzer
Command: npx skills add https://github.com/robotijn/ctoc --skill complexity-analyzer-robotijn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of unmaintainable, hard-to-read code by automatically measuring multiple standard code complexity metrics to identify functions that require refactoring before they accumulate technical debt and cause bugs.

Core Features & Use Cases

  • Multi-metric measurement: Calculates cyclomatic, cognitive, NPath, Halstead, and structural complexity metrics across 7+ programming languages.
  • Actionable findings: Every flagged function includes the measured metric value, threshold breach, and concrete refactor suggestions, with no findings lacking a fix recommendation.
  • Tool integration: Works with common static analysis tools (SonarQube, lizard, radon, language-specific linters) and integrates into CI/CD pipelines and code review workflows.
  • Edge case handling: Includes a suppression contract for legitimate complexity exceedances like generated code, state machines, and sealed enum switches. Use case: A development team can run this skill during code review to catch overly complex functions early, reducing long-term maintenance costs and preventing hard-to-debug issues.

Quick Start

Use the complexity-analyzer skill to scan your project's source code for functions exceeding complexity thresholds and get a prioritized list of refactoring hotspots with suggested fixes.

Frequently Asked Questions about complexity-analyzer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I measure code complexity to find refactoring hotspots?▼

Code complexity measurement calculates cyclomatic, cognitive, NPath, Halstead, and structural metrics to identify functions exceeding maintainability thresholds. Every flagged function receives a concrete refactor suggestion to resolve the identified hotspot.

What code complexity metrics should I track for technical debt?▼

Tracking cyclomatic, cognitive, NPath, Halstead, and structural code complexity metrics identifies unmaintainable functions before they accumulate technical debt. These metrics expose hard-to-read code paths and prioritize functions that require immediate refactoring to prevent bugs.

Can I integrate static analysis into CI/CD pipelines for code review?▼

Static analysis integrates directly into CI/CD quality gates and code review workflows. It works with common tools like SonarQube, lizard, radon, and language-specific linters, outputting structured reports compatible with refinement loops to catch overly complex functions early.

Does code complexity analysis support polyglot codebases with multiple languages?▼

Code complexity analysis supports polyglot codebases by calculating maintainability metrics across 7+ programming languages. It applies uniform thresholds to identify refactoring hotspots regardless of the language, ensuring consistent technical debt tracking across the entire project.

How do I handle false positives in generated code during complexity analysis?▼

Complexity analysis handles false positives in generated code through a suppression contract mechanism. This explicitly excludes legitimate complexity exceedances like state machines, sealed enum switches, and generated code from refactoring findings without disabling analysis for the rest of the codebase.

Why does cyclomatic complexity matter for maintaining code quality?▼

Cyclomatic complexity matters because it quantifies the number of independent execution paths in a function, directly correlating with maintainability and testing difficulty. Measuring it identifies functions that are hard to read and prone to bugs before they accumulate technical debt.

Related Skills

Explore More Software Engineering Skills→
CuriousLearnerCuriousLearner
27

complexity-analyzer

Measure code complexity metrics and identify high-complexity areas in software projects.

Community
Advanced
forcedotcomforcedotcom
803

running-apex-tests

Execute Salesforce Apex unit tests with coverage analysis and failure diagnosis.

Official
Advanced
dinoudondinoudon

code-quality-metrics

Assess code quality using cyclomatic complexity, test coverage, and maintainability metrics.

Community
Advanced
deandumdeandum
3

style

Enforce language-agnostic coding style and conventions across a codebase.

Community
Intermediate