Production Monitoring & Career Portfolio · 45 min · Python · GitHub API · Debt Dashboards
The Problem
AI coding tools generate code at unprecedented speed, but they also introduce issues at unprecedented scale. The "Debt Behind the AI Boom" study found 464,900 AI-introduced issues, with 105,364 (22.7%) surviving 9+ months. These surviving issues accumulate as technical debt, degrading code quality over time. Without a debt strategy, AI code quality degrades silently.
Issue Survival Analysis
| Metric | Value | Source |
|---|
| Total AI-introduced issues | 464,900 | Debt Behind the AI Boom study |
| Surviving issues (9+ months) | 105,364 | 22.7% survival rate |
| Fixed issues | 359,536 | 77.3% resolution rate |
| Growth trend | Rapidly increasing since early 2025 | Study observation |
| Avg age of surviving issues | 180+ days | Study data |
| Oldest surviving issues | 720+ days | Study data |
Why AI debt is different from traditional debt
Traditional technical debt comes from rushed deadlines and shortcuts. AI debt comes from: (1) Volume: AI generates code 10x faster than humans, introducing issues 10x faster. (2) Subtlety: AI code looks correct (passes syntax, passes existing tests) but has subtle behavioral bugs. (3) Trust bias: Developers trust AI code more than human code, reviewing it less carefully. (4) Scale: 464,900 issues is far more than any human team would introduce. Traditional debt strategies (refactoring sprints, code reviews) don't scale to AI debt. You need automated tracking, dashboards, and paydown strategies.
What is issue survival analysis, and how does it help track AI-introduced technical debt?
Issue survival analysis is a technique from the 'Debt Behind the AI Boom' study that tracks how long AI-introduced issues persist in the codebase before being fixed. It's adapted from survival analysis in statistics (originally used in medical research to track patient survival over time). Here's how it works and why it's important for tracking AI-introduced technical debt: What issue survival analysis measures: (1) Total AI-introduced issues: The total number of issues that were introduced by AI-generated code. These are identified by analyzing git history, commit messages, and code patterns associated with AI coding tools. The study found 464,900 AI-introduced issues across open-source repositories. (2) Surviving issues: Issues that are still open at HEAD (the current state of the repository). These are issues that were introduced but never fixed. The study found 105,364 surviving issues. (3) Survival rate: The percentage of AI-introduced issues that are still open. Formula: survival_rate = surviving_issues / total_issues. The study found a 22.7% survival rate (105,364 / 464,900). This means nearly 1 in 4 AI-introduced issues are never fixed. (4) Age distribution: How old are the surviving issues? This shows how long issues have been in the codebase without being fixed. Example distribution: 30% are 1-3 months old, 25% are 3-6 months old, 20% are 6-9 months old, 25% are 9+ months old. The 25% that are 9+ months old are the most concerning -- they've been in the codebase for a long time and are likely to persist indefinitely. (5) Resolution rate: How many AI-introduced issues are fixed per week/month. This measures the team's capacity to address AI debt. Example: 500 issues introduced per week, 300 issues fixed per week → net debt growth of 200 issues per week. If resolution rate < introduction rate, debt grows. If resolution rate > introduction rate, debt shrinks. How it helps track AI-introduced technical debt: (a) Quantifying the debt: Issue survival analysis provides hard numbers: 464,900 total issues, 105,364 surviving, 22.7% survival rate. This is not a guess or estimate -- it's measured data. The team knows exactly how much AI debt they have. (b) Showing the trend: By tracking issue survival over time, the team can see if debt is growing or shrinking. The study observed that surviving issues have been growing rapidly since early 2025 (when AI coding tools became widely adopted). This trend analysis helps the team understand if their debt strategy is working. (c) Identifying old issues for prioritized resolution: The age distribution shows which issues have been in the codebase the longest. Issues that are 9+ months old are unlikely to be fixed without active intervention. The team can prioritize these old issues for resolution in debt sprints. (d) Measuring paydown progress: By tracking resolution rate vs introduction rate, the team can measure their paydown progress. If they fix 500 issues per week but introduce 300 new issues, they're making net progress (200 issues paid down per week). If they fix 200 but introduce 500, they're falling behind (300 issues added per week). (e) Comparing to industry benchmarks: The 22.7% survival rate from the study provides an industry benchmark. Teams can compare their own survival rate to the benchmark: (i) < 10% survival rate: Excellent -- AI debt is well-managed. (ii) 10-20% survival rate: Good -- some debt accumulation but manageable. (iii) 20-30% survival rate: Average -- matches the industry benchmark. (iv) > 30% survival rate: Poor -- AI debt is accumulating faster than it's being paid down. How to implement issue survival analysis: (1) Tag AI-introduced issues: Use GitHub labels to tag issues introduced by AI-generated code. Label: 'ai-generated'. This allows filtering and tracking AI issues separately from human issues. (2) Track issue creation and resolution dates: For each AI-introduced issue, record: (a) Creation date: When the issue was introduced. (b) Resolution date: When the issue was fixed (or null if still open). (c) Current age: Days since creation (for surviving issues). (3) Calculate survival metrics: (a) Total AI issues: Count all issues with 'ai-generated' label. (b) Surviving issues: Count issues with 'ai-generated' label that are still open. (c) Survival rate: surviving / total. (d) Age distribution: Group surviving issues by age (1-3 months, 3-6 months, 6-9 months, 9+ months). (e) Resolution rate: Issues closed per week. (4) Build a debt dashboard: Display the survival metrics on a dashboard (Grafana or custom). The dashboard should show: (a) Total AI issues (number). (b) Surviving issues (number, trend over time). (c) Survival rate (percentage, trend over time). (d) Age distribution (pie chart or bar chart). (e) Resolution rate (number per week, trend over time). (f) Introduction rate (number per week, trend over time). (g) Net debt change (resolution rate - introduction rate, trend over time). (5) Set alert thresholds: (a) Survival rate > 30%: WARNING (debt accumulating too fast). (b) Surviving issues > 500: WARNING (too many unresolved AI issues). (c) Resolution rate < introduction rate: WARNING (debt growing, not shrinking). (d) Oldest issue > 365 days: WARNING (ancient debt that needs attention). In summary, issue survival analysis is a data-driven approach to tracking AI-introduced technical debt. By measuring total issues, surviving issues, survival rate, age distribution, and resolution rate, teams can quantify their AI debt, track trends, prioritize old issues, and measure paydown progress. The 22.7% survival rate from the 'Debt Behind the AI Boom' study provides an industry benchmark for comparison."