When we talk about technical debt today, the conversation too often circles back to a single, ugly question: how do we remove it all? At QCon London 2026, Joy Ebertz flipped that script. Instead of chasing a pristine codebase that may never exist in a world of rapid AI-assisted production, she argues we should ask which debt actually matters. The most útil takeaway is not a heroic cleanup mission but a disciplined prioritization framework that separates “ticking time bombs” from the more forgiving, or even inconsequential, forms of debt. Personally, I think this reframing is long overdue. The software industry has spent years chasing perfection while customers, markets, and teams move on. What matters is not the absence of debt, but the absence of risk that blindsides a business.
What follows is a compact, opinionated synthesis of Ebertz’s framework, spiced with observations, cautions, and the kind of forward-looking questions that keep engineering leadership awake at night.
A practical lens: six questions that matter more than any guilt trip about code cleanliness
- What is the cost if we don’t do anything?
What matters here is scale and impact across developers and users, plus the cascading effects: customer churn, slower feature delivery, and attrition among engineers who burn out trying to work around fragile systems. The key insight many overlook is that risk isn’t binary. It’s a gradient: some debts corral your future decisions, others slam the brakes on growth. One detail that I find especially interesting is how Ebertz distinguishes ticking time bombs—issues that are predictable in their trajectory—from security vulnerabilities where the probability of exploitation remains uncertain. This distinction matters because it reframes urgency: not every impending failure is equally urgent, and not every risk justifies a full-blown migration.
From my perspective, the real-world implication is that product and platform leadership should map debt to business outcomes. If a debt’s trajectory threatens scalability, reliability, or customer trust in a way that jeopardizes the business line, it becomes a priority; otherwise, it’s a candidate for a staged, cost-aware approach.
- What is the cost of fixing it?
Fixing debt isn’t only about engineering hours. It’s about opportunity cost, learning curves for new systems, the friction of dual-running environments, and the hidden surprises that sneak in during migrations. Ebertz’s example—a feature missed during a migration—drives home a painful truth: even a well-planned refactor can derail the roadmap if you don’t account for downstream dependencies and testing blowback. What this suggests is a luxury many teams don’t have: predictable, end-to-end visibility during transition periods. If you pretend you can keep shipping at the same pace while you rewire the backbone, you’re kidding yourself.
In my view, the practical upshot is that rational debt remediation must be budgeted with stage gates and measurable milestones. Without those, you’re just hoping the migration behaves itself.
- Do we need to fix it the right way?
Here Ebertz invites a hard, almost brutal question: is an optimal, perfect solution always required, or is a near-enough, cheaper fix worth it? Nightly scripts, hard-coded limits, even monthly restarts can buy time and reduce risk with a fraction of the cost and effort of a comprehensive rewrite. The point isn’t to minimize quality; it’s to maximize impact per unit of investment. The deeper takeaway is humility: there are situations where a 80% fix now prevents 100% chaos later, and the math of risk and reward can justify a pragmatic shortcut.
My interpretation: teams should create a velocity budget for debt work, where “good enough” is not laziness but a deliberate economy of attention. If the system is nearing a safe, contained state with low marginal risk, a lighter touch can preserve capacity for higher-leverage work.
- When to do it and when is now the right time?
Timing is about trajectory. Is the system deteriorating on its own, or could new tooling—especially AI-assisted automation—unlock easier refactors tomorrow? Ebertz’s stance is not anti-refactor; it’s anti-wasted cycles. If a rewrite looks more feasible now than it did a year ago due to better tooling, that’s a signal. If the debt is not actively hurting, waiting can be a rational strategy—allowing adoption of better patterns and emergence of safer migration paths.
From where I stand, this translates into a readiness culture: keep refactorability in your architectural DNA, monitor debt as a business metric, and be prepared to accelerate when market dynamics tilt in your favor.
- Will we finish the migration, and will it actually help?
The risk here is elegantly captured by a PHP project that keeps migrating frameworks but never finishes the job. Debts accumulate not just in the code, but in decision histories, tooling choices, and deployment rituals. A migration must have completion criteria anchored to real outcomes, not just an internal sense of “getting closer.” This is where governance, milestones, and checkpoints play starring roles. If you can’t articulate how the migration improves reliability, time-to-market, or customer value, you haven’t earned the right to continue.
My takeaway: progress tracking should be outcome-driven, with explicit re-evaluation points that can flip the plan if the intended benefits fail to materialize.
- Will the outcome actually improve the situation?
Ebertz warns against tunnel-vision: teams obsess over the negatives of their current stack and forget the positives that justified the original design. Checkpoints that reassess continued migration prevent “feature drift” into perpetual work in progress. In practice, that means documenting why the current approach made sense, what has changed, and whether the new approach demonstrably reduces risk or increases velocity.
From my angle, this is a cultural cue as much as a technical one: bake in continuous learning and honest stop-signs. If you’re still shipping value, you should feel comfortable continuing. If the return on investment keeps eroding, it’s time to pivot or stop.
Translating debt into a business case you can actually sell
Ebertz doesn’t just leave teams with a checklist; she pushes for economics-first thinking. Her method translates technical decisions into currency: current costs, future costs, and the fixed cost of implementation. The security-patch example—a 5% exploit probability times a potential fine—becomes a clean, financial argument for action. What this reveals is that debt management is not a nerdy engineering exercise; it’s a strategic business decision that affects risk, competitiveness, and resilience.
The AI pivot: more slop, but does it matter?
One of the most provocative lines is the acknowledgment that AI is producing more code—and not all of it is pristine. The key question, though, is not whether AI makes worse code, but whether the debt it creates is hard or easy to fix. Data migrations, security vulnerabilities, and high-performance code remain the tough, costly debt that can define a product’s fate. Easier-to-fix debt—things with clear boundaries and modularity—can be resolved with lower impact. What this suggests is a realistic view: automation accelerates throughput, but not all acceleration is equal in risk profile.
A deeper takeaway for leaders
What makes this framework especially compelling is the insistence on context. Not all debt is created equal, and the value of refactoring lives in the quality of the questions you ask and the way you measure outcomes. In a world where AI can crank out functionality at speed, the real skill is prioritization under uncertainty: knowing what to fix first, how hard the fix will be, and what the business gains from moving. The essential irony is that faster code production heightens the stakes of every decision. If you rush the wrong debt, you can end up with brittle systems that fail when you need them most. If you move thoughtfully, you create a base of more stable, scalable software that can absorb future acceleration.
Conclusion: a principled path forward
The big takeaway from Joy Ebertz’s framework is not a blueprint for erasing debt, but a disciplined lens for triaging it. In practice, that means treating debt as a spectrum of risk and cost, instead of a monolith to be defeated. It means building business cases in financial terms, applying checkpoints that prevent endless migrations, and using AI thoughtfully—recognizing that some debt is simply not worth the effort to eliminate immediately.
If you take a step back and think about it, this approach aligns software practice with business reality: invest where it matters, defer where the risk is acceptable, and maintain a readiness to pivot as tools and markets evolve. The outcome isn’t a flawless codebase; it’s a resilient one, capable of delivering value under pressure and adapting to whatever comes next.
Would you like this piece to lean more into concrete case studies from your team or industry, or to extend into a practical template for a six-question debt assessment tailored to a specific tech stack?
