Atul Sabharwal is a founder and CEO of Snipp, a leading AI-powered value-added SaaS company in the global loyalty and promotions sector.
Twenty years ago, our entire business was powered by a handful of tower servers in a basement. We’ve held on to a photo of that setup—nostalgia for our version of the classic tech origin story, complete with company mug and logo 1.0.
Those yellowed towers look almost archaeological now, but they were the best solution we had then. Until we outgrew them, and then they weren’t. That was the generation of technical debt we knew how to handle: hardware kept past its useful life, systems held together with duct tape and sheer will, legacy code nobody wanted to sift through. Stuff we understood.
AI is changing that picture, and even what counts as technical debt. Code is being generated so fast, and at such scale, that the next generation of technical debt will sit in the gap between what our systems can do and what we can actually explain, govern and safely change. Over the next 20 years, that gap—and that debt—could widen faster than we know how to track.
One year out: Unexamined code becomes the debt.
Most of us—90% of tech professionals surveyed in Google’s 2025 DORA research—are already using AI to do more, faster. Mainly for writing new code. That code may be great, and may increase delivery throughput, but Google also found that higher AI adoption was associated with increased delivery instability.
The risk is that AI is writing so much code that review, testing and governance lag behind. Friction shifts toward review and verification, and gaps are already showing up there: Sonar’s 2026 survey found 96% of developers say they don’t fully trust AI-generated code, yet fewer than half always check it before committing.
A lot of unexamined code could be sitting beneath shipped software, invisible until it needs to be changed or secured. Then the interest comes due: time spent reasoning through codebases that nobody wrote line by line, with upgrades and new features becoming slower and riskier.
Five years out: Dependencies become the debt.
AI agents will likely be taking the reins: monitoring systems, patching code and coordinating with each other to keep things running. Developers may move further from a system’s underlying code toward writing prompts, specifying outcomes and reviewing what AI fills in.
But here’s the rub: AI doesn’t land on a clean slate. It inherits your existing stack, technical debt included. Fragmented systems, inconsistent data, undocumented business logic and years of workarounds will show up in the quality and reliability of what gets produced. Engineers get pulled into firefighting instead of building. IBM research found that 81% of executives say technical debt is already constraining AI success, potentially adding 15% to 22% to schedules.
This is where choices about models, vendors or agents can become dependencies, shaping business outcomes long after whoever chose them has moved on. The debt won’t be the dependency itself; it’ll be reaching the point where nobody can explain why a particular choice was made, or what breaks if it’s replaced.
Twenty years out: Lost judgment becomes the debt.
This far ahead, the conversation stops being about code. OK, it stops being only about code. AI may be doing the heavy lifting of designing, building and repairing systems, and applications probably won’t age the way they do now. But the debt won’t simply be paid down. It’ll move higher in the organization and become a trust problem. If institutional knowledge is embedded in models and workflows, then who’s really in charge? How do you challenge key decisions when nobody fully understands or can retrace their underlying logic?
You can refactor a legacy application’s code, but you can’t refactor organizational judgment. AI may help you build the most capable system in the world, but if you can’t explain it, then you’ve outsourced judgment without outsourcing accountability for what it does.
Here’s what we’re learning and what leaders should take away.
At Snipp, we’re already seeing both sides of this shift: the debt we inherited, and the debt we could create next. Growth through acquisitions left us with systems built on different architectures and standards. As we bring AI into development, QA and operations, those differences have become starker. A few lessons have emerged:
• Clean data is only the start. You also need to know where it came from, what rules shape it and why key choices were made. Versioning, monitoring and traceability can’t stop when a system launches.
• Faster output only helps if the organization can trust it. Every major AI-assisted system needs a named human owner, clear review processes and a way to roll back changes. Preserve the datasets, prompts, model versions and business rules behind key outputs.
• The model, vendor or architecture that works today may not be the right one five years from now. Modular systems, portable data and realistic fallback plans keep one dependency from becoming the foundation of the whole business.
• Don’t count only the development time AI saves. Include the cost of review, monitoring, security, compliance, retraining and eventually changing models or vendors. Otherwise, the ROI looks better than it actually is.
Servers become obsolete. Principles don’t.
The goal isn’t zero technical debt. Every company makes trade-offs and every generation inherits its share. When I look at that photo now, the reassuring part is that we knew what those servers did, why they were there and when it was time to replace them. AI changes those signposts. The goal now is to know where the debt sits, who owns it and whether you can still change direction before the debt starts making decisions for you, so that 20 years from now, you’re still the one governing what AI has helped build.
I’ve never been able to find that mug, though.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?