The Top 6 Things I’ve Learned from Developing with AI

In this post, I’ll discuss some things I’ve learned from developing with AI and explain them from my point of view, and how to get the best results using it.

But first, let me share with you how I usually developed software before the internet, Google and AI assistants.

The Beginning

Before the internet existed, developers shared their source code via floppy disks. A significant amount of code was shared among professors and university students through physical media exchanges and academic networks.

Documentation and code examples were obtained through books, and you had to manually type the source code and adapt it to your specific needs. This process was time-consuming and error-prone, but it was the only way to access programming resources.

Sometimes it would take ages to create a certain functionality because you didn’t have the proper documentation for that programming language. Finding comprehensive references was a challenge that could stall development for weeks.

The Era of Physical Documentation

A classic example I recall is Visual Basic 6.0, which came with several books and lengthy Microsoft-style explanations, similar to what we see today on https://learn.microsoft.com. These physical manuals were essential references that developers kept close to their workstations.

The learning curve was steep, and mastering a programming language required significant investment in physical books, magazines and sometimes expensive training courses. Sharing knowledge meant photocopying pages or manually transcribing code snippets.

The Internet Revolution

Then the internet arrived, and it became much easier to “harvest” source code from programming websites. High-quality components with excellent source code were easily found on sites such as http://www.vbaccelerator.com/ and https://www.codeproject.com/.

The Current Challenge

The core issue is that it’s currently humanly impossible for someone to master 100% of a programming language or framework, encompassing both the complete backend and frontend stack, given the constant release of innovations.

The rapid pace of technological advancement means that by the time you master one technology, several new ones have emerged. This creates a continuous learning challenge that can be overwhelming for developers trying to stay current.

The AI Era

At this point, we reach the realm of AI. It brought a possibility that didn’t exist before: helping us create source code in any language. AI democratized programming by making expert-level assistance available to developers at all skill levels.

Like any powerful tool, AI requires understanding, respect and proper application to be genuinely beneficial.

Source Genesys

The efforts preceding the advent of generative AI were significantly greater. The same tasks that demanded a week of development are now completed in just a few hours. Frontend adjustments and component creation, which often required an entire development shift, depending on complexity, are now completed in a matter of minutes.

The MVP of the migrations I performed recently was completed in record time, migrating both the database and the legacy source code. AI acted as if I had an extra developer on the frontend and another on the backend.

However, I must be honest: The AI that has helped me the most is my own, which I’ve been developing since 2000, now known as Source Genesys. It delivers backend code in .NET 9 and frontend code in React Next.js, but it continues to evolve and refine.

The idea of Source Genesys has existed since the late Clipper era, when I developed an MRP II system in 1994/1995, where the source code for each manufacturing unit was created depending on which one it would be deployed for. In 1995, I began working with Visual Basic and continued to develop and evolve it until 2010. Developed more than 200 components in ActiveX.

From 2011 onward, I began working and focusing on C# development. But it was in 2025 that I returned with full force to update the tool that generated the C# code for Advocati.NET in .NET 4.x.

And it was thanks to the help of generative AI that I was able to put five migration projects into development almost simultaneously. Because I develop and evolve the tool simultaneously, I perform the migrations.

The Top 6 Things to Know About AI Development

With this historical context in mind, I’ll now list my six discoveries using AI for development over the past two years, working with ChatGPT, Gemini, Claude AI and GitHub Copilot. Between January and July 2025, I have already completed five legacy system migrations from VB6/Access and ASP.NET C# to .NET 9, utilizing React and Next.js with Microsoft SQL Server.

During this period, I consistently utilized AI assistance to complete projects and meet requirements, continually refining my prompts as the AI systems themselves evolved.

So, here is my list of lessons learned:

1. AI Makes Mistakes Often, But You Can Show It the Right Path

The greater your background in technologies and understanding of how things work at a technical level, the easier it will be for you to understand the results AI generates.

Often, the prompt generates very good code, but some property or function presents a defect or something deprecated. This is where human action comes in, identifying what’s wrong and correcting it.

