cleanup-code
/cleanup-code
Comprehensive codebase cleanup across 11 quality dimensions: dead code, duplication, weak types, circular deps, defensive cruft, legacy code, AI slop, type consolidation, security, performance, and async patterns. Analyzes code with confidence scoring and verifies changes with build/test gates. Use when codebase has accumulated tech debt, after major feature work, before releases, or when code quality metrics are declining. Trigger with "/cleanup-code-code", "clean up the codebase", "remove dead code", "fix code quality".
- Author
- jeremylongshore ↗
- Repository
- tons-of-skills-marketplace ↗
- Licence
- MIT
- Last repository change
- 26.10.2026
Assessment and security
- Files in this package
- 5
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Comprehensive codebase cleanup across 11 quality dimensions: dead code, duplication, weak types, circular deps, defensive cruft, legacy code, AI slop, type consolidation, security, performance, and async patterns. Analyzes code with confidence scoring and verifies changes with build/test gates. Use when codebase has accumulated tech debt, after major feature work, before releases, or when code quality metrics are declining. Trigger with "/cleanup-code-code", "clean up the codebase", "remove dead code", "fix code quality".
Triggers from the description
Arguments
/cleanup-code [scope] [--dimensions d1,d2,...] [--changed]
Original author description
Comprehensive codebase cleanup across 11 quality dimensions: dead code, duplication, weak types, circular deps, defensive cruft, legacy code, AI slop, type consolidation, security, performance, and async patterns. Analyzes code with confidence scoring and verifies changes with build/test gates. Use when codebase has accumulated tech debt, after major feature work, before releases, or when code quality metrics are declining. Trigger with "/cleanup-code-code", "clean up the codebase", "remove dead code", "fix code quality".
How it works
- Environment Detection
- Prerequisites
- Overview
- Instructions
- Output
- Error Handling
- Examples
- Resources
SKILL.md preview
--- name: cleanup-code description: 'Comprehensive codebase cleanup across 11 quality dimensions: dead code, duplication, weak types, circular deps, defensive cruft, legacy code, AI slop, type consolidation, security, performance, and async patterns. Analyzes code with confidence scoring and verifies changes with build/test gates. Use when codebase has accumulated tech debt, after major feature work, before releases, or when code quality metrics are declining. Trigger with "/cleanup-code-code", "clean up the codebase", "remove dead code", "fix code quality". ' allowed-tools: Read, Write, Edit, Glob, Grep, Bash(git:*), Bash(npm:*), Bash(npx:*), Bash(pnpm:*), Bash(python3:*), Bash(tsc:*), Bash(wc:*), Bash(ls:*), AskUserQuestion version: 1.7.0 author: Jeremy Longshore <jeremy@intentsolutions.io> license: MIT tags: - code-quality - cleanup - refactoring - dead-code - deduplication - type-safety - security argument-hint: '[scope] [--dimensions d1,d2,...] [--changed]' compatibility: Designed for Claude Code --- # Codebase Cleanup Systematic code cleanup across 11 quality dimensions, ordered by risk. Each finding includes confidence scoring (HIGH/MEDIUM/LOW) and all changes are verified through build/test gates. ## Environment Detection !`git rev-parse --show-toplevel 2>/dev/null && echo "---" && git diff --stat HEAD~5 2>/dev/null | tail -5` !`ls package.json pyproject.toml Cargo.toml go.mod Makefile 2>/dev/null | head -5` !`cat package.json 2>/dev/null | head -3; echo "---"; ls tsconfig.json .eslintrc* 2>/dev/null` ## Prerequisites - Git repository with clean working tree (no uncommitted changes) - Language toolchain installed (Node.js/Python/Go/Rust as applicable) - Optional: `knip`, `madge`, `jscpd`, `ruff`, `bandit` for tool-verified scanning ## Overview This skill orchestrates cleanup across **11 dimensions**, each with a dedicated agent. Dimensions are ordered LOW → HIGH risk. See [dimensions reference](references/dimensions.md) for full detection criteria, verification steps, and risk profiles. **The 11 Dimensions** (by risk level): | # | Dimension | Key | Risk | Auto-apply? | |---|-----------|-----|------|-------------| | 1 | Dead code removal | `dead` | LOW | Yes (after build) | | 2 | AI slop removal | `slop` | LOW | Comments only | | 3 | Weak type elimination | `types` | MED | Yes (after typecheck) | | 4 | Security cleanup | `security` | MED | Flag only | | 5 | Legacy code removal | `legacy` | MED | With confirmation | | 6 | Type consolidation | `typecons` | MED | Yes (after typecheck) | | 7 | Defensive code cleanup | `defensive` | MED | Flag only | | 8 | Performance optimization | `perf` | MED | Flag only | | 9 | DRY deduplication | `dry` | HIGH | Flag only (>=10 lines) | | 10 | Async pattern fixes | `async` | HIGH | Flag only | | 11 | Circular dep untangling | `circular` | HIGH | Flag only | ## Instructions ### Step 1: Safety Checkpoint Before any changes: 1. Verify clean git state: `git status --porcelain` must be empty (or stash changes) 2. Record baseline: `git rev-parse HEAD` as rollback point 3. Run existing tests to confirm green baseline 4. See [safety protocol](references/safety.md) for revert procedures ### Step 2: Determine Scope Parse user arguments to set scope: - **Full codebase** (default): scan all source files - **Specific path**: `cleanup src/api/` — limit to directory - **Changed files only**: `--changed` flag — `git diff --name-only HEAD~10` - **Specific dimensions**: `--dimensions dead,types,security` - **Single dimension**: `cleanup --dimensions dry` Exclude from all scans: `node_modules/`, `dist/`, `build/`, `.git/`, vendor dirs, generated files. ### Step 3: Execute Dimensions For each selected dimension (in risk order): 1. **Scan** using patterns from [patterns reference](references/patterns.md) 2. **Score confidence** — HIGH (certain, safe to fix), MEDIUM (likely, needs review), LOW (possible, flag only) 3. **Apply or flag** based on the dimension's auto-apply policy (see table above) 4. **Verify** — run build/typecheck/tests after each dimension with auto-apply Use [tools reference](references/tools.md) for language-specific tool commands (knip, madge, ruff, jscpd, etc.). ### Step 4: Build Verification Gate After each auto-applied dimension: ```text # TypeScript/JavaScript npx tsc --noEmit 2>&1 | tail -20 npm test 2>&1 | tail -30 # Python python3 -m py_compile <changed_files> python3 -m pytest --tb=short 2>&1 | tail -30 # General git diff --stat # Show what changed ``` If verification fails, revert that dimension: `git checkout -- .` ### Step 5: Generate Report Produce a cleanup report in this format: ``` ## Cleanup Report **Scope:** [path or "full codebase"] **Baseline:** [commit hash] **Dimensions:** [list of dimensions run] ### Summary | Dimension | Findings | Applied | Flagged | Confidence | |-----------|----------|---------|---------|------------| | dead | 12 | 10 | 2 | HIGH | | types | 8 | 8 | 0 | HIGH | | security | 3 | 0 | 3 | MEDIUM | ### Changes Applied - [file:line] description of change ### Flagged for Review - [file:line] description + reasoning + suggested fix ### Lines Removed: N | Lines Modified: N | Files Touched: N ``` ## Output A structured cleanup report containing: - Summary table with findings per dimension (count, applied, flagged, confidence) - List of changes applied with file:line references - List of flagged items with reasoning and suggested fixes - Stats: lines removed, lines modified, files touched ## Error Handling | Error | Recovery | |-------|----------| | Dirty git state | Ask user to commit or stash first | | Build fails after cleanup | `git checkout -- .` to revert dimension | | No test command found | Skip verification, flag all as "unverified" | | Tool not installed | Fall back to grep patterns (see references/patterns.md) | | Confidence unclear | Default to flag-only, never auto-apply | ## Examples **Full cleanup:** ``` /cleanup-code ``` **Security-focused:** ``` /cleanup-code --dimensions security,async ``` **Changed files only:** ``` /cleanup-code src/api/ --changed ``` **Single dimension deep-dive:** ``` /cleanup-code --dimensions dead ``` ## Resources - [All 11 Dimensions](references/dimensions.md) — detection criteria, verification, risk profiles - [Tool Reference](references/tools.md) — language-specific cleanup tools - [Grep Patterns](references/patterns.md) — detection patterns by dimension - [Safety Protocol](references/safety.md) — revert procedures, confidence scoring
Files in this package (5)
- SKILL.md 6 KB
- references/dimensions.md 9 KB
- references/patterns.md 6 KB
- references/safety.md 4 KB
- references/tools.md 4 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · jeremylongshore/tons-of-skills-marketplace | 100 | MIT |
| sydasif/claude-python-standards | 90 | MIT |
| rowansci/rowan-python | 86 | MIT |
Identical content appears in 1 other GitHub folders. We show one copy with the highest score.
Database snapshot: 13.11.2026 · package version 0efbf1afed24 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100run-ts-cleanup
Use if cleaning up a TypeScript codebase — dead code, unused deps, AI slop, weak types. - 100code-quality
Run comprehensive code quality analysis: cyclomatic complexity, code smells, SOLID principle violations, dead code detection, duplication analysis, and maintainability scoring. Use when reviewing code quality, conducting code audits, checking technical debt, analyzing complexity… - 100slop-scan
Scan a codebase for accumulated slop, technical debt, dead code, and refactor opportunities. Default is recent changes only. Use when user says 'scan for slop', 'find tech debt', 'what needs cleanup', or before a refactor sprint. Don't use as the pre-PR gate — that is /vet (lens D). - 90prune
Audit a codebase for dead code, duplication, unused dependencies, and cruft, then safely remove what no longer earns its place. Evidence-based (runs real dead-code analyzers, not vibes), confidence-tiered, and verification-gated. Use when the user wants to clean up / declutter /… - 100refactor
Audits the codebase for code quality issues and refactors without changing external behavior. This skill should be used when the user asks to "refactor the codebase", "clean up code quality", "eliminate duplication", "improve abstractions", "enforce consistency", "remove dead… - 100code-audit
Use when the user says '/code-audit', 'audit this code', 'check code quality', 'find duplication', 'find dead code', 'code cleanup', 'technical debt audit', 'code review module', or wants a structured noetic investigation of code quality. This skill runs external analysis tools…