techdebt
Automates discovery of technical debt hotspots, including code duplicates, dead code, and TODOs.
Install
mkdir -p .claude/skills/techdebt && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/15448" && unzip -o skill.zip -d .claude/skills/techdebt && rm skill.zipInstalls to .claude/skills/techdebt
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Detect technical debt — duplicated code, dead code, TODOs, and oversized functions across the codebase. Use at the end of a session or when auditing code hygiene. Trigger on "find tech debt", "any dead code", "duplicated code", "code hygiene", "techdebt".Key capabilities
- →Detect duplicated code.
- →Detect dead code.
- →Detect TODOs and FIXMEs.
- →Detect oversized functions and files.
- →Classify findings by severity and suggest fixes.
How it works
The skill executes a scan script that auto-detects language (Python/JS/TS) and uses various tools (pylint, jscpd, vulture, ts-prune, radon, pycycle, madge, grep) to find technical debt. It then interprets the output, classifies findings by severity, and suggests fixes.
Inputs & outputs
When to use techdebt
- →Find dead code
- →Scan for duplicates
- →Identify complexity hotspots
About this skill
Tech Debt Finder
Purpose
Surface technical debt patterns before they accumulate: duplicates, dead code, complexity hotspots, TODOs, oversized files.
Quick Start
/techdebt # scan current directory
/techdebt src/ # scan specific path
/techdebt --duplicates # only duplicate check
/techdebt --todos # only TODO/FIXME markers
/techdebt --dead-code # only dead code
How to Run
Execute the scan script — it auto-detects Python/JS/TS and skips missing tools:
bash $CLAUDE_SKILL_DIR/scripts/scan.sh [path] [filter-flag]
Then interpret and report the output using the Output Format below. The script handles tool invocation; your job is to classify findings by severity and suggest fixes.
Output Format
Produce a # Tech Debt Report with:
- Summary table — category, count, severity (Low / Medium / High)
- Details per category — file, line, symbol, suggestion
- Quick Fixes — any automatable repairs (
ruff --fix,eslint --fix) - Recommended Actions — prioritized: Immediate / This week / Backlog
Severity thresholds: duplicates (Low ≤2, Medium 3-5, High >5), dead code (Low ≤5, High >10), large functions (Medium >75 lines, High >100), large files (High >1000 lines), complexity CC >10 (Medium).
Tool Reference
Tools the script uses (installed = runs; missing = skipped with note):
| Check | Python | JS/TS |
|---|---|---|
| Duplicates | pylint | jscpd |
| Dead code | vulture | ts-prune |
| Complexity/size | radon | eslint |
| Circular imports | pycycle | madge |
| TODOs | grep (no dep) | grep (no dep) |
Install missing tools: uv add --dev vulture radon pylint / npm install -D jscpd ts-prune madge
Gotchas
.venv,node_modules,dist,__pycache__are auto-excluded by the scan scriptpylint --enable=duplicate-codeis slow on large codebases; warn if scanning >500 filests-pruneonly works from the project root (needstsconfig.json); run from a sub-path → 0 findingsradon cc= per-function cyclomatic complexity;radon raw= per-file LOC — different output formats- Deprecated registry dependency check requires
~/.claude/docs/development/registry.yaml; skip silently if absent
When not to use it
- →When the user needs to install missing tools.
- →When `ts-prune` needs to be run from a sub-path.
- →When `pylint --enable=duplicate-code` is slow on large codebases (>500 files).
Limitations
- →Requires specific tools to be installed for each check.
- →Automatically excludes certain directories like `.venv` and `node_modules`.
- →`ts-prune` only works from the project root.
How it compares
This skill automates the process of identifying various types of technical debt across different languages and provides a structured report with actionable recommendations, unlike manual code review.
Compared to similar skills
techdebt side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| techdebt (this skill) | 0 | 2mo | Review | Intermediate |
| effective-go | 323 | 9mo | No flags | Beginner |
| solid-principles | 57 | 9mo | No flags | Intermediate |
| typescript-review | 39 | 2mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by matteocervelli
View all by matteocervelli →You might also like
effective-go
openshift
Apply Go best practices, idioms, and conventions from golang.org/doc/effective_go. Use when writing, reviewing, or refactoring Go code to ensure idiomatic, clean, and efficient implementations.
solid-principles
SmidigStorm
Enforce SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) in object-oriented design. Use when writing or reviewing classes and modules.
typescript-review
metabase
Review TypeScript and JavaScript code changes for compliance with Metabase coding standards, style violations, and code quality issues. Use when reviewing pull requests or diffs containing TypeScript/JavaScript code.
ast-grep
ast-grep
Guide for writing ast-grep rules to perform structural code search and analysis. Use when users need to search codebases using Abstract Syntax Tree (AST) patterns, find specific code structures, or perform complex code queries that go beyond simple text search. This skill should be used when users ask to search for code patterns, find specific language constructs, or locate code with particular structural characteristics.
serena
massgen
This skill provides symbol-level code understanding and navigation using Language Server Protocol (LSP). Enables IDE-like capabilities for finding symbols, tracking references, and making precise code edits at the symbol level.
typescript
lobehub
TypeScript code style and optimization guidelines. Use when writing TypeScript code (.ts, .tsx, .mts files), reviewing code quality, or implementing type-safe patterns. Triggers on TypeScript development, type safety questions, or code style discussions.