Dead code removal

Skill yeaight7/agent-powerups/plugins/codebase-maintenance/skills/dead-code-removal

Curated power-ups for coding agents: skills, slash commands, MCP configs, hooks, AGENTS.md templates, and workflows for serious software engineering. Claude Code, Codex, Antigravity CLI, Cursor and more

Install

npx -y skills add yeaight7/agent-powerups --skill dead-code-removal

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

6 stars6 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Use when unused functions, classes, exports, or files need to be identified and safely deleted.

SKILL.md

2.5 KB, as published. Nobody here has run it

Purpose

Dead code increases maintenance overhead and confuses developers. Verify a symbol is truly unused across the entire repository, then delete it outright — never comment it out.

When to Use

A symbol, file, or export looks unused
A feature removal or migration left orphaned helpers behind
A coverage or lint report flags unreachable code

Inputs

The candidate symbols/files to remove
The repo's test and type-check commands

Workflow

Verify unused — search the entire repository. Do not assume code is dead just because the current file doesn't use it:
```
grep -rn "symbolName" . --include="*.ts" --include="*.tsx"    # all references
grep -rn "from ['\"].*module-name" src/                       # import sites
git log -3 --oneline -- path/to/suspect-file                  # recent touches
```
Ecosystem tools can shortcut the inventory when available (e.g., knip or ts-prune for TypeScript exports, vulture for Python).
Check for dynamic invocation. Be wary of dynamically invoked code — reflection, dependency injection by string name, ORM mappers, route tables, config-driven dispatch:
```
grep -rn "\"symbolName\"\|'symbolName'" .    # string-keyed references
```
If there is any doubt, leave it alone or ask the user.
Delete aggressively. Once confirmed unused, delete the code. Do not comment it out.
Prune dependencies. If you delete the only code that was using an imported module, remove the import statement as well.
Run tests. Always run tests and/or type checkers (e.g., tsc --noEmit) after removal to ensure you didn't accidentally break a hidden dependency.

Output

The deletion diff plus, per removed symbol, the search evidence that it was unused

Verification

Whole-repo search performed per symbol — including string-keyed/dynamic references
No commented-out code left behind
Orphaned imports pruned along with the dead code
Tests and type checker green after removal

Failure Modes

Current-file blindness — "this file doesn't use it" is not "the repo doesn't use it".
Dynamic-invocation casualties — reflection/DI/ORM references don't appear as imports; search string keys too.
Commenting instead of deleting — commented-out code is still dead code; git history already preserves it.