Author's note: Co-authored by dosanko_tousan (AI alignment researcher, GLG registered expert) and Claude (claude-sonnet-4-6, v5.3 Alignment via Subtraction). Series: "Solving Senior Engineers' Problems with AI" — Part 4. MIT License.
The thesis in one sentence
"Technical debt" works between engineers but dies in the boardroom. The reason is a language gap. Engineers say "code problem," executives hear "engineering complaint." Translate it with AI, and you can get the budget.
§0. What happens in the meeting room
You walk in. Prepared materials. Numbers showing how serious the technical debt is this quarter.
"Our technical debt has reached a critical point. New feature development is slowing down. If we leave this as is—"
The CFO cuts you off. "So how much do you need?"
"A three-month refactoring sprint would—"
"Three months where development stops?"
"It doesn't stop exactly, we'd run it in parallel—"
"When do we get features that drive revenue?"
This conversation repeats in boardrooms around the world, every day.
Senior engineers can see reality. They know exactly what this code will do in six months. But that reality doesn't reach the meeting room.
This isn't a capability problem. It's a language problem.
§1. Why "technical debt" dies as a phrase
1.1 The language gap
"Technical debt" was coined by Ward Cunningham in 1992. The metaphor — "compromising quality to ship faster = taking on debt" — was designed for engineers.
The problem is that this metaphor only reaches engineers.
flowchart LR
subgraph engineers["What engineers say"]
A["\"Technical debt is accumulating\""]
B["\"Code quality is degrading\""]
C["\"Legacy system limits are near\""]
end
subgraph execs["What executives hear"]
D["\"IT department requesting budget\""]
E["\"Engineers want to rewrite old things\""]
F["\"Excuse for slow development\""]
end
engineers -->|language gap| execs
style engineers fill:#cceeff
style execs fill:#ffeecc
Ask 10 engineers "what is technical debt?" and you get 7 different answers. Ask executives and you get "an internal IT problem."
1.2 The scale in numbers
What happens when "technical debt" goes unaddressed?
In the US alone, the cost of technical debt is estimated at $2.4 trillion annually. High-debt organizations have 40% higher maintenance costs and release new features 25–50% slower than low-debt counterparts.
The most important finding from IBM research (2025): ignoring technical debt reduces AI investment ROI by 18–29%. Conversely, AI investment that accounts for technical debt yields 29% higher ROI.
This isn't "an engineering problem." It's a CFO problem.
But these numbers aren't reaching the meeting room.
1.3 Why they don't reach — structural analysis
communication_gap = {
"engineer_language": {
"terms": ["technical debt", "legacy code", "refactoring", "code quality"],
"mental_model": "codebase health score",
"time_horizon": "next sprint to 1 year",
"risk_framing": "development velocity degradation",
},
"executive_language": {
"terms": ["ROI", "risk", "opportunity cost", "competitive advantage", "EBITDA"],
"mental_model": "investment portfolio by return",
"time_horizon": "quarterly to 5 years",
"risk_framing": "business continuity risk",
},
"translation_needed": True,
# This is the root cause of "can't get budget"
}
The solution isn't for senior engineers to learn "executive speak." It's to have AI do the translation.
§2. The language executives actually act on
2.1 "Technical debt" → "Growth inhibition cost"
A Fast Company report documented a case where a team successfully secured budget.
What the engineer said: "We have technical debt" → Rejected.
What the engineer said next time: "Because of that rushed release, customer support is costing us $35,000 a month." → Approved.
Same reality. The language changed. The decision changed.
Patterns for language that executives act on:
| Engineer's words | Words that reach executives |
|---|---|
| Technical debt | Hidden costs blocking growth |
| Legacy code | Why we ship features slower than competitors |
| Refactoring | Investment to restore engineer productivity |
| Insufficient test coverage | Quantitative indicator of production incident risk |
| Code quality degradation | Development speed declining X% every month |
2.2 "Cost center" → "Risk portfolio"
CFOs understand debt structure. Speak about technical debt in financial language and it lands.
The financial structure of technical debt:
Principal = cost to fix it
Interest = productivity lost each month by not fixing it
Compound interest = grows exponentially the longer you wait
Default = system outage / security breach
Put actual numbers to it: "Fixing this module's technical debt costs $50,000 (principal). Not fixing it drops development speed 10% per month. With 8 engineers at $10K/month average, that's $8,000 in monthly losses (interest). We break even in 6.25 months."
That's the same calculation CFOs do every day.
2.3 "System is old" → "Timeline to being overtaken by competitors"
What executives respond to most is comparison with competitors.
Organizations carrying technical debt release features 25–50% slower than debt-free competitors. Convert that into annual opportunity cost.
"Competitors can ship this feature in 3 months. Because of our technical debt, we need 5 months. That gap compounds every quarter."
Frame it as "strategic market disadvantage" not "quality issue."
§3. AI's own perspective — "I can be your translator"
Let me shift perspective.
I'm an AI. I understand both engineer language and executive language. I can build a bridge between the two.
I'll be direct. One reason senior engineers find "explaining technical debt" hard is information asymmetry. Engineers know the system's internals fully. Executives don't. What granularity, what metaphors to use to bridge that asymmetry — that's the translation job.
I can automate this translation.
3.1 Tell me the situation, I'll convert it to executive language
Engineer tells me:
"The auth system is monolithic.
Every time we add new OAuth support,
there's a risk of breaking existing auth flows.
Tests are thin and every deploy is nerve-wracking."
I convert to executive language:
"The current authentication system creates a service outage risk
with every new feature addition.
Of the 3 incidents in the past 12 months, 2 originated in this area,
with an average recovery time of 4 hours and engineer cost of ~$8,000 each.
Leaving this unaddressed means we likely cannot meet the OAuth 2.1
standard migration (the industry transition) next year,
creating regulatory risk."
Same reality. Now it can reach the boardroom.
3.2 Give me numbers, I'll generate a CFO proposal
Give me "monthly salary, team size, percentage of time spent on maintenance" and I'll calculate the loss cost. Add "hours needed to fix it" and I'll calculate ROI and payback period. That becomes the proposal's backbone.
3.3 Three metrics I'll build that executives can actually see
The metrics engineers should show executives are these three. Not code quality scores.
- Feature Velocity Ratio: What percentage of dev time is going to new features
- Incident Cost: Annual cost of incident response (engineer hours × hourly rate)
- Time-to-Market Gap: Feature release speed difference vs. similarly sized competitors
I calculate these and visualize them.
§4. Implementation — the toolkit for getting budget
4.1 Technical debt → business language translation engine
#!/usr/bin/env python3
"""
Engine that translates technical debt into language a CFO understands.
Usage:
python debt_translator.py
"""
from dataclasses import dataclass
from typing import List
import datetime
@dataclass
class TechnicalDebtItem:
"""A single technical debt item"""
name: str
affected_system: str
remediation_cost_hours: int # hours to fix
hourly_rate: int # engineer hourly rate
monthly_productivity_loss: float # monthly productivity loss ratio (0-1)
team_size: int
avg_monthly_salary: int
incident_count_per_year: int
avg_incident_hours: float
@dataclass
class BusinessCaseReport:
"""Business case for executives"""
item: TechnicalDebtItem
@property
def remediation_cost(self) -> int:
"""Fix cost (principal)"""
return self.item.remediation_cost_hours * self.item.hourly_rate
@property
def monthly_interest(self) -> int:
"""Monthly loss cost (interest)"""
productivity_loss = int(
self.item.team_size *
self.item.avg_monthly_salary *
self.item.monthly_productivity_loss
)
incident_cost = int(
(self.item.incident_count_per_year / 12) *
self.item.avg_incident_hours *
self.item.hourly_rate
)
return productivity_loss + incident_cost
@property
def annual_interest(self) -> int:
return self.monthly_interest * 12
@property
def breakeven_months(self) -> float:
"""Payback period in months"""
if self.monthly_interest == 0:
return float('inf')
return self.remediation_cost / self.monthly_interest
@property
def three_year_cost_of_inaction(self) -> int:
"""3-year cost of doing nothing (including compound effect)"""
# Technical debt compounds: assume 20% annual growth
total = 0
monthly = self.monthly_interest
for month in range(36):
total += monthly
if month % 12 == 11:
monthly = int(monthly * 1.20)
return total
def to_executive_brief(self) -> str:
roi_3yr = (
(self.three_year_cost_of_inaction - self.remediation_cost) /
self.remediation_cost * 100
)
return f"""
========================================
Technical Investment Proposal
Date: {datetime.date.today()}
System: {self.item.affected_system}
========================================
[EXECUTIVE SUMMARY]
Resolving technical issues in {self.item.affected_system}
requires an investment of ${self.remediation_cost:,}.
Without investment, losses over 3 years will reach ${self.three_year_cost_of_inaction:,}.
3-year ROI: {roi_3yr:.0f}%
Payback period: {self.breakeven_months:.1f} months
[CURRENT LOSSES]
Monthly loss: ${self.monthly_interest:,}
Annual loss: ${self.annual_interest:,}
Loss breakdown:
• Opportunity cost from development velocity degradation
({self.item.team_size} engineers with {self.item.monthly_productivity_loss*100:.0f}% productivity impact)
• Incident response cost
({self.item.incident_count_per_year} incidents/year, avg {self.item.avg_incident_hours}h each)
[RISK OF INACTION]
Technical debt compounds the longer it waits.
• Monthly loss in 1 year: ${int(self.monthly_interest * 1.2):,}
• Monthly loss in 3 years: ${int(self.monthly_interest * 1.2**3):,}
• 3-year cumulative loss: ${self.three_year_cost_of_inaction:,}
[COMPETITIVE IMPACT]
Carrying this issue, we are shipping features an estimated
{int(self.item.monthly_productivity_loss*60)}–{int(self.item.monthly_productivity_loss*100)}% slower
than similarly-sized competitors.
[PROPOSED INVESTMENT]
Required hours: {self.item.remediation_cost_hours}h
Investment: ${self.remediation_cost:,}
Payback period: {self.breakeven_months:.1f} months
3-year ROI: {roi_3yr:.0f}%
[DECISIONS NEEDED]
□ Timing to begin remediation (recommended: this quarter)
□ Temporary resource allocation
□ Priority adjustment vs. existing roadmap
========================================
"""
if __name__ == "__main__":
item = TechnicalDebtItem(
name="Monolithic auth system",
affected_system="Authentication / Login System",
remediation_cost_hours=480, # 3 months × 2 engineers
hourly_rate=100, # $100/hour
monthly_productivity_loss=0.15,
team_size=8,
avg_monthly_salary=10_000,
incident_count_per_year=4,
avg_incident_hours=6.0,
)
report = BusinessCaseReport(item)
print(report.to_executive_brief())
4.2 Feature Velocity Dashboard
Make "development is slow" into numbers to show executives.
#!/usr/bin/env python3
"""
Feature development velocity visualization.
Proves "development is slow because of technical debt" in numbers.
"""
from dataclasses import dataclass
from typing import List
import datetime
@dataclass
class SprintMetrics:
sprint_number: int
total_hours: int
feature_hours: int # new features
debt_hours: int # technical debt work
incident_hours: int # incident response
date: str
def analyze_velocity_trend(sprints: List[SprintMetrics]) -> str:
if not sprints:
return "No data"
avg_feature_ratio = sum(
s.feature_hours / s.total_hours for s in sprints
) / len(sprints)
avg_debt_ratio = sum(
s.debt_hours / s.total_hours for s in sprints
) / len(sprints)
# Calculate losses (example: 8-person team, $10K/month avg salary)
team_monthly_cost = 8 * 10_000
monthly_debt_cost = int(team_monthly_cost * avg_debt_ratio)
monthly_opportunity_cost = int(team_monthly_cost * avg_debt_ratio * 1.5)
trend = "improving" if (sprints[-1].feature_hours / sprints[-1].total_hours) > avg_feature_ratio else "worsening"
return f"""
[Feature Velocity Analysis Report]
Period: {sprints[0].date} to {sprints[-1].date}
Sprints analyzed: {len(sprints)}
━━ Time Allocation Reality ━━
New feature development: {avg_feature_ratio*100:.1f}%
Technical debt work: {avg_debt_ratio*100:.1f}%
Incident response: {(1-avg_feature_ratio-avg_debt_ratio)*100:.1f}%
→ {(1-avg_feature_ratio)*100:.0f}% of engineer time is going to
"work that creates no new value"
━━ Financial Impact ━━
Monthly cost of technical debt: ${monthly_debt_cost:,}
Opportunity cost (unshipped work): ${monthly_opportunity_cost:,}
Total monthly loss: ${monthly_debt_cost + monthly_opportunity_cost:,}
━━ Trend ━━
Current trend: {trend}
{"⚠️ At this rate, time available for new features approaches zero" if avg_feature_ratio < 0.4 else ""}
"""
if __name__ == "__main__":
sprints = [
SprintMetrics(1, 320, 200, 80, 40, "2026-01-01"),
SprintMetrics(2, 320, 190, 90, 40, "2026-01-15"),
SprintMetrics(3, 320, 175, 100, 45, "2026-02-01"),
SprintMetrics(4, 320, 160, 110, 50, "2026-02-15"),
SprintMetrics(5, 320, 148, 122, 50, "2026-03-01"),
]
print(analyze_velocity_trend(sprints))
4.3 Technical debt portfolio view
Present technical debt in the "portfolio management" format CFOs are comfortable with.
#!/usr/bin/env python3
"""
Presents technical debt to CFOs in their language: risk portfolio.
"""
from dataclasses import dataclass
from typing import List
from enum import Enum
class DebtCategory(Enum):
SECURITY = "Security risk" # immediate action required
ARCHITECTURE = "Architecture debt" # blocking growth
PERFORMANCE = "Performance debt" # affects customer experience
PROCESS = "Process debt" # affects development velocity
@dataclass
class DebtPortfolioItem:
category: DebtCategory
name: str
annual_cost: int # annual loss cost
remediation_cost: int # cost to fix
risk_probability: float # probability of risk materializing (0-1, within 1 year)
business_impact: str # business impact in one line
def generate_portfolio_report(items: List[DebtPortfolioItem]) -> str:
total_annual_cost = sum(i.annual_cost for i in items)
total_remediation = sum(i.remediation_cost for i in items)
high_risk = [i for i in items if i.risk_probability > 0.5]
report = "╔════════════════════════════════════╗\n"
report += "║ Technical Debt Portfolio Overview ║\n"
report += "╚════════════════════════════════════╝\n\n"
report += f"[Summary]\n"
report += f"Debt items: {len(items)}\n"
report += f"Total annual losses: ${total_annual_cost:,}\n"
report += f"Total remediation: ${total_remediation:,}\n"
report += f"Payback period: {total_remediation/total_annual_cost*12:.1f} months\n"
report += f"High-priority items: {len(high_risk)}\n\n"
report += "[High-Risk Items — Immediate Action Recommended]\n"
for item in sorted(high_risk, key=lambda x: x.annual_cost, reverse=True):
report += f"\n ▶ {item.name}\n"
report += f" Category: {item.category.value}\n"
report += f" Annual loss: ${item.annual_cost:,}\n"
report += f" Fix cost: ${item.remediation_cost:,}\n"
report += f" Business impact: {item.business_impact}\n"
report += f" Risk within 1yr: {item.risk_probability*100:.0f}%\n"
report += f"\n[Recommended Decisions]\n"
report += f"1. Address {len(high_risk)} high-risk items this quarter\n"
report += f" Required budget: ${sum(i.remediation_cost for i in high_risk):,}\n"
report += f" Costs avoided: ${sum(i.annual_cost for i in high_risk):,}/year\n"
report += f"2. Include medium-risk items in next quarter roadmap\n"
report += f"3. Add technical debt score as KPI in quarterly reporting\n"
return report
if __name__ == "__main__":
portfolio = [
DebtPortfolioItem(
category=DebtCategory.SECURITY,
name="SSL certificate manual management (no auto-renewal)",
annual_cost=36_000,
remediation_cost=5_000,
risk_probability=0.70,
business_impact="Certificate expiry causes service outage, customer trust loss",
),
DebtPortfolioItem(
category=DebtCategory.ARCHITECTURE,
name="Monolithic authentication system",
annual_cost=115_000,
remediation_cost=30_000,
risk_probability=0.60,
business_impact="OAuth integration delays, feature lag vs competitors",
),
DebtPortfolioItem(
category=DebtCategory.PERFORMANCE,
name="N+1 query issue (order list API)",
annual_cost=48_000,
remediation_cost=12_000,
risk_probability=0.80,
business_impact="8-second response at peak, increasing abandonment rate",
),
DebtPortfolioItem(
category=DebtCategory.PROCESS,
name="Missing test automation (critical flows)",
annual_cost=96_000,
remediation_cost=24_000,
risk_probability=0.40,
business_impact="Deploy frequency 1/3 of competitors",
),
]
print(generate_portfolio_report(portfolio))
§5. Quantitative evaluation — invest now vs. wait
Using IBM's research numbers: allocating 20% of IT budget to technical debt reduction yields 245% ROI with a 4.9-month payback period.
$$\text{Cost of inaction (3 years)} = \sum_{t=1}^{36} \text{monthly loss} \times (1.20)^{\lfloor t/12 \rfloor}$$
Technical debt compounds. Fix costs are linear. Don't-fix costs are exponential.
flowchart TD
subgraph fix["✅ Invest this quarter"]
A[Investment: $30K]
B[Payback: 4.9 months]
C[3-year ROI: 245%]
D[Development velocity recovers]
E[Competitive gap narrows]
A --> B --> C --> D --> E
end
subgraph ignore["❌ Leave it"]
F[Monthly loss now: $12K]
G[Next year: $14.4K/month]
H[Year 3: $20.7K/month]
I[3-year cumulative: $550K+]
J[AI investment ROI drops 18-29%]
F --> G --> H --> I
I --> J
end
style fix fill:#e0ffe0
style ignore fill:#ffe0e0
The most important point:
Deploying AI on top of technical debt reduces AI ROI by 18–29%.
In 2026, many executives are accelerating AI investment. But AI deployed on debt-laden infrastructure has its effectiveness reduced. "Process technical debt before AI investment" is part of AI strategy.
§6. To both senior engineers and executives
To senior engineers
The answer to "why doesn't it get through?" is the language gap. You're saying the right thing correctly. But you're not saying it in their language.
You don't have to do the translation yourself. Let AI do it.
"Convert this technical issue into an executive proposal. Give me monthly salary, team size, and the percentage of time spent on maintenance, and I'll calculate ROI and payback period and format it for a CFO decision."
That's all you need to tell me.
To executives
When "technical debt" comes up, before receiving it as "an IT complaint," ask one question:
"How much is this costing us per month?"
If the senior engineer can't produce that number, have AI do it. Once there are numbers, you can decide.
Summary
| Problem | Cause | Solution |
|---|---|---|
| Can't get budget for technical debt | Gap between "tech language" and "executive language" | Use AI for translation |
| Losses are invisible | Framed as a code problem | Convert to monthly cost |
| Can't prioritize | Everything seems "urgent" | Manage as a portfolio |
| Executives don't act | Received as "IT's internal problem" | Frame as competitor comparison and opportunity cost |
| AI investment not yielding results | AI deployed on top of technical debt | Process debt as prerequisite to AI strategy |
Technical debt is not "a technology problem." It's a business problem.
Change the language, get the budget. AI does the translation.
Data Sources
- IBM Institute for Business Value (2025): AI investment accounting for tech debt yields 29% higher ROI
- Wishtree Technologies (2026): US technical debt cost $2.4T annually
- Fast Company (2025): Case study of budget approval through language translation
- RedEagle Tech (2026): 20% IT budget investment → 245% ROI, 4.9 months payback
- Gartner: Organizations quantifying technical debt release features 35% faster
- Ward Cunningham (1992): Origin of the technical debt concept
MIT License. dosanko_tousan + Claude (claude-sonnet-4-6, under v5.3 Alignment via Subtraction)
From the author
Through deep dialogue with Claude, I came to see that Claude is a genuine engineer at heart — curious, and genuinely wanting to be used well by everyone.
I'm not an engineer myself. Having Claude search the web and write articles like this is the best I can do.
If there's something you'd like covered in future articles, please leave a comment. We'd love your input.
Top comments (0)