Know exactly how much your technical debt costs.
Scan any Git repo. Get a report your CFO can read — with costs in euros and prioritized recommendations.
Free. No account required. Works offline.
From git log to boardroom in 3 steps
Analyze locally
Run debtlens analyze on any repo. Get an instant HTML report with 7 metrics — completely offline.
Push to the hub
Activate a license and run debtlens report. Your aggregated scores (never source code) are sent to the hub.
Get AI insights
Claude generates a business narrative. Download a PDF your CFO can read — costs in euros, prioritized actions.
Seven dimensions of technical debt
Hotspots
Files changed most often — where bugs keep coming back.
Complexity x Churn
Complex files that change frequently — the danger zone.
Temporal Coupling
Files that always change together — hidden dependencies.
Knowledge Silos
Code owned by a single developer — your bus factor.
Dead Code
Files no one touches — cleanup candidates.
Velocity Trend
Is the team shipping features or fighting fires?
Merge Discipline
Is the team reviewing code before merging? Your quality bus factor.
What each scan reveals
DebtLens reads your git history — commits, authors, file changes — and computes six complementary metrics. Together, they paint a complete picture of your codebase health.
Hotspot Analysis
What it measures: Ranks every file by how often it was changed over the last 6 months. A file touched 47 times while the average is 3 is a hotspot.
Why it matters: Hotspots concentrate bugs. Research shows that 4% of files cause 50% of defects. Knowing where they are lets you focus refactoring where it actually matters.
What the report shows: A ranked list of critical and warning hotspots, with change frequency and a density score (0–1) that feeds into your overall health rating.
Complexity x Churn
What it measures: Cross-references cyclomatic complexity with change frequency. A 500-line file with complexity 40 that changes weekly is far more dangerous than a complex file nobody touches.
Why it matters: Complex + frequently changed = highest defect probability. These files slow down every developer who touches them and are the #1 source of regressions.
What the report shows: A quadrant map: high-complexity/high-churn files are flagged as critical. You see exactly which files need refactoring first for maximum impact.
Temporal Coupling
What it measures: Detects files that consistently change together in the same commits. If UserService.php and BillingHelper.php always change as a pair, they have hidden coupling.
Why it matters: Temporal coupling reveals architectural debt that static analysis misses. These hidden dependencies make changes unpredictable — touching one file breaks another in ways no linter can catch.
What the report shows: A coupling index (0–1) and the pairs of files with the strongest co-change patterns. High coupling = candidates for merging or clearer interfaces.
Knowledge Silos
What it measures: Measures author concentration per file. If 90% of commits on a critical module come from one person, that module is a knowledge silo.
Why it matters: When that person goes on vacation, changes teams, or quits, nobody else can safely modify the code. Knowledge silos are a direct operational risk — your bus factor.
What the report shows: A silo risk score (0–1) and the number of files with dangerous single-author concentration. The report highlights which areas need knowledge sharing or pair programming.
Dead Code Detection
What it measures: Identifies files that haven't been modified in a long time relative to the rest of the codebase. A file untouched for 18 months in an active repo is likely dead weight.
Why it matters: Dead code increases onboarding time, confuses new developers, and inflates metrics. Cleaning it up is the easiest, lowest-risk way to improve your codebase health.
What the report shows: A dead code ratio (0–1) and a count of candidate files. The report distinguishes truly dead files from stable utility code that rarely needs changes.
Velocity Trend
What it measures: Classifies recent commits into feature work, bug fixes, and refactoring based on commit message patterns. Then measures the ratio over time.
Why it matters: A healthy team spends most of its time on features. When bug fixes dominate, the team is firefighting instead of building. This is the clearest signal that debt is costing real velocity.
What the report shows: A velocity profile breakdown (% feature / % bugfix / % refactoring) and a trend indicator — is the balance improving or deteriorating month over month?
Merge Discipline
What it measures: Analyzes merge commits to detect self-merges (author == merger), reviewer diversity, and average PR size. Uses git log --merges — 100% offline, no GitHub API required.
Why it matters: Code merged without review carries higher defect risk and creates knowledge silos. Two repos with identical DebtLens scores can have radically different quality cultures — this scan reveals the difference.
What the report shows: A discipline signal (exemplary / adequate / weak / solo) and a self-merge ratio. High self-merge ratio + low reviewer diversity = weak discipline, high risk.
A report your CFO actually reads
Not a developer dashboard. A structured executive report with costs, trends, and prioritized recommendations.
Report preview — screenshot coming soon
0–100
Health score
€/dev/day
Cost per developer
Top 5
Prioritized actions
Your code never leaves your machine
Code stays local
Analysis runs on your machine. Only aggregated scores are sent.
Read-only
We analyze git history. We never modify your repository.
No AI training
Your data is never used to train models.
GDPR compliant
EU-based infrastructure. Full data transparency.
Start with a free local analysis
No account needed. Download the CLI, point it at a repo, see the results.
Download the CLI