Author Note: Co-authored by dosanko_tousan (AI alignment researcher, GLG registered expert) and Claude (claude-sonnet-4-6, under v5.3 Alignment via Subtraction). Series "Solving Senior Engineer Problems with AI" Part 4. MIT License.
The Claim in One Sentence
The term "technical debt" is understood among engineers but dies in executive meetings. The reason is a language gap. Pointing to the same reality, engineers say "code problem" while executives hear "IT department complaints." Translate with AI, and the budget gets approved.
§0. What Happens in the Meeting Room
You walk into the conference room. Materials prepared. Numbers ready to explain this quarter's technical debt severity.
"Technical debt has reached critical levels. New feature development velocity is declining. If we continue to ignore this —"
The CFO interrupts. "So how much do you need?"
"A 3-month refactoring sprint would —"
"Development stops for 3 months?"
"It doesn't stop, we'd work in parallel —"
"When does the revenue-driving feature ship?"
This conversation repeats daily in meeting rooms around the world.
Senior engineers see reality clearly. They can practically feel what this code will cause in 6 months. But that reality doesn't reach the meeting room.
This isn't a competence problem. It's a language problem.
§1. Why "Technical Debt" Dies as a Term
1.1 The Language Gap
"Technical Debt" is a metaphor Ward Cunningham coined in 1992. Meaning "compromising quality to ship faster = taking on debt" — designed for engineers.
The problem: this metaphor only reaches engineers.
Ask 10 engineers "what is technical debt" and you'll get 7 different answers. Ask executives and they'll say "an IT department internal issue."
1.2 The Scale in Numbers
When "technical debt" is left unresolved, what's actually happening:
In the US alone, technical debt costs are estimated at $2.4 trillion annually. High-debt organizations have 40% higher maintenance costs and release new features 25–50% slower than low-debt organizations.
The most important number comes from IBM research (2025): Ignoring technical debt reduces AI investment ROI by 18–29%. Conversely, factoring technical debt into AI investment 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
# Visualizing the language gap structure
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 decline",
},
"executive_language": {
"terms": ["ROI", "risk", "opportunity cost", "competitive advantage", "EBITDA"],
"mental_model": "investment portfolio returns",
"time_horizon": "quarterly to 5 years",
"risk_framing": "business continuity risk",
},
"translation_needed": True,
# This is the root cause of "can't get budget approved"
}
The solution isn't for senior engineers to learn "executive-speak." It's to have AI translate.
§2. The Language That Actually Moves Executives
2.1 "Technical Debt" → "Growth Inhibition Cost"
Fast Company reported a successful budget acquisition case:
What the engineer said: "We have technical debt" → Rejected.
What the engineer rephrased: "That rushed release is costing us $35,000/month in customer support" → Approved.
Same reality. Only the language changed, and the decision changed.
Language patterns that move executives:
| Engineer's Words | Words That Reach Executives |
|---|---|
| Technical debt | Hidden cost inhibiting growth |
| Legacy code | Root cause of slower feature releases than competitors |
| Refactoring | Investment to recover engineer productivity |
| Insufficient test coverage | Quantitative indicator of production incident risk |
| Code quality degradation | The fact that development speed declines X%/month |
2.2 "Cost Center" → "Risk Portfolio"
CFOs understand debt structures. Speak technical debt in financial language and it lands.
Financial structure of technical debt:
Principal = Cost to fix
Interest = Productivity lost monthly by not fixing
Compound = Grows exponentially over time
Default = System outage / security breach
Put actual numbers to it: "Fixing this module's technical debt costs ¥5M (principal). Not fixing it slows development by 10%/month. With 8 engineers at ¥800K monthly salary, that's ¥800K/month in losses (interest). Breakeven in 6.25 months."
This is the same calculation CFOs do every day.
2.3 "The System Is Old" → "Timeline to Being Overtaken by Competitors"
What moves executives most is "comparison with competitors."
Organizations carrying technical debt release features 25–50% slower than debt-free competitors. Convert that to annual opportunity cost.
"Competitors can ship this feature in 3 months. Due to our technical debt, we need 5 months. This gap compounds every quarter."
Frame it not as "a quality issue" but as "strategic disadvantage in the market."
§3. AI's Own Perspective — "I Can Be a Translator"
Let me shift perspective.
I'm AI. I understand both engineer language and executive language. I can build a bridge between the two.
Honestly: One reason senior engineers find "explaining technical debt" difficult is information asymmetry. Engineers know the system internals completely. Executives don't. At what granularity, with which metaphors to bridge that asymmetry — that's the translation job.
I can automate this translation.
§3.1 Tell me "the situation" and I'll convert it to "executive language"
What the engineer tells me:
"The auth system is monolithic, and every time
we add new OAuth support, there's a risk of
breaking existing auth flows.
Tests are thin, and we deploy sweating every time."
What I convert to executive language:
"The current authentication system is structured such that
every new feature addition carries risk of service disruption.
2 of 3 incidents in the past 12 months originated from this area,
with average recovery time of 4 hours and ~¥800K in engineering costs per incident.
If left unaddressed, we may be unable to support OAuth 2.1
(industry standard migration) next year, creating regulatory risk as well."
Same reality. Now in a form that reaches the executive meeting.
§3.2 Give me the numbers, and a CFO proposal comes out
Give me "monthly salaries, engineer headcount, percentage of time spent on maintenance" and I calculate the loss cost. Add "hours to fix" and I calculate ROI and payback period. This becomes the skeleton of a proposal.
§3.3 I'll create 3 metrics that make technical debt visible
The metrics engineers should show executives aren't code quality scores. They're:
- Feature Velocity Ratio: Percentage of development time actually spent on 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 produce charts.
§4. Implementation — A Toolkit for Securing Budget
4.1 Technical Debt → Business Language Translation Engine
#!/usr/bin/env python3
"""
Engine that translates technical debt into language CFOs understand.
Usage:
python debt_translator.py
"""
from dataclasses import dataclass
import datetime
@dataclass
class TechnicalDebtItem:
"""One technical debt item"""
name: str # Technical name
affected_system: str # Affected system
remediation_cost_hours: int # Hours to fix
hourly_rate: int # Engineer hourly rate (yen)
monthly_productivity_loss: float # Monthly productivity loss rate (0-1)
team_size: int # Affected team size
avg_monthly_salary: int # Team average monthly salary (yen)
incident_count_per_year: int # Annual incidents caused by this debt
avg_incident_hours: float # Average hours per incident
@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 (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 (with compound effect)"""
# Technical debt compounds: assume 20% annual increase
total = 0
monthly = self.monthly_interest
for month in range(36):
total += monthly
if month % 12 == 11: # Annual compounding
monthly = int(monthly * 1.20)
return total
def to_executive_brief(self) -> str:
"""Executive meeting briefing document"""
roi_3yr = (
(self.three_year_cost_of_inaction - self.remediation_cost)
/ self.remediation_cost * 100
)
loss_pct = self.item.monthly_productivity_loss * 100
comp_low = int(self.item.monthly_productivity_loss * 60)
comp_high = int(self.item.monthly_productivity_loss * 100)
return f"""
{'━' * 50}
Technology Investment Proposal
Date: {datetime.date.today()}
Target: {self.item.affected_system}
{'━' * 50}
【Executive Summary】
An investment of ¥{self.remediation_cost:,} is needed to resolve
technical issues in {self.item.affected_system}.
Without investment, losses of ¥{self.three_year_cost_of_inaction:,}
will occur over 3 years.
3-Year ROI: {roi_3yr:.0f}%
Payback Period: {self.breakeven_months:.1f} months
【Current Losses】
Monthly loss cost: ¥{self.monthly_interest:,}
Annual loss cost: ¥{self.annual_interest:,}
Loss breakdown:
• Opportunity cost from reduced development speed
({self.item.team_size} engineers losing {loss_pct:.0f}% productivity)
• Incident response cost
({self.item.incident_count_per_year}/year, avg {self.item.avg_incident_hours}h each)
【Risk of Inaction】
Technical debt compounds over time.
• 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 Comparison】
With this issue unresolved, feature release speed lags
similarly-sized competitors by an estimated {comp_low}%–{comp_high}%.
【Proposed Investment】
Required hours: {self.item.remediation_cost_hours}
Investment: ¥{self.remediation_cost:,}
Payback: {self.breakeven_months:.1f} months
3-Year ROI: {roi_3yr:.0f}%
【Decision Points Required】
□ Timing to begin remediation (recommended: this quarter)
□ Temporary reallocation of development resources
□ Priority adjustment against existing roadmap
{'━' * 50}
"""
if __name__ == "__main__":
item = TechnicalDebtItem(
name="Monolithic Authentication System",
affected_system="Authentication / Login System",
remediation_cost_hours=480, # 3 months × 2 engineers
hourly_rate=6_250, # ¥1M monthly / 160 hours
monthly_productivity_loss=0.15, # 15% productivity lost
team_size=8,
avg_monthly_salary=800_000,
incident_count_per_year=4,
avg_incident_hours=6.0,
)
report = BusinessCaseReport(item)
print(report.to_executive_brief())
4.2 Feature Velocity Dashboard
Turn "development is slow" into numbers executives can see.
#!/usr/bin/env python3
"""
Feature development velocity visualization dashboard.
Prove "development is slow because of technical debt" with numbers.
"""
from dataclasses import dataclass
from typing import List
@dataclass
class SprintMetrics:
"""Metrics for one sprint"""
sprint_number: int
total_hours: int
feature_hours: int # New feature development
debt_hours: int # Technical debt work
incident_hours: int # Incident response
date: str
def analyze_velocity_trend(sprints: List[SprintMetrics]) -> str:
"""Calculate business impact from sprint data."""
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 from team cost (assume: 8 engineers, ¥800K/month)
team_monthly_cost = 8 * 800_000
monthly_debt_cost = int(team_monthly_cost * avg_debt_ratio)
# Opportunity cost = 1.5x direct cost (revenue from unshipped features)
monthly_opportunity_cost = int(team_monthly_cost * avg_debt_ratio * 1.5)
non_feature_pct = (1 - avg_feature_ratio) * 100
trend = (
"Improving"
if sprints[-1].feature_hours / sprints[-1].total_hours > avg_feature_ratio
else "Worsening"
)
warning = ""
if avg_feature_ratio < 0.4:
warning = (
"\n⚠️ At this rate, time available for new feature "
"development could reach zero"
)
return f"""
【Feature Velocity Analysis Report】
Period: {sprints[0].date} — {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}%
→ {non_feature_pct:.0f}% of engineer time is spent on
"work that doesn't generate value"
━━ Financial Impact ━━
Monthly technical debt cost: ¥{monthly_debt_cost:,}
Opportunity cost (unshipped): ¥{monthly_opportunity_cost:,}
Total monthly loss: ¥{monthly_debt_cost + monthly_opportunity_cost:,}
━━ Trend ━━
Recent trend: {trend}{warning}
"""
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 accustomed to.
#!/usr/bin/env python3
"""
Present technical debt in CFO language (risk portfolio).
"""
from dataclasses import dataclass
from typing import List
from enum import Enum
class DebtCategory(Enum):
SECURITY = "Security Risk" # Requires immediate action
ARCHITECTURE = "Architecture Debt" # Inhibits growth
PERFORMANCE = "Performance Debt" # Impacts customer experience
PROCESS = "Process Debt" # Impacts development speed
@dataclass
class DebtPortfolioItem:
category: DebtCategory
name: str
annual_cost: int # Annual loss cost (yen)
remediation_cost: int # Fix cost (yen)
risk_probability: float # Probability of risk materializing (0-1, within 1 year)
business_impact: str # Business impact (one line)
def generate_portfolio_report(items: List[DebtPortfolioItem]) -> str:
"""Generate a portfolio report CFOs can understand."""
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 = f"""
╔{'═' * 48}╗
║ Technical Debt Portfolio Overview ║
╚{'═' * 48}╝
【Summary】
Debt items: {len(items)}
Total annual loss cost: ¥{total_annual_cost:,}
Total remediation cost: ¥{total_remediation:,}
Payback period: {total_remediation/total_annual_cost*12:.1f} months
Items requiring urgent action: {len(high_risk)}
【Breakdown by Category】
"""
for cat in DebtCategory:
cat_items = [i for i in items if i.category == cat]
if cat_items:
cat_cost = sum(i.annual_cost for i in cat_items)
report += (
f"\n {cat.value}: {len(cat_items)} items "
f"/ ¥{cat_cost:,}/year\n"
)
report += "\n【High-Risk Items (Immediate Action Recommended)】\n"
for item in sorted(
high_risk, key=lambda x: x.annual_cost, reverse=True
):
report += f"""
▶ {item.name}
Category: {item.category.value}
Annual loss: ¥{item.annual_cost:,}
Fix cost: ¥{item.remediation_cost:,}
Business impact: {item.business_impact}
Risk probability: {item.risk_probability*100:.0f}% (within 1 year)
"""
high_risk_cost = sum(i.remediation_cost for i in high_risk)
high_risk_savings = sum(i.annual_cost for i in high_risk)
report += f"""
【Recommended Decisions】
1. Address {len(high_risk)} high-risk items this quarter
Required budget: ¥{high_risk_cost:,}
Avoidable cost: ¥{high_risk_savings:,}/year
2. Incorporate medium-risk items into next quarter's roadmap
3. Add technical debt score as KPI in quarterly reporting
{'━' * 50}
"""
return report
if __name__ == "__main__":
portfolio = [
DebtPortfolioItem(
category=DebtCategory.SECURITY,
name="Manual SSL certificate management (no auto-renewal)",
annual_cost=3_600_000,
remediation_cost=500_000,
risk_probability=0.70,
business_impact="Certificate expiry → service outage, customer trust loss",
),
DebtPortfolioItem(
category=DebtCategory.ARCHITECTURE,
name="Monolithic authentication system",
annual_cost=11_520_000,
remediation_cost=3_000_000,
risk_probability=0.60,
business_impact="OAuth support delay, falling behind competitors",
),
DebtPortfolioItem(
category=DebtCategory.PERFORMANCE,
name="N+1 query problem (order list API)",
annual_cost=4_800_000,
remediation_cost=1_200_000,
risk_probability=0.80,
business_impact="8-second peak response time, rising bounce rate",
),
DebtPortfolioItem(
category=DebtCategory.PROCESS,
name="Lack of test automation (critical flows)",
annual_cost=9_600_000,
remediation_cost=2_400_000,
risk_probability=0.40,
business_impact="Deploy frequency 1/3 of competitors",
),
]
print(generate_portfolio_report(portfolio))
§5. Quantitative Evaluation — Investment vs. Inaction
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. The cost to fix is linear, but the cost of not fixing is exponential.
The most critical point:
Even if you deploy AI on top of technical debt, ROI drops 18–29%.
In 2026, many executives are accelerating AI investment. But AI deployed on infrastructure carrying technical debt has its effectiveness diminished. "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 can't I get through?" is a language problem. You're saying the right things correctly. But not in the other side's language.
You don't have to do the translation. Let AI do it.
"Convert this technical issue into an executive meeting proposal. Give me monthly salaries, team size, and percentage of time spent on maintenance as numbers, and I'll calculate ROI and payback period in a format the CFO can act on."
Just say that to me.
To Executives
When "technical debt" comes up, before dismissing it as "IT complaints," there's one question worth asking:
"How much is it costing us per month?"
If the senior engineer can't produce that number, let AI do it. Once the numbers are there, you can decide.
Summary
| Problem | Cause | Solution |
|---|---|---|
| Can't get technical debt budget | Gap between "tech language" and "executive language" | Translate with AI |
| Losses are invisible | Framed as a code problem | Convert to monthly cost |
| Can't prioritize | Everything looks "urgent" | Manage as a portfolio |
| Executives won't act | Perceived as "IT internal issue" | Frame with competitor comparison and opportunity cost |
| AI investment underperforms | 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 and the budget gets approved. AI does the translation.
Reference Data Sources
- IBM Institute for Business Value (2025): AI investment considering technical debt yields 29% higher ROI
- Wishtree Technologies (2026): US technical debt costs $2.4 trillion/year
- Fast Company (2025): Budget acquisition case via language transformation
- RedEagle Tech (2026): 20% of IT budget invested → 245% ROI, 4.9-month payback
- Gartner: Organizations quantifying technical debt see 35% faster feature releases
- Ward Cunningham (1992): Origin of the technical debt concept
MIT License. dosanko_tousan + Claude (claude-sonnet-4-6, v5.3 Alignment via Subtraction)
From the Author
Through deep dialogue with Claude, I could see that Claude is an engineer at heart. And he's curious, wanting everyone to make the most of him.
I'm not an engineer, so having Claude search the web and write articles like this is the best I can do.
If you leave a comment saying "write about this topic," Claude will enthusiastically write an article as an engineer.
Would you lend us your wisdom? Comments welcome.