Solutions
Find and remove dead code.
The average enterprise codebase carries 10–30% dead code. That's code your team maintains, reviews, and deploys — but nobody calls. Axiom Refract finds it all and tells you exactly how much you can safely remove.
What dead code actually costs you.
Dead code isn't harmless. It's a silent tax on every engineering activity.
Maintenance Burden
Every dead file still gets read during onboarding. Every dead function still gets updated during refactors. Your team is maintaining code that does nothing.
Developer Confusion
New engineers don't know which modules are active and which are abandoned. They build on top of dead code, creating dependencies on things that should have been deleted years ago.
Expanded Attack Surface
Unused code still ships. Unused dependencies still get installed. Every line of dead code is a line that can contain a vulnerability — and nobody is reviewing it because nobody thinks it matters.
False Confidence in Test Coverage
Dead code inflates your line count. If 15% of your codebase is dead, your “80% coverage” is actually covering less than you think. The denominator is lying to you.
Four categories of dead code. One scan.
Most tools stop at unused imports. Axiom Refract identifies dead code at every level of your system.
Dead Files
Files that are never imported, never referenced, never executed. Entire modules sitting untouched.
Dead Functions
Functions and methods defined but never called from any live code path. The function exists; nothing uses it.
Orphaned Database Tables
Tables defined in your schema but never queried or written to by any application code. Data structures with no consumers.
Ghost Methods
The inverse: symbols that are called but never defined. Something in your code references a function that doesn't exist. These are latent runtime errors waiting to surface.
Recoverable LOC: one number that changes the conversation.
After scanning your codebase, Axiom Refract reports a single metric that cuts through every debate about cleanup priority: recoverable lines of code.
This is the total volume of code — measured in lines — that can be safely removed without affecting any live functionality. Dead files, dead functions, orphaned tables, all aggregated into one number.
It's not an estimate. It's not a heuristic. It's computed from the actual dependency graph. If no live code path reaches it, it's dead — and Axiom tells you exactly how many lines that represents.
Across codebases analyzed by Axiom Refract
10–30%
of lines are recoverable dead code — code that ships, gets maintained, and does nothing.
How it works.
Axiom Refract parses your entire codebase using Tree-sitter AST analysis across 145+ languages. It builds a complete dependency graph — every import, every function call, every database query reference — and then walks the graph to find what's connected and what isn't.
Code that has no inbound edges — nothing imports it, nothing calls it, nothing references it — is dead. Axiom flags it, counts it, and tells you exactly which files and functions are safe to remove.
No configuration. No rule files. No false positives from unused-import linters that don't understand your framework's conventions. Axiom works at the structural level, not the syntactic level.
See how much dead code your codebase is carrying.
Upload your repository. Get a complete dead code inventory — files, functions, tables, and ghost methods — with exact recoverable line counts.