AI and Technical Debt

We have some great articles in the latest Top Stories of the Week. Some of them discuss artificial intelligence and machine learning (AI/ML), while others cover the latest in power, analog, and computer technology. My contribution this week is about technical debt. 

One thing generative AI is good at doing is generating lots and lots of text, including programming code. It's great if the software works. Unfortunately, though, many who use it only care if it works once, with little thought on how it will work in the future or how it might make future changes or bug fixes more difficult. 

What is Technical Debt?

Ward Cunningham coined the term "technical debt" back in 1992. It gave a name to the regular cost of doing business due to choices made by programmers, engineers, and developers. 

Shipping first time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite... The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object-oriented or otherwise. — Ward Cunningham, Technical Debt

We have all faced the challenges of deadlines, hacks to get around issues, and so on that we would rather have done differently if we had the time or tools. In the past, the work was done by people but, as Paul Ehrlich notes: 

To err is human, but to really foul things up you need a computer. — Paul Ehrlich

These days, generative AI and now agentic AI are really fouling things up. 

Essentially techlnical debt is something added to a project either intentionally or unintentionally that needs to be addressed in the future. It oftens costs time and money along the way, with costs often increasing over time. 

Technical debt can occur due to multiple reasons:

• Deadlines and time pressures
• Changing or poorly defined specifications
• Development process issues and deferred work
• Inconsistent implementation patterns
• Not following best practices
• Over- and under-engineering

Of course, these days AI is trying to address this as well as generating a lot of code, etc., that's not reviewed by anyone before it goes into production. 

What's AI Got to Do With It?

AI has a lot to do with technical debt, from generating it to fixing it. I will focus on software examples, but technical debt is something that spans development and deployment of any product or service. 

On the generating side, AI and chatbots will churn out more software than anyone can easily review. Unfortunately, it's best practices, and what you desire may not be the same thing. On the plus side, software needs to run through a compiler to be succesfully used, but that only addresses part of the issue. What the code does is another matter. Given the cut-and-paste approach of AI and many programmers, the amount of technical debt grows simply because best practices aren't being followed. 

On the checking side, AI can potentially help identify issues. It many cases, it's been used to locate bugs and performance issues with recommendations on fixing those problems. Of course, the hope is that the solution isn't worse than the problem. 

Finally, there's the idea that AI will improve the performance of real people. In this case, they will either generate new software that has less technical debt or be able to more quickly fix issues with the help of AI. 

Managing Technical Debt with AI? 

As noted, AI may be able to help check and potentially fix issues related to technical debt. Still, care must be taken when using AI tools, as they could just as easily worsen the problem.

AI tends to be great at pattern matching as well as identifying inconsistencies. So, using it to help developers determine where issues exist, the costs of leaving it in place, and what it will take to change it, are potentially answers that will be easier to obtain using AI. 

However, there are many challenges. Most AI systems these days are changing rapidly to versions that are purported to be better. While that may be true, this will alter how prompts, processes, etc., will be changed because the underlying engine is different. 

Too much dependency and little oversight can also be an issue. That's because the checking and improvement now has its own technical debt, and, as we have seen, AI can create lots of slop a lot faster than people. 

On the plus side, agentic and generative AI is able to provide the tools and management of the development and review process. Just remember to keep a real eye on it.