Updating Legacy Software with AI for Small Business Owners
In a world where custom software often ages out faster than its business value, AI offers a compelling way to salvage and update legacy applications without a complete rewrite. In this article, I share my experience as a self-taught developer using AI to refactor a billing app I built almost 20 years ago. The app, previously discarded in favor of commercial solutions, was resurrected with AI’s help after my go-to software became unavailable. This story highlights how AI can streamline and expedite the redevelopment process, even for those without a formal software engineering background, by taking on some of the technical legwork required to modernize old code.
Introduction
In the world of software development, it’s all too common to outgrow custom-built solutions as more advanced options come to market. That was my situation with a billing app I created almost two decades ago—a simple but functional tool that tracked time and materials for service requests in a way that felt just right for my workflow. Eventually, I pivoted to a commercial tool, Connectwise, which served me well until a recent server crash left it unusable, with no backup.
Starting with Context and Clear Parameters
My first step was to set the stage for the AI by laying out my circumstances. I explained that the app needed a “refactor”—a process of updating the code without changing its core purpose, by replacing outdated components. With this context, I shared the “code behind” for one of the app’s forms and highlighted the controls that needed replacing, conveniently labeled with unique identifiers from the original third-party vendor.
A significant factor that made this process feasible was having access to the original source code. Without it, the task would’ve been a completely different challenge, requiring a more complex reverse-engineering approach that AI alone likely couldn’t handle. This article specifically focuses on situations where source code is available and ready for AI to refactor.
While the AI tool responded eagerly and capably, I wasn’t ready to let it handle everything unsupervised. I took on the role of a manager, verifying its responses to ensure it thoroughly handled every outdated reference. After a few iterations, the code was clean, stripped of third-party dependencies, and replaced with native .NET elements. I then introduced it to the form’s “module,” the logical programming code tied to the form’s controls, ensuring the names and actions matched up. This iterative dialog was smooth—but only because I had a developer’s eye to guide it.
AI’s Limitations in Visual Layout and UI
With code refactored, the next challenge became painfully clear: Visual Studio couldn’t render the form layout because it lacked those third-party controls, so I had to rely on the AI’s replacements. Here’s where the limitations became apparent. While the AI effectively swapped controls, it didn’t handle the form’s visual layout as accurately as I would have liked.
Most of the replacement controls appeared stacked on top of each other, lacking labels or formatting. Buttons, fields, and checkboxes were there but jumbled together with no visual order or descriptive text. It’s a situation that would leave a less experienced user utterly lost.
So, I had to get hands-on. I manually identified each control, making sure it was visible, adding descriptive text, and arranging everything back into a usable form. For anyone attempting a similar project, this detail is key: AI can handle refactoring, but if visual elements matter, be prepared for some manual layout work or give specific instructions from the start to preserve control placement.
A Capable Partner for a Practical Developer
Despite its limitations, the AI was an incredibly effective partner in this process. With minimal back-and-forth, it shaved what could have been days of tedious work down to just hours. Yet, it’s important to stress that success here wasn’t automatic. As a self-taught developer with no formal training, I brought enough experience to “speak the language” of software, something essential to guiding the AI effectively. The AI was a helpful assistant but needed oversight—particularly in ensuring responses weren’t truncated or that all essential lines were accounted for.
For those without development experience, diving into AI-assisted app refactoring would likely be frustrating. It requires knowledge of both the tool and coding conventions to assess when AI suggestions are on track or veering off.
Final Thoughts: AI as an Accelerator, Not a Replacement
My experience shows that while AI is a powerful tool, it’s not a stand-in for a developer’s expertise—at least not yet. However, for anyone with some coding background facing the challenge of updating or “resurrecting” an old app, AI can be a game-changer. It can transform a daunting, time-intensive task into a manageable one, speeding up parts of the process while leaving you in control of the final product.
In my case, the AI breathed new life into my 20-year-old app, transforming it from text descriptions into a workable, visual form. While I still have adjustments to make, the heavy lifting is done, and I have a viable app back in production—all thanks to a little AI and a lot of oversight.
For small-scale developers or business owners with legacy software, AI is worth considering as a capable assistant that, with the right guidance, can help unlock value from code you thought was lost.
