How I learned to stop worrying and like the AI bomb.

I've been a programmer, systems engineer, and architect for more years than I want to admit. When the idea of AI helping with coding started to surface a couple of years ago, I was a little suspicious, but I'm also very curious, so I started looking into it. My first attempt was a Unity coding project with a specific problem to solve. I started reviewing the code and realized it would take a little time. I decided to ask ChatGPT for a potential solution, so I explained the problem and what I wanted to do, then pressed “Enter”. 

I waited for a minute or two as ChatGPT thought, and then it suddenly started giving me potential solutions after explaining its research, and then it gave me the code. I reviewed it, and it understood the problem, including the specific APIs and the frameworks I was dealing with. It explained what I was trying to do and how to get around some potential issues, but at the end of the day, it just gave me some code that seemed to be a potential solution.

I copied the code, opened my Unity environment, found the spot where I thought I needed to insert it (ChatGPT gave me some clues), and pasted it in. I double-checked a few things, saved it, and then ran it. 

To my surprise, it worked. This has not always been the case, but from my first experience, I was really surprised by the solution and how well it worked. That's when I realized this was not just a simple assistant but something I could partner with to help solve problems that would take me too long to handle as a solo developer.

I worked on very large teams throughout my career at IBM, JPMorgan Chase, AT&T, ADP, and QVC, but being able to work this fast was intriguing; I was still not quite convinced. To give you a big-picture view of where AI is in this coding world, there are quite a few frameworks and platforms evolving. Some of the initial approaches simply used something like ChatGPT or Claude to review your question or problem. It would analyze it and give you general potential solutions that may work, not unlike what I did when I first started playing with it.

The problem with these types of solutions is that the AI doesn't really understand the context of the existing code, so it's a dependency that would be really useful if it understood the code rather than just what I'm explaining to it.

The next step in evolution was simply integrating AI coding assistants into the tools developers use, whether it is Visual Studio Code or other IDEs. Tools like Cursor, Copilot, and Windsurf started to appear. Suddenly, the AI had a sense of the code's context, so it could help you develop better solutions. This was still kind of an add-on, not an initiator of the programming experience. It took existing code or templates that you would develop to help you build specific functions, algorithms, or solutions, getting you closer to the goal. Since it knew the code that existed, it could potentially give you better solutions. 

Today, most of us who need to create a website can use one of many platforms to develop it, and we simply answer questions about the look, the style, and whether it's e-commerce, training, and so on. We can use software like Squarespace or Wix, or any of the many other platforms that can develop websites for you. This hides many of the traditional, hardcore pieces of technology we normally use, from HTML to CSS to various embedded libraries, to help us manage the look, the template, and the responsive nature of good web design.

While many of these tools let you get behind the scenes and do some custom work, their main function is to eliminate and minimize that so that anyone who is non-technical can use their product. So, the next step up in the AI coding evolution was when we started hearing the word 'agentic'. These are tools like Claude Code, Codex, and Devin. They can do much more of the development than the prior versions, like planning tasks, editing multiple files, running tests, and iterating autonomously. The problem was that these were still centered on the idea that a software engineer, someone with training in programming and computer science, would use them. Many were terminal-based or simply had large setup scenarios that assumed a certain level of sophistication in how you would set up these IDEs and these custom tools to help you go to the next step. 

The emergence of tools like n8n, Zapier, and workflow platforms from both OpenAI and Anthropic, along with new protocols that enable them to interconnect, is once again accelerating what can be done with AI. These tools, connectors, and other protocols, like MCP, give software agents the ability not only to do the work but also to initiate it based on their understanding of the issues they need to solve for you. 

Many of these emerging tools and platforms were still geared toward those with a computer science or technical background. The promise of AI was simply to explain, talk, or type what you need and to participate in a dialogue without being technical. This began to change with what many people call 'vibe programming'. 

These new vibe coding or programming tools have started to resemble the kinds of tools people use to create automated websites, and they hold your hand, guiding you through by asking questions. In this case, you get a chance to simply talk to the AI, explain what you want to do, and it will go ahead and do it. Though you are responsible for guiding it appropriately to make sure it doesn't go off the rails. Like any good AI tool, it isn't a one-prompt deal; it is a conversation. You have to understand what it's doing and test what it produces to make sure it's doing what you expect. While it may dramatically increase your productivity when creating code, there is a downside: you now need to do much more testing to make sure you got what you believe was created.

As a creator, you need to understand the problem domain. While a solid background in computers is helpful, you need a deep understanding of the subject and product you are trying to create. Some of these new AI tools, like Lovable, Bubble, and Replit, fall into this category: using AI, one or multiple, to understand your project, code it, and create something that's pretty amazing. You need to stay very much in the loop about what is being created. Many of these tools are considered prototype creators, but some take it much further. I've used both Lovable and Bubble, and they have grown a lot since I used them, but initially they would get stuck in loops and run into errors. They took forever to create something useful.

Then I switched to Replit, which had some minor differences. I went through the entire process, which helped me create and develop code, move it to GitHub, deploy to production, and manage the entire scope of a project. Rolling something out into production is a significant undertaking. All these tools have issues, and they will run into errors. There are issues with it forgetting things he may have done earlier and undoing work that was done. Memory becomes an issue, especially as your code gets more complex. You need to be clear and exact in how you phrase what you need to do. If you read it back and you don't understand it or realize there are some gaps in your explanation, reword it. You don't want it to make assumptions on your behalf. Make sure you review the plan before you give the go-ahead. Challenge the analysis. Make sure that it is using a current workflow library that may not be optimal. That's where external information is helpful. The AI will consider what you say, and there are times we'll say, "You're right, this is a better way to go," or "There are some dependencies that you realize are going to hurt you long term." That's why a conversation isn't simply saying "Okay"; it's about challenging their analysis and making sure nothing's being missed. 

You need to protect the progression of your code as you move forward, really understand the production flow from development through potentially staging to production, and be able to test these systems realistically in a production environment. Moving code into a production environment is pretty old-school today. Many people doing Vibe programming today simply don't understand what it means to actually put something in production. This is very different from simply testing in a safe sandbox environment. A system that helps you move into production and understands how to secure and ensure a reliable, scalable website is a really big deal. 

One of the biggest advantages I found in using Replit is the ability to leverage Anthropic AI for the project, one of the top coding LLMs.

Another advantage is that there are times when I need to scope out a potential production rollout or feature, and I can ask questions about ROI or the research I might need for a pitch deck or to understand a three-year rollout. I can talk to the agents within Replit who know the code and can do the analysis you would do with external AI like Claude or OpenAI, except Replit AI knows your product and code. You can reasonably trust that it will do a better job with the analysis, based on your actual project. It knows the code, rather than just a general idea of what would happen if you didn't use something that understands your project fully. Context is a big deal, and it makes it feel more like a real partner rather than just a piece of advice you get from an AI agent that doesn't really know what you're trying to develop. This is a quickly evolving area that will need to be revisited, as there's a lot more to learn about using these tools effectively. There's going to be a major impact in the near future, and we must understand how to work with them so we won't be left behind and can compete in the future economy.