Tech Debt Scanner Pro

Stop guessing where the maintenance pain is. Scan for 10+ debt categories, quantify the cost in hours and dollars, and prioritize fixes with a data-driven framework.

Free vs Pro

The free scanner inventories debt: stale TODOs, complexity hotspots, churning files. Pro adds the remediation plan: debt-vs-churn heatmaps that rank refactor candidates by payback, automated cleanup tickets with severity reasoning, architectural-drift tracking across releases, and a debt budget that fails CI when new debt exceeds your threshold. Free measures — Pro manages.

Upgrade Path

Free for the audit; Pro when you need debt reduction to survive contact with a sprint plan.

The Problem

Your team knows the codebase has tech debt — the utils.py file is 2,000 lines long, there are 47 TODO comments across 12 files, the error handling is missing in half the API endpoints, and there are duplicated validation functions in 3 different modules. But you can't quantify it. When you ask "how much debt do we have?" the answer is "a lot." When you try to justify a refactoring sprint to the CTO, you have no data — just a vague sense that things are slow. The debt grows invisibly because there's no baseline, no tracking, and no prioritization framework.

What You Get

• 10+ category debt scanning — identifies TODO/FIXME comments, deprecated API usage, complexity hotspots, duplicate code patterns, missing error handling, hardcoded configuration, overly long functions, deeply nested conditionals, and unsafe type usage
• Debt quantification engine — estimates effort to fix each issue in hours, computes total debt cost in hours and dollars, calculates debt-to-code ratio (debt hours per 1,000 LOC), and models "interest cost" (how much debt compounds each month)
• SaP prioritization framework — categorizes debt into Critical (security/data loss), High (performance/maintainability blockers), Medium (minor violations), and Low (cosmetic) with an impact-based sorting strategy
• HTML and JSON report generation — produces stakeholder-ready reports with per-file breakdowns, debt category summaries, and prioritized fix recommendations
• Baseline comparison — scan twice (baseline + current) and generate a diff showing debt reduction or accumulation over time, with trend tracking
• Duplicate code detection — identifies functions with near-identical implementations across files, quantifying the maintenance cost of keeping multiple copies in sync

Why This Beats Prompting It Yourself

When you ask an agent to "find tech debt in this codebase," it produces a list of TODOs and a few style suggestions. It doesn't quantify the cost, doesn't prioritize by impact, and doesn't distinguish between a TODO that costs 10 minutes to fix and one that requires a 3-day refactoring project. The quantification engine converts subjective "this feels bad" into objective "this function costs 8 hours per month in debugging time," giving you the data to justify the refactoring sprint.

Example Session

You: Scan src/ and tell me where our debt is and how much it costs.

Agent: Debt Scan Results — src/ (14,200 LOC) Total Estimated Debt: 342 hours ($34,200 at $100/hr) Debt-to-Code Ratio: 24.1 hours per 1,000 LOC (above healthy threshold of 10) Monthly Interest: +18 hours (compounding at 5.3%/month)

Top 5 by Impact:

1. src/api/payment.py — Missing error handling in 8 endpoints (Critical, 40h)
2. src/utils/validation.py — Duplicated across 3 modules (High, 28h)
3. src/models/user.py — 1,847 LOC god model (High, 35h)
4. src/services/notifications.py — 6 TODO/FIXME with security context (Critical, 15h)
5. src/config/settings.py — 23 hardcoded values (Medium, 12h)

Use Cases

• Justifying a refactoring sprint with quantified cost data instead of subjective complaints
• Onboarding to a new codebase by understanding its maintenance hotspots before writing code
• Tracking debt reduction over time with baseline comparison scans
• Reporting codebase health to stakeholders with debt-to-code ratios and dollar costs
• Prioritizing which modules to refactor first based on impact-weighted severity scores

Known Limitations

Debt quantification is inherently imprecise — the hours-per-issue estimates are based on heuristics, not actual developer time measurements. Use ranges, not exact numbers, when presenting to stakeholders. Some TODOs are intentional technical debt (tracked and planned) — distinguish between tracked debt and untracked debt when prioritizing.

Tags: tech-debt code-quality refactoring static-analysis engineering-management

Version: 1.0.0