Dead Code Discovery: Finding and Removing Code Nobody Calls

The Silent Accumulation

Dead code doesn't announce itself. It quietly accumulates:

• Features that got deprecated but never removed
• Utility functions written for one-time migrations
• Old API endpoints that no client uses anymore
• Experimental code that never shipped
• Duplicate implementations where only one survived

Most codebases have 10-30% dead code. The older the codebase, the higher the percentage.

Why Dead Code Matters

It's tempting to ignore dead code. If it's not running, what's the harm? Plenty:

• Maintenance burden: Every refactor has to consider code that doesn't matter
• Confusion: New developers don't know what's used and what isn't
• Build times: Dead code still gets compiled and bundled
• Security surface: Unused code can still have vulnerabilities
• Testing overhead: Sometimes dead code still has tests that need updating

The Detection Problem

Finding dead code is harder than it sounds. Simple approaches fail:

• Text search: Doesn't understand code structure
• IDE "find usages": One file at a time, misses dynamic calls
• Linters: Only catch obvious unused variables
• Test coverage: Low coverage doesn't mean dead—it might mean undertested

What you need is a complete call graph. You need to see every function and every path that leads to it.

The LOOM Approach

LOOM maps your entire codebase and builds a complete dependency graph. Functions with no inbound edges are dead code candidates. You can trace any function to see its callers—or discover it has none.

This isn't guessing. It's seeing the actual structure of your code.