Introduction
Recently, I ventured into starting a personal project, one of those that often stay in the ideas box. However, this time, I decided to embark on developing a somewhat simple web infrastructure but with significant weight behind it. The idea isn’t new; in fact, I took it from a project developed a few years ago, during the final semesters of my degree. While the end result was interesting, the inexperience and lack of knowledge in many areas made the path tortuous. Finally, the project reached the client, who received it and used it for their venture.
A few weeks ago, while writing an article for this same blog, I grew curious about how long it would take to develop the same project from scratch today. I sat at my computer and began planning the web infrastructure development. It’s not just about taking the project and copying it, but about analyzing how my current self develops a project compared to my former self from years ago. What things I would do differently, what technologies I would use, and what design patterns I would implement.
The biggest difference is that today we have the blessed Artificial Intelligence, which can assist us in many software development tasks. So, I started asking all sorts of questions about the project to see what suggestions the AI would give me. It was a truly interesting process, as I realized many things I could do differently and better.
I took the professional experience I have as a software developer, market trends, videos from Youtubers talking about AI and software development, and of course, the experience I had developing the project in the past. I decided on a powerful tech stack and a development methodology that’s being talked about a lot lately, which also goes very well with AI—I even have an article about it, you can see it below.
Straight to the point: a few days later, having made considerable progress on the project, I found myself thinking: AI is a speed multiplier, but if you don’t know what you’re multiplying, you’re only accelerating the disaster. If you’re wondering why, let’s look at the problems AI can cause in software development:
Disadvantages of AI Development
1. Symptoms of “Zombie Code”
No matter how much documentation you create within your project directory, AI doesn’t have the capacity to understand the full context of your project. Therefore, it’s very likely that you’ll generate code that doesn’t integrate correctly with the rest of the project or requires significant modifications to work properly. Among the symptoms of zombie code, we find:
Visual Inconsistency:
Buttons that look different from each other, mismatched styles, inconsistent typographies, etc. This happens because the AI lacks the ability to understand the full context of your project. Google knows this and has even published design.md; check it out in the links I’ll leave below.
Verbose Code:
In the best-case scenario, the AI will generate code that is correct but not optimal. In the worst-case scenario, it will generate incorrect code that requires significant modifications to work. Therefore, it’s crucial to have programming knowledge to detect and correct these issues. Moreover, a method that could undoubtedly be written in fewer than ten lines of code, the AI might transform into a complex function of more than a hundred lines, when in reality it’s something very simple.
Ghost Dependencies:
Some models have improved significantly in many ways, but that doesn’t make them infallible. In fact, it happened to me several times that the AI tried to import libraries I didn’t even have installed. Not only that, sometimes it works with outdated libraries, deprecated methods, etc. It can become frustrating to resolve these issues, especially if you lack programming knowledge.
2. Frankenstein’s Anatomy (The Technical Problem)
Lack of Global Context
As mentioned before, AI doesn’t always have the full context of the project; it sees the project through the “keyhole” (the current prompt) and loses the vision of the entire architecture. This isn’t always a problem, as the prompt is often enough for the AI to generate the correct code. However, for tasks where the prompt leaves many ambiguous points, the decisions the AI makes can be questionable.
Instant Technical Debt
Your project can be born “dead” if technical debts are present from the start. Technical debt is simply “shortcuts” taken during development to move faster, but which will cause problems in the future. An example of technical debt is a method that is functional at first but is not optimized or doesn’t follow coding standards or best practices.
If from the moment you start firing prompts, you review the results, and seeing that it “works” you move to the next development without reviewing, debugging, and optimizing the previous part, then your project will be born with technical debts. these will turn into a nightmare when your project starts to grow and you need to scale.
It’s no exaggeration, and it’s not just about making the code look “pretty”; this involves issues like your application’s performance, security, scalability, etc. Things that can compromise the integrity of your application and, consequently, that of your client and/or users.
Survival Guide: How to ACTUALLY Work with AI
To begin this survival guide, it’s necessary to clarify that AI is not a substitute for the programmer, but rather an assistant or copilot that can help in many software development tasks, provided the programmer has the necessary knowledge to guide it. The secret lies in knowing what to ask, how to ask it, and how to review the results.
Architecture First, Prompts Later
Before even thinking about asking the AI to generate code, it is fundamental to have a clear and well-defined architecture. Think of the architecture as the skeleton of your project; if the skeleton is weak, everything you build on it will be weak. There are many architectural standards for software development out there; don’t bother looking for “which is better or worse”—if they exist, it’s for a reason. Each project and each need adapts better to one architecture than another.
Developing is not synonymous with programming; programming is throwing lines of code (something AI does a lot lately), while developing is analyzing, planning, designing, structuring, debugging, and optimizing. Basically, development is a complex process, and AI is only a tool that can assist in some of its tasks.
The Scout Rule:
Leave the code cleaner than you found it (or how the AI delivered it to you)
Essentially, this rule consists of leaving the code in better condition than you found it. If you see a function that isn’t optimized, optimize it. If you see a function that isn’t documented, document it. If you see a function that isn’t tested, test it. In short, if you see code that can be improved, improve it.
Iterative Reviews
Don’t blindly trust AI. Always review the code the AI generates before using it. Sometimes you can look at the result and see that what you asked for works, yes, but under the hood, more problems than solutions might be hidden. A good prompt will give you a good result, but even so, you’ll always have to review it before moving on to throw another prompt at your agent.
Conclusion
As you could see, AI has many advantages and disadvantages in software development. The key lies in knowing how to use it to our advantage and not letting it use us. Remember, AI is a tool, not a substitute for the programmer. I hope this survival guide has been useful to you. As for the project I started—no, I’m not going to abandon it; quite the opposite, the developed MCP will serve as a foundation for a complete, structured, well-planned, documented, tested, and optimized development.
Links of Interest
Check out this official Google resource where they talk about Design.MD, the standard you can use to specify your project’s design.
Review it now, thank me later: Refactoring Guru
Read more about clean code architectures in this very interesting article, credits to the author: