Dead Code Removal
- 180 installs
- 4 repo stars
- Updated April 11, 2026
- 89jobrien/steve
dead-code-removal is a Claude Code skill that detects and safely removes unused imports, functions, and classes across multiple languages with dependency analysis, safety checks, and backups.
About
dead-code-removal is a Claude Code skill that detects and safely removes unused code across multiple languages. A developer uses it after refactoring, when removing features, or before production deployment to reduce bundle size. It builds dependency graphs, applies safety checks that skip dynamic and framework code, creates backups, and validates each incremental removal with syntax checks and tests.
- Detects and safely removes unused imports, functions, and classes across languages
- Includes AST-based Python helper (find_unused_imports.py) plus safety checks and backups
- Preserves framework patterns (Django, React, Spring) and dynamic-usage code
Dead Code Removal by the numbers
- 180 all-time installs (skills.sh)
- Ranked #354 of 1,352 Code Review & Quality skills by installs in the Skillselion catalog
- Data as of Jul 28, 2026 (Skillselion catalog sync)
dead-code-removal capabilities & compatibility
- Capabilities
- dead code removal · refactoring · dependency analysis
- Use cases
- refactoring
- Pricing
- Free
What dead-code-removal says it does
This skill safely identifies and removes unused code across multiple programming languages.
It includes comprehensive safety checks to prevent removing code that's actually needed.
npx skills add https://github.com/89jobrien/steve --skill dead-code-removalAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 180 |
|---|---|
| repo stars | ★ 4 |
| Last updated | April 11, 2026 |
| Repository | 89jobrien/steve ↗ |
What it does
Use it to safely find and remove unused imports, functions, and classes across Python, JavaScript, Java, Go, and Rust projects.
Who is it for?
Cleaning up unused code after refactoring or before deployment, with safety checks and backups.
Skip if: Codebases relying heavily on dynamic imports or reflection where usage cannot be statically proven.
When should I use this skill?
After refactoring, when removing features, or before production deployment to reduce bundle size.
What you get
Unused code safely removed and validated, with backups and tests passing.
- unused-code report
- safe incremental removals
- code backup
By the numbers
- 6-step analysis process
- 1 AST-based Python helper script (find_unused_imports.py)
Files
Dead Code Removal
This skill safely identifies and removes unused code across multiple programming languages. It includes comprehensive safety checks to prevent removing code that's actually needed.
When to Use This Skill
- After refactoring code and removing features
- Before production deployment to reduce bundle size
- When cleaning up legacy code
- When removing deprecated functionality
- When optimizing codebase size
- When maintaining code quality standards
What This Skill Does
1. Language Detection: Identifies project languages and structure 2. Entry Point Mapping: Maps entry points and critical paths 3. Dependency Analysis: Builds dependency graphs and usage patterns 4. Safe Detection: Identifies unused elements with safety checks 5. Incremental Removal: Removes code incrementally with validation 6. Backup Creation: Creates backups before making changes
Helper Scripts
This skill includes Python helper scripts in scripts/:
- `find_unused_imports.py`: Uses AST parsing to accurately detect unused imports in Python files. Outputs JSON with unused imports and line numbers.
python scripts/find_unused_imports.py src/utils.py src/services.pyHow to Use
Remove Unused Code
Find and remove unused imports and functions in this projectClean up dead code in src/ directory, but be conservativeSpecific Analysis
Check for unused functions in src/utils/ and remove them safelyAnalysis Process
1. Language Detection
Identify Project Type:
- Python: Look for
pyproject.toml,setup.py,requirements.txt - JavaScript/TypeScript: Check
package.json,tsconfig.json - Java: Look for
pom.xml,build.gradle - Go: Check
go.mod - Rust: Check
Cargo.toml
Detect Entry Points:
- Python:
main.py,__main__.py,app.py,run.py - JavaScript:
index.js,main.js,server.js,app.js - Java:
Main.java,*Application.java,*Controller.java - Config files:
*.config.*,settings.*,setup.* - Test files:
test_*.py,*.test.js,*.spec.js
2. Build Dependency Graph
Cross-File Dependencies:
- Track imports and requires
- Map function/method calls
- Identify class inheritance
- Track dynamic usage patterns
Framework Patterns:
- Preserve framework-specific patterns (Django models, React components, etc.)
- Check for decorators and annotations
- Verify entry point registrations
3. Detect Unused Elements
Using Helper Script:
The skill includes a Python helper script for finding unused imports:
# Find unused imports in Python files
python scripts/find_unused_imports.py src/utils.py src/services.pyUnused Imports:
# Python: AST-based analysis
import ast
# Track: Import statements vs actual usage
# Skip: Dynamic imports (importlib, __import__)// JavaScript: Module analysis
// Track: import/require vs references
// Skip: Dynamic imports, lazy loadingUnused Functions/Classes:
- Define: All declared functions/classes
- Reference: Direct calls, inheritance, callbacks
- Preserve: Entry points, framework hooks, event handlers
4. Safety Checks
Never Remove If:
- Python:
getattr(),eval(),globals()usage detected - JavaScript:
window[],this[], dynamicimport()usage - Java: Reflection, annotations (
@Component,@Service) - Framework patterns: Models, controllers, routes, components
- Entry points: Main functions, app initialization
- Test files: All test-related code
Framework Preservation:
Python:
- Django: Models, migrations, admin registrations
- Flask: Routes, blueprints, app factories
- FastAPI: Endpoints, dependencies
JavaScript:
- React: Components, hooks, context providers
- Vue: Components, directives, mixins
- Angular: Decorators, services, modules
Java:
- Spring: Beans, controllers, repositories
- JPA: Entities, repositories
5. Safe Removal Process
Backup Creation:
backup_dir="./unused_code_backup_$(date +%Y%m%d_%H%M%S)"
cp -r . "$backup_dir" 2>/dev/null || mkdir -p "$backup_dir" && rsync -a . "$backup_dir"Incremental Removal:
1. Create temp file with change 2. Validate syntax 3. Run tests if available 4. Apply or rollback
Validation:
# Python
python -m py_compile file.py
python -m pytest
# JavaScript
npx eslint file.js
npm test
# Java
javac -Xlint file.java
mvn testExamples
Example 1: Remove Unused Imports
Input: Clean up unused imports in src/utils/helpers.py
Output:
## Dead Code Removal: src/utils/helpers.py
### Analysis
- **File**: `src/utils/helpers.py`
- **Total imports**: 8
- **Unused imports**: 3
### Unused Imports Found
1. `import os` - Line 2 (not used anywhere)
2. `import json` - Line 3 (not used anywhere)
3. `from datetime import timedelta` - Line 5 (not used anywhere)
### Safe to Remove
✅ All 3 imports are safe to remove (no dynamic usage detected)
### ChangesBefore
import os import json from datetime import datetime, timedelta import requests
After
from datetime import datetime import requests
### Validation
- ✅ Syntax check passed
- ✅ Tests pass
- ✅ No dynamic imports detected
Example 2: Remove Unused Functions
Input: Find unused functions in src/services/
Output:
## Dead Code Removal: src/services/
### Analysis
- **Files analyzed**: 12
- **Functions found**: 45
- **Unused functions**: 2
### Unused Functions
**1. `formatOldDate()` in `src/services/utils.js`**
- **Location**: Line 34-42
- **Status**: ✅ Safe to remove
- **Reason**: No references found, not exported, not used in tests
**2. `legacyAuth()` in `src/services/auth.js`**
- **Location**: Line 78-95
- **Status**: ⚠️ Preserved (framework pattern)
- **Reason**: Referenced in route configuration (line 12)
### Summary
- **Removed**: 1 function (`formatOldDate`)
- **Preserved**: 1 function (framework usage)
- **Lines removed**: 9
- **Size reduction**: ~300 bytesBest Practices
Safety Guidelines
Do:
- Run tests after each removal
- Preserve framework patterns
- Check string references in templates
- Validate syntax continuously
- Create comprehensive backups
- Remove incrementally
Don't:
- Remove without understanding purpose
- Batch remove without testing
- Ignore dynamic usage patterns
- Skip configuration files
- Remove from migrations
- Remove exported/public APIs
Detection Patterns
Static Analysis:
- Use AST parsing for accurate detection
- Track cross-file references
- Check for dynamic usage patterns
- Verify framework-specific patterns
Validation:
- Always run syntax checks
- Run tests after removal
- Verify build still works
- Check for runtime errors
Reporting
Report Should Include:
- Files analyzed (count and types)
- Unused detected (imports, functions, classes)
- Safely removed (with validation status)
- Preserved (reason for keeping)
- Impact metrics (lines removed, size reduction)
Related Use Cases
- Code cleanup before release
- Reducing bundle size
- Removing deprecated code
- Maintaining code quality
- Refactoring legacy codebases
- Optimizing build times
#!/usr/bin/env python3
"""Find unused imports in Python files.
Uses AST parsing to accurately detect unused imports.
"""
import ast
import json
import sys
from pathlib import Path
class ImportVisitor(ast.NodeVisitor):
"""AST visitor to collect imports and their usage."""
def __init__(self):
self.imports = {} # name -> line_number
self.used_names = set()
self.import_star = False
def visit_Import(self, node):
for alias in node.names:
name = alias.asname if alias.asname else alias.name.split(".")[0]
self.imports[name] = node.lineno
self.generic_visit(node)
def visit_ImportFrom(self, node):
if node.module:
if node.names[0].name == "*":
self.import_star = True
else:
for alias in node.names:
name = alias.asname if alias.asname else alias.name
self.imports[name] = node.lineno
self.generic_visit(node)
def visit_Name(self, node):
if isinstance(node.ctx, ast.Load):
self.used_names.add(node.id)
self.generic_visit(node)
def visit_Attribute(self, node):
# Handle cases like os.path, sys.argv
if isinstance(node.value, ast.Name):
self.used_names.add(node.value.id)
self.generic_visit(node)
def find_unused_imports(file_path: Path) -> dict:
"""Find unused imports in a Python file."""
try:
content = file_path.read_text()
tree = ast.parse(content, filename=str(file_path))
visitor = ImportVisitor()
visitor.visit(tree)
# Find unused imports
unused = []
for name, line_num in visitor.imports.items():
if name not in visitor.used_names and not visitor.import_star:
unused.append(
{
"name": name,
"line": line_num,
}
)
return {
"file": str(file_path),
"unused_imports": unused,
"total_imports": len(visitor.imports),
"has_import_star": visitor.import_star,
}
except SyntaxError as e:
return {
"file": str(file_path),
"error": f"Syntax error: {e}",
"unused_imports": [],
}
except Exception as e:
return {
"file": str(file_path),
"error": f"Error parsing file: {e}",
"unused_imports": [],
}
def main():
"""Main entry point."""
if len(sys.argv) < 2:
print("Usage: find_unused_imports.py <python_file> [<python_file>...]")
sys.exit(1)
results = []
for file_path_str in sys.argv[1:]:
file_path = Path(file_path_str)
if not file_path.exists():
print(f"Warning: File not found: {file_path}", file=sys.stderr)
continue
result = find_unused_imports(file_path)
results.append(result)
print(json.dumps(results, indent=2))
if __name__ == "__main__":
main()
Related skills
Improve Codebase ArchitectureSafely deepen clusters of shallow modules into cohesive, testable units while respecting their external dependencies.566k196k
Caveman ReviewGet ultra-compressed, one-line code review comments that cut noise while keeping every actionable fix.270k94.7kCodebase DesignShared vocabulary for designing deep modules: improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable.266k196kCavecrewDelegate coding tasks to specialized subagents that return compressed output, keeping the main context window usable for much longer sessions.220k94.7kCode ReviewReviews a branch or PR diff on two axes at once: conformance to coding standards plus a code-smell baseline, and whether it actually implements the original spec.201k196k
Requesting Code ReviewDispatch a consistent, high-signal code reviewer subagent that catches plan deviations and quality issues before merging or continuing development.183k264kFAQ
Which languages does it detect entry points for?
Python, JavaScript/TypeScript, Java, Go, and Rust per the SKILL.md.
How does it stay safe?
It skips dynamic usage (getattr, eval, dynamic import) and framework patterns, creates backups, and validates each removal with syntax checks and tests.