Sometimes you can ask AI to evolve your source code from another approach because the generated code doesn’t effectively meet the requirements. In this way, you are the guide.

With AI agents, such as GitHub Copilot (Agent option), the solution level can be more realistic, but it can also generate other problems, including overly complex code with numerous dependencies.

Before asking the agent to modify your code, I recommend making a git commit to revert changes if they present more problems than solutions.

From time to time, you need to start a new session to release the old context, which helps the AI analyze the problem from a different perspective.

2. Build Skeletons and Ask AI to Complete Them

When creating something new, such as a new component or a new function/method, you can ask AI to assist you. But it will do things its own way, especially if your prompt isn’t comprehensive and detailed.

I’ve noticed that if you want to build something more robust, it’s best to create a skeleton—a basic version of what you want—and then instruct the AI to make a version using SOLID principles and/or Clean Code. This way, you get a more satisfactory result. I’ve also learned to break problems into small parts and ask the AI to work on a specific issue by starting a new session for each one.

Make functional “mockups” of what you have as objectives and inject improvements and enhancements piece by piece.

AI doesn’t see the result as we do visually and logically, so if you can add some screenshots of what you want or to improve the result, it will guide itself and improve the generated code.

3. Don’t Ask for Everything Ready-made

Broad and generic requests aren’t AI’s strong suit. You can’t ask, “Make a complete, simple, beautiful and scalable system.” You must build your project in segments. Assemble the idea with the requirements and divide to conquer.

A very broad request can generate overly complex code. Even if you want complex code, you want to feel that you’re in command, transforming requirements into presentable, scalable solutions that are easy to maintain using consistent logic.

4. Structure Prompts with Precision and Technical Constraints

Specific, well-defined prompts consistently produce higher quality code than vague requests. Instead of asking “create a user interface,” specify: “create a React TypeScript component with form validation using react-hook-form, including email/password fields with real-time error display.”

The key is providing context, constraints and expected outcomes. AI models perform better with structured input that defines scope, technology stack and architectural patterns.

5. Leverage AI’s Specialized Knowledge Domains

AI has access to information as comprehensive as a specialist in any knowledge area. This is good because it shares knowledge from various areas of human knowledge. Of course, it makes mistakes, but your job is to validate the results it produces.

In my experience, I have frequently worked with technicians who are extremely knowledgeable about a specific area of software. With the advent of generative AI, it’s easy to clarify technical data, its use, variations, limits and rules—enough to get your structure ready. And then, at validation time, a human professional from a specific area can refute or confirm this data. So you’re halfway there already, ready for a human to polish and use their expertise to finish the project.

In a world where we encounter a new framework every day or must work with a new language we haven’t mastered, the knowledge that AI has about various subjects makes it a valuable ally. But it still depends on us to understand technically what we are looking for and to ask the right prompts to get to the right end result.

6. Context Is Everything—Both Business and Technical

The more context we provide, the better the result will be.

But we need to understand the context of our objective. When we develop software for areas we don’t have mastered, the context is passed to us over time through our interactions with professionals who perform their daily work. This happened to me when developing industrial, legal and medical systems.

One of AI’s difficulties is understanding context. This applies to both business domain knowledge and technical architecture.

In a business context, we might need a rule: To select the status of a meeting, a free-of-charge option should be available only for 20 days after the last paid one.

In a technical context, AI can be extremely specialized. Commercial AIs require you to explain database relationships manually, whereas specialized tools like Source Genesys automatically understand schema relationships and generate proper validations. Source Genesys has been provided the necessary context to create these understandings.

Conclusion

Human interaction remains the fundamental basis for validating and correcting AI-generated results, verifying that the final product meets the desired standards. With the continuous advancement of technology, AI is becoming increasingly integrated into our daily lives, transforming the way we produce and collaborate.

Understanding its functioning enables us to utilize its capabilities strategically and achieve exceptional results. This transformation from physical media to internet resources to AI assistance represents one of the most dramatic shifts in how we approach software development, offering unprecedented possibilities for innovation and productivity.

Want another developer’s input? Read: How I’m Using AI (as an AI Skeptic)