Code Analyzer Skill

Installation

No separate download: the skill runs the in-repo tool

.claude/tools/analysis/project-analyzer/analyzer.mjs

Ensure Node.js (v18+) is installed: nodejs.org or
```
winget install OpenJS.NodeJS.LTS
```
(Windows),
```
brew install node
```
(macOS).
From the project root, the script is invoked automatically; no extra install steps.

Cheat Sheet & Best Practices

Metrics: Focus on cyclomatic complexity (decision paths), LOC, maintainability index, and duplicate blocks. Use ESLint

complexity

rule (e.g.

"complexity": ["error", 15]

) for JS/TS; optional chaining and default params add branches.

Process: Analyze before refactoring; run project-wide then drill into hotspots. Track trends over time (not one-off). Use

max-depth

max-lines

max-nested-callbacks

max-params

max-statements

alongside complexity.

Hacks: Start with project-analyzer output; filter by file type and threshold. Prioritize files with high complexity and high churn. Disable complexity rule only if you cannot set a sensible limit; prefer lowering the threshold over disabling.

Certifications & Training

No single cert; aligns with static analysis and ESLint complexity. ESLint: complexity rule, max-depth, max-lines, max-params. Skill data: Cyclomatic complexity, LOC, maintainability, duplicates; analyze before refactor; track hotspots and trends.

Hooks & Workflows

Suggested hooks: Pre-commit or CI: run project-analyzer/doctor for health; optional complexity gate. Use with developer (secondary), qa (secondary), code-reviewer (primary).

Workflows: Use with code-reviewer (primary), developer/ qa (secondary), c4-code (primary). Flow: run analyzer → filter hotspots → refactor or add tests. See

code-review-workflow.md

Overview

Static code analysis and metrics. 90%+ context savings.

Tools (Progressive Disclosure)

Analysis

Tool	Description
analyze-file	Analyze single file
analyze-project	Analyze entire project
complexity	Calculate complexity metrics

Metrics

Tool	Description
loc	Lines of code
cyclomatic	Cyclomatic complexity
maintainability	Maintainability index
duplicates	Find duplicate code

Reporting

Tool	Description
summary	Get analysis summary
hotspots	Find complexity hotspots
trends	Analyze metric trends

Agent Integration

code-reviewer (primary): Code review
refactoring-specialist (primary): Tech debt analysis
architect (secondary): Architecture assessment

Iron Laws

ALWAYS run project-wide analysis before drilling into individual files — local analysis without context misses which files are actually the highest-priority hotspots; start broad, then focus.
ALWAYS focus on high-complexity AND high-churn files — a complex but rarely-changed file is lower priority than a moderately complex but frequently-changed one; intersection matters most.
NEVER set complexity thresholds above 20 — cyclomatic complexity >20 is demonstrably correlated with defects; teams that allow >20 accumulate unmaintainable code without noticing.
ALWAYS track metrics over time, not just once — a single analysis snapshot is meaningless; track trends weekly to detect gradual degradation before it becomes a crisis.
NEVER report metrics without actionable next steps — complexity numbers without refactoring targets provide no value; every high-complexity finding must include a specific suggested improvement.

Anti-Patterns

Anti-Pattern	Why It Fails	Correct Approach
Analyzing only changed files	Misses cross-file complexity accumulation	Run project-wide then filter to changed hot spots
Ignoring high-complexity files over time	Gradual degradation invisible in point-in-time analysis	Track weekly trends; alert on any increase
Complexity threshold >20	Research shows defect rate spikes sharply above 20	Set ESLint complexity rule to ≤15 for enforcement
Reporting metrics without action items	Metrics without remediation don't reduce complexity	Attach specific refactoring suggestion per hotspot
Running analysis once and ignoring results	Technical debt silently accumulates	Schedule automated weekly analysis with trend reports

Memory Protocol (MANDATORY)

Before starting: Read

.claude/context/memory/learnings.md

After completing:

New pattern ->
```
.claude/context/memory/learnings.md
```
Issue found ->
```
.claude/context/memory/issues.md
```
Decision made ->
```
.claude/context/memory/decisions.md
```

ASSUME INTERRUPTION: If it's not in memory, it didn't happen.

code-analyzer

NPX Install

Tags

SKILL.md Content