complexity-audit

To audit code for complexity, this skill analyzes modules to detect circular dependencies, god objects, and layering violations. It identifies mutual imports, cross-layer leakage, and large classes, providing severity ratings and remediation suggestions to guide refactoring efforts.

Accidental complexity refers to unnecessary intricacies in code that make it hard to maintain. This skill identifies it by scanning for anti-patterns like hidden invariants, implicit state, over-configuration, and temporal coupling, classifying each issue by severity to pinpoint problematic areas.

Before refactoring, you can audit specific modules to pinpoint problematic areas. This skill assesses complexity issues by severity—Harmless, Concerning, or Dangerous—highlighting exact layering violations and coupling problems so you can prioritize your refactoring efforts effectively.

Yes, this code complexity analysis detects cross-layer leakage and temporal coupling. It explicitly audits for these structural violations alongside mutual requires, hidden invariants, and over-configuration, assigning a severity rating to each identified issue.

The best way to assess technical debt in large modules is auditing them for structural anti-patterns. This skill identifies god objects, large modules, and implicit state, providing targeted remediation suggestions to reduce coupling and improve overall maintainability.

Yes, you can check for layering violations and mutual imports in a specific module by running an audit. The skill analyzes the targeted module for cross-layer leakage, mutual requires, and other coupling issues, returning severity ratings to indicate the impact.