Software Development with Codex, ChatGPT, and AI: A Practical Guide for Developers

If you had asked me a few years ago what software development would look like in ten years, I would probably have talked about new programming languages, better frameworks, or more powerful development environments. Today, my answer would be completely different. The biggest change isn’t happening with the tools, but in the way we as developers think and work.

As I write these lines, I am working on a new software system myself. For the past few weeks, I have been making extensive use of modern AI tools such as Codex and other language models. At first, I was curious; now, I’m mostly impressed. Not because the AI suddenly does everything on its own, but because it handles certain tasks surprisingly well, thereby enabling new ways of working.

Many discussions about artificial intelligence revolve around the question of whether developers will eventually become obsolete. Based on my experience so far, I don’t find this question particularly helpful. It is far more interesting to observe that the role of the developer is changing. The real challenge is increasingly less about writing individual lines of code. Instead, it is becoming more important to analyze problems, understand systems, document relationships, and provide AI with the right information.

---

---

The Developer as Architect

In traditional software development, developers often spent a large portion of their time on the actual implementation. They programmed functions, built databases, and fixed bugs. These tasks still exist today. However, AI systems can now assist with or even take over many of these tasks.

This shifts the focus. Anyone who wants to develop successfully with AI must, above all, know what they actually want to build. That may sound obvious at first, but it isn't.

In many projects, the majority of problems arise not from poor programming, but from unclear requirements. If the objective is vague, even the best AI won’t help. In fact, such shortcomings are often made even more apparent by AI, because the systems operate very consistently based on the information they receive.

As a result, the modern developer is increasingly taking on the role of an architect. They design the structure of a system, define processes, describe interrelationships, and ensure that everyone involved—whether people or AI systems—has the same understanding of the project. The larger a project becomes, the more important this skill becomes.

From Programmer to Project Manager

One interesting observation I've made in my own projects is that communication has become much more important than it used to be. People who work with AI often spend more time on specifications, documentation, and design than on the actual coding.

That doesn’t mean technical knowledge is becoming unimportant. On the contrary. Anyone who doesn’t understand the basics of databases, software architecture, or business processes won’t achieve good results with AI either. However, the focus is shifting from pure implementation to management.

One could say that developers are increasingly becoming project managers of their own virtual development teams. These teams no longer consist exclusively of human colleagues, but rather of various AI systems capable of handling different tasks. One AI assists with architecture, another creates documentation, yet another analyzes errors, and still another develops user interfaces.

However, the responsibility remains with humans. AI provides suggestions. It does not make business decisions, is not aware of the company’s goals, and bears no responsibility for the consequences of its work.

Why experience is becoming more important

Some people fear that AI will render expertise obsolete. In my experience, the opposite is true. The more capabilities these tools have, the more important experience becomes. An experienced developer can more quickly determine whether a solution makes sense. They see connections that AI may not have considered. They are familiar with common sources of error and can critically evaluate results.

That is precisely why AI projects often work particularly well when subject matter expertise and artificial intelligence come together. The best results rarely come from blind trust in technology. They arise when an experienced person sets the direction and the AI supports the implementation.

In a way, this reminds me of the introduction of modern machinery in many trades. The tools became more powerful, but the experienced craftsman remained indispensable. He simply had to learn how to use the new tools effectively.

A new way of thinking

Anyone developing software with AI today should therefore not start by thinking about what code the AI should write. The more important question is: How can I describe my project in a way that the AI understands as fully as possible?

This is where the real work begins. The prompt alone does not determine success or failure. What matters is the knowledge behind the prompt. Those who understand their processes, grasp their data structures, and can clearly articulate their goals provide the AI with the foundation for good results.

This is fundamentally changing the field of software development. In the future, a developer’s value will be measured less and less by how quickly they can type code. Far more important will be the ability to analyze complex systems, organize knowledge, and communicate clearly.

The good news is: these skills have always been valuable. AI simply makes them more visible. And that is precisely why successful software development with AI doesn’t start with coding, but with understanding.

Understand first, then program

People working with powerful AI for the first time often experience a surge of excitement. Suddenly, tasks that used to take hours or even days can be completed in just a few minutes. A database structure is quickly designed, a user interface appears at the click of a button, and even more complex program functions often appear on the screen surprisingly quickly.

However, this is precisely where one of the biggest pitfalls of modern software development lies. The speed of the tools tempts developers to start implementation too early. Many developers, entrepreneurs, and project managers jump straight into programming even though they haven’t fully thought through the actual problem yet. While the AI may produce impressive results, it ultimately operates on an uncertain foundation.

The problem here isn't the AI. The problem is the incomplete description of the project. If an AI is given incorrect or incomplete information, it will still try to generate a solution. The result often looks plausible at first. Only later does it become clear that important connections are missing or that fundamental assumptions were wrong.

In my view, this is one of the most common reasons why projects lose valuable time.

The Temptation of a Quick Start

Many developers know this feeling. You have an idea for a new app, open the AI chatbot, and immediately start with the first prompt.

• „Set up a CRM system for me.“
• „Write a warehouse management system.“
• „Develop a project management system with time tracking.“

Such instructions are understandable. After all, you want to see results as quickly as possible. But it is precisely this approach that often leads to having to rework large parts of the system later on.

AI cannot know what makes your company unique. It doesn’t know your customers. It doesn’t know your processes. It doesn’t know what decisions have been made in the past or what constraints need to be taken into account.

An experienced software developer would typically ask a client many questions before beginning the actual implementation. The exact same approach makes sense for AI projects as well.

Instead of jumping right into programming, it’s important to get everything straight first.

What exactly are we trying to create?

This question may sound trivial, but surprisingly often it isn’t answered adequately. Almost every software project has different objectives. Sometimes the goal is to streamline a workflow. In other cases, the focus is on better analytics, lower error rates, or greater automation.

AI can only make meaningful decisions if it knows these goals. Let’s take customer management as an example. At first glance, it seems relatively simple. But after just a few minutes, numerous questions arise.

Is this simply an address management system or a full-fledged CRM system? Are there designated contacts? Are quotes and invoices managed? Does the software need to be multilingual? Are there field sales representatives? Do data protection requirements need to be taken into account?

The more precisely these questions are answered, the better the AI understands the system’s actual purpose. The goal should therefore always be not only to describe the software, but also the business context behind it.

Processes are more important than functions

Another common mistake is to focus exclusively on features. Many project descriptions include phrases such as:

• „There’s supposed to be a customer form.“
• „There should be a search function.“
• „It should be able to generate PDF files.“

While this is important information, it merely describes tools. What’s really interesting are the processes behind them.

• Why is a customer profile required?
• What steps come next?
• Who uses the data?
• What information will be analyzed later?

Modern AI systems are remarkably good at understanding processes when they are described in sufficient detail. That is why it is often worthwhile to document entire workflows. The focus should not be on the question „Which mask do I need?“, but rather on the question:

„How will the user work with the system later on?“

The more precisely this process is described, the better the AI can generate appropriate suggestions.

The Importance of Data

Alongside the processes, data forms the foundation of all software. Many developers underestimate how important a detailed description of data structures is to the success of an AI project.

If an AI only knows that customers exist, that’s not very helpful. The information becomes much more valuable when it also describes which fields exist, what relationships are intended, and how the data will be used later.

In my projects, I've found it helpful to provide real-world examples as early as possible. Sample datasets are often more informative than lengthy theoretical descriptions.

A specific customer record containing the name, address, contact persons, and communication history often provides the AI with a better understanding than several paragraphs of abstract explanations. The same applies to product master data, projects, invoices, or any other information.

The closer the description is to the actual outcome, the better the results will be.

The analysis phase saves time

Many people view analysis and documentation as tedious preliminary work. After all, they want to see productive results as quickly as possible. Paradoxically, it is precisely this impatience that often leads to longer development times.

Every hour spent on a thorough analysis at the outset often saves many hours of corrective work later on. This principle held true long before the age of artificial intelligence and is even more important today.

AI works extremely quickly. However, this also means it can replicate errors very quickly. If you develop a system with unclear specifications, you may end up with hundreds of lines of code for the wrong solution within just a few minutes.

On the other hand, those who first define the requirements precisely lay a solid foundation for all subsequent steps.

Understanding as the foundation for everything else

The most important lesson, therefore, is this: Good software isn’t created by good prompts alone. It’s created through a deep understanding of the problem.

The better you understand a project’s goals, processes, data, and context, the more effectively you can work with AI. Ultimately, the quality of the results depends less on the intelligence of the tool than on the quality of the information you provide.

That is why successful AI-driven software development does not begin with the first line of code. It begins with an effort to understand the problem so thoroughly that another person—or, indeed, an artificial intelligence—can grasp and solve it.

The Perfect Project Launch for an AI

When a new employee joins a company, they aren’t usually just sat down at a desk and told, „Get to work.“ Instead, they receive an orientation. They learn about the company’s goals, receive important documents, understand the processes, and talk to people who already have experience.

The exact same logic applies to working with artificial intelligence. Nevertheless, many developers still treat their AI like a search engine. They ask specific questions, give brief instructions, and then wonder why the results are incomplete or irrelevant. Yet experience shows time and again that the quality of the answers depends heavily on how well the AI was integrated into a project. A well-prepared project integration can make the difference between mediocre and exceptionally good results.

From my own experience, I’ve learned that the initial information an AI receives about a project often has a surprisingly significant impact on the entire course of the project. The better this foundation is established, the more productive the collaboration becomes.

Explain the project in simple terms

The first step is to describe the project as a whole. Many developers make the mistake of jumping straight into technical details. They talk about databases, programming languages, or interfaces before it’s even clear what problem needs to be solved. For AI, however, the business context is what matters most at first.

Imagine you want to develop an ERP system. Instead of jumping right into tables and field names, you should first describe who the software is intended for, what tasks it is supposed to perform, and what goals it aims to achieve. A good project kickoff addresses these fundamental questions:

• Who will be using the system in the future?
• Which processes should be supported?
• What problems need to be solved?
• What are the special features?

Only once these relationships are clear does it make sense to delve into the technical details. You can think of it like building a house. Before discussing electrical outlets or water pipes, it should be clear whether the project involves a single-family home, an office building, or a warehouse.

The technical framework

Once the conceptual foundations have been explained, we move on to the technical environment. The goal here is to define the parameters within which the AI is expected to operate. These include, for example, the programming languages, database systems, frameworks, and target platforms used.

This step is more important than many people might initially think. A solution that works well for a web application is not necessarily suitable for a desktop application. Similarly, the capabilities of different database systems can vary significantly.

The more specific the framework conditions are described, the more effectively the AI can work. It is important to document not only current technical decisions but also existing guidelines. There may already be legacy systems, existing interfaces, or specific corporate standards in place. This information also helps the AI develop realistic recommendations.

The Data Model as the Foundation

At this point, at the very latest, it becomes clear why thorough preparation is so valuable. Data plays a central role in virtually every major software project. Customers, products, projects, invoices, documents, and user accounts form the foundation of the final application.

That is why it is worthwhile to provide the AI with an overview of the data model as early as possible. The initial focus is not on creating perfect technical documentation. Rather, what matters is that the AI understands the basic relationships.

• What tables are available?
• Which objects are related to one another?
• What information is stored?
• What data is particularly important?

The more clearly this structure is described, the easier it is for the AI to correctly classify subsequent requirements. Many projects have shown that the quality of subsequent program proposals is directly linked to an understanding of the data model. Those who neglect this area are often confronted with misunderstandings and unnecessary corrections.

Why sample data is so valuable

One of the most effective ways to help an AI system understand a system is to provide real-world examples. People often learn by example. AI systems work in a similar way in many situations.

A theoretical description of a customer base can be helpful. However, a real-world sample dataset often provides much more information. Suddenly, the AI recognizes typical content, naming conventions, data formats, and relationships. It better understands which information is actually relevant and how it will be used later. The same applies to product master data, invoices, projects, or any other objects within a system.

Of course, data protection and confidentiality must be taken into account. In many cases, anonymized sample data is entirely sufficient. What matters is not the authenticity of the individuals or companies, but the structure of the information.

Learning the Language of AI

An interesting side effect of working with AI is that developers learn to describe their own systems more clearly. Many connections that seem obvious in their own minds suddenly need to be articulated. This brings to light ambiguities that were previously hardly noticeable.

This process is similar to writing technical documentation. As soon as you try to explain something precisely, you often realize there are areas that haven’t been fully thought through yet.

That is precisely why introducing a project is not only helpful for the AI, but often for the developer as well. Anyone who can explain their project in a way that an AI can understand usually has a much better grasp of it themselves.

An investment that pays off many times over

Some developers initially view a detailed project kickoff as an extra burden. In reality, however, it is one of the most profitable investments in an AI project.

Every hour spent at the outset defining goals, processes, data, and technical parameters can save many hours of rework later on. As a result, the AI no longer operates blindly, but rather on the basis of a shared understanding of the project.

It is precisely this shared understanding that forms the foundation for everything that follows. It determines whether AI will merely perform individual tasks or evolve into a true development partner.

That is why the project launch should never be viewed as a chore. It is the moment when the foundation for all future collaboration is laid. The stronger that foundation, the better the results will generally be.

Context is more important than code

Many developers initially assume that modern AI systems are particularly good at programming. After all, the most impressive examples are often demonstrated using code. An AI can generate a website, develop a database query, or write an entire function in a matter of seconds.

However, practical experience often paints a different picture. The true strength of modern AI does not lie primarily in writing code. Its greatest strength lies in linking information, recognizing patterns, and applying knowledge to new situations.

That is exactly why context is so important. When AI understands the context, it often produces surprisingly good results. Without that context, it continues to generate answers and code, but it does so on an uncertain foundation. The quality of the results then often drops significantly, even if the code appears technically correct.

In practice, it becomes clear time and again that it is not the code that is the key building block of AI, but rather the context in which that code is created.

Why brief instructions often lead to poor results

People who are new to working with AI often tend to formulate tasks very briefly. A typical prompt might be:

„Set up a customer management system.“

From a technical standpoint, this statement is not incorrect. However, it leaves out almost all of the important details.

• For which industry?
• How many users?
• What data should be stored?
• Which processes should be supported?
• What reports are needed?
• What systems are already in place?

The AI has to answer all these questions on its own and inevitably makes assumptions. Some of them will happen to be correct, others will not. The result is comparable to an architect who is simply told:

„Build me a house.“

Of course, he can design a house. However, the likelihood that it will match your exact vision is low. The more relevant information is missing, the greater the room for interpretation. And it is precisely this room for interpretation that often leads to unnecessary revisions later on.

The Difference Between Information and Context

One important point is often overlooked in discussions about AI. Information and context are not the same thing. Information consists of individual facts, such as:

• The system uses PostgreSQL.
• There is a customer table.
• The application runs in the browser.

This information is useful, but it is usually not enough. Context only emerges when the connections between these pieces of information become clear.

• Why is PostgreSQL used?
• What role does the customer table play in the overall system?
• Which users are using the application?
• Which business processes are involved?

AI needs not only facts, but also their meaning. Only then can it make decisions that are appropriate for the project. The more complex a project becomes, the more important this distinction becomes.

The AI is designed to understand the company

An interesting observation from real-world experience is that the best results often come when AI understands not only the software, but also the company behind it.

Let’s take the example of an ERP system again. It makes a significant difference whether this system is developed for a small business, a wholesaler, a medical practice, or an online retailer. Many technical requirements stem directly from the business model.

If you simply explain the technical structure to an AI, you leave much of the interpretation up to it. If, on the other hand, you also describe the company’s processes, you provide a much more valuable context. That is why it is often worthwhile to first introduce the organization to the AI.

• How does the company make money?
• Which processes are particularly important?
• Where do typical problems arise?
• What are the software's objectives?

At first glance, this kind of information may seem to have little to do with programming. In fact, however, it often significantly improves the quality of the technical results.

Context reduces errors

One of the greatest strengths of a good project context is that it significantly reduces the likelihood of poor decisions. Let’s imagine that an AI is tasked with developing a new feature. Without context, it knows only the current task. It tries to solve it as efficiently as possible.

With enough context, it also knows:

• the architecture of the overall system
• existing design principles
• previous decisions
• technical framework
• long-term goals

This allows it to automatically adapt many suggestions to the existing structure. The quality of the results often improves not gradually, but in leaps and bounds. For this reason, experienced developers often spend more time providing context than formulating individual tasks.

Documentation as a Context Repository

This highlights the enormous importance of good project documentation. No developer wants to have to explain the same information over and over again. The same applies to working with AI systems.

A central documentation system therefore serves as a permanent repository of context. Important information can be collected there:

Project objectives, data models, architectural decisions, naming conventions, technical specifications, and open questions.

New chatbots or AI systems can then access this documentation and familiarize themselves with the project. The larger a project becomes, the more important this approach becomes. In a sense, this creates a kind of collective memory for the project. It benefits not only humans but also AI.

More context doesn't mean more text

This is where a common misunderstanding often arises. Providing more context does not automatically mean producing as many pages of text as possible.

What matters most is the relevance of the information. A concise five-page description can be far more valuable than fifty pages of unstructured text. The key is to provide the information that is truly essential for understanding a project. This includes, in particular:

• Goals
• Processes
• Data Structures
• technical framework
• Architectural decisions
• real-life examples

Those who document these areas thoroughly usually lay an excellent foundation.

Why context will become more important than programming in the long run

The more powerful AI systems become, the more the focus shifts from actual programming to the transfer of knowledge.

Code is increasingly becoming a resource that can be generated automatically. Context, on the other hand, remains a human task. Only humans know a company’s goals. Only humans understand political, organizational, or economic contexts. Only humans can determine the long-term direction a project should take.

AI can use this knowledge, expand upon it, and translate it into technical solutions. However, it cannot generate it on its own. That is why context will likely become one of the most valuable resources in software development in the future.

If you provide AI with the right context, you’ll often get surprisingly good results. If you skip this step, however, you’ll frequently find that even perfectly written code doesn’t automatically lead to good software. After all, successful software isn’t created by individual lines of code, but by understanding the context from which those lines of code emerge.

Dividing large projects into specialist chat groups

People who are new to developing with AI software usually work in a single chat. That makes sense. You start with an idea, describe the requirements, and develop the project step by step.

This approach often works very well for small projects. A single application, a script, or a manageable database can easily be discussed in a chat.

However, as projects grow in size, the requirements change. Suddenly, there are numerous tables, different user roles, multiple interfaces, extensive documentation, and hundreds of decisions made throughout the development process. At the same time, new requirements emerge, while older information becomes increasingly outdated.

At this point, at the latest, an important insight becomes clear: Large software projects should be structured in the same way as large companies.

No one would expect a single employee to be a CEO, accountant, salesperson, developer, designer, and support representative all at once. That is exactly why it’s important to keep different areas of responsibility separate when working with AI.

While the idea that a single conversation can provide ongoing support for an entire large-scale project is appealing, it becomes increasingly impractical as complexity increases.

The idea behind expert chats

One of the most effective approaches in larger AI projects is to set up multiple chat groups with clearly defined scopes of work. Each of these chat groups has its own focus and, over time, develops a specific area of expertise.

The principle is similar to that of traditional development teams. In a company, there are often specialists in databases, user interfaces, infrastructure, documentation, or quality assurance. No one has to do everything at once.

Surprisingly, this same concept works very well for AI systems. Instead of typing all questions into a single chat, different topics are specifically assigned to multiple sections. This keeps conversations more organized and allows the AI to focus more intently on its specific area of responsibility. At the same time, it reduces the risk of important information getting lost among many different topics.

The Architecture Chat

The architecture chat often serves as the strategic hub of a project. This is where fundamental decisions are made.

• Which data structures should be used?
• What does the system architecture look like?
• What modules are available?
• What naming conventions apply?
• What technical principles should be followed?

This chat focuses less on individual lines of code and more on the big picture.

In many projects, it has proven effective to document architectural decisions in a centralized location whenever possible, rather than constantly switching between different chat channels. This creates a solid foundation for all further work.

In a sense, the architecture chat thus becomes the technical memory of the project.

The Backend Chat

While the architecture chat addresses fundamental questions, the backend chat focuses on the actual business logic. This is where database queries, interfaces, automations, and complex processes are developed.

In this area, AI can focus entirely on the technical requirements without being constantly distracted by design issues or documentation matters.

Especially on larger projects, this separation often leads to significantly better results. Over time, the backend team becomes an expert in internal workflows and technical processes. This makes collaboration more efficient and transparent.

The Front-End Chat

User interfaces often follow rules that are completely different from those of backend systems. Here, the focus is on usability, navigation, layouts, and workflows. A frontend chat can specifically address these issues.

• What information must be visible?
• What input fields are required?
• What should the structure of a mask be?
• What steps does a user go through while working?

Because this chat does not have to handle complex database logic or architectural issues at the same time, it can focus much more on the user's perspective.

Developers, in particular, sometimes tend to prioritize technical considerations over user-friendliness. Having a dedicated front-end chat helps strike a better balance.

The Documentation Chat

Many projects fail not because of technical issues, but because of a lack of documentation. At first, everything seems logical and obvious. A few months later, however, no one can remember why certain decisions were made.

Having a dedicated documentation chat channel can be extremely beneficial. Its purpose is to record technical decisions, create project overviews, document changes, and ensure that knowledge remains accessible over the long term.

This chat should work as closely as possible with the other project teams. Whenever new features are developed or architectural decisions are made, the documentation can be updated.

Step by step, this creates a valuable reference guide for the entire project.

The Quality Assurance Chat

One particularly interesting approach is to assign AI an additional role as a reviewer. Instead of developing new features, this chatbot reviews the work of other chatbots. It analyzes:

• possible errors
• Security issues
• Inconsistencies
• Performance Risks
• Gaps in the documentation

This approach is reminiscent of traditional code reviews in development teams. The main advantage is that it brings different perspectives to the table.

While a development chat often focuses on implementing a task as quickly as possible, a quality assurance chat takes a critical look at the same solution and specifically searches for weaknesses. This additional layer of oversight can significantly improve the quality of a project.

The shared knowledge base

However, multiple specialist chats only work well if they all draw on the same knowledge base. That is precisely why centralized project documentation plays such an important role. All chats should have access to the same basic information:

Project objectives, architectural decisions, data models, naming conventions, and technical requirements.

This approach avoids creating a hodgepodge of unrelated subprojects and instead results in a unified system with a clear structure. You could say that the documentation serves as the common language for all chats.

Without this common language, there is a risk of misunderstandings and conflicting results.

AI as a virtual development team

The longer you work with this approach, the clearer an interesting idea becomes. Modern AI systems are increasingly behaving like a virtual development team.

Of course, these aren't real people. Nevertheless, many of the tried-and-true organizational principles of traditional software projects can be applied surprisingly well here. Instead of relying on a single jack-of-all-trades, several specialized roles with clear responsibilities are created.

This makes projects clearer, more transparent, and often of higher quality. This approach can make a huge difference, especially for larger projects. After all, successful software development isn’t just about coding. It involves planning, architecture, documentation, quality assurance, and communication.

The better these areas are kept separate from one another while remaining interconnected, the more successful the project as a whole tends to be. And this is precisely where specialist chats really shine.

Central Project Documentation

Almost every major software project begins with a clear vision. The goals are known, the requirements seem manageable, and the key decisions are clear to everyone involved. In this early phase, it often seems that extensive documentation isn’t really necessary. After all, you know why certain decisions were made. The data structures are familiar, the processes are transparent, and the architecture seems logical.

But with every passing day of development, the situation changes. New features are added. Requirements shift. Previous decisions are expanded or adjusted. Additional developers join the project. New AI chatbots are launched. Exceptions and special cases arise. What seemed completely straightforward just a few weeks ago is slowly beginning to fade.

This is precisely where the true value of good project documentation becomes apparent. Its primary purpose is not to generate paperwork or fill filing cabinets. Its most important function is to ensure that knowledge remains permanently accessible. You could say that the documentation becomes the project’s memory.

Why AI projects require a particularly high level of documentation

Interestingly, documentation is not becoming less important with modern AI systems; on the contrary, it is becoming significantly more important. In traditional projects, people could keep a lot of information in their heads or pass it on through conversation. When working with AI systems, however, this is only possible to a limited extent.

• Every new chat starts with no project information.
• Every new conversation is based solely on the information provided to it.
• Any additional AI needs context to function effectively.

This gives rise to a new requirement: knowledge must be systematically stored. As a result, documentation is no longer merely a tool for humans, but also a source of knowledge for AI systems. The larger a project becomes, the greater this advantage becomes.

Good documentation makes it possible to get new chats up and running in just a few minutes, rather than having to explain important information over and over again.

What should be documented

A common question is what exactly needs to be documented. The answer is simpler than many people think. Above all, decisions should be documented. Source code can be regenerated or analyzed at any time. It becomes more difficult when it comes to the reasoning behind the code.

• Why was a particular architectural style chosen?
• Why was the table structured this way?
• Why was an interface implemented this way and not another?
• Why was an alternative solution rejected?

Without documentation, this kind of information is often lost. When a change becomes necessary a few months later, even experienced developers often can’t recall all the reasons behind earlier decisions. Good documentation preserves this knowledge for the long term.

The project overview as a starting point

All documentation should begin with a clear project overview. This section serves as a starting point for everyone involved. It explains:

• What is the goal of the project?
• What problems need to be solved?
• What are the main modules?
• What technologies are used?
• What is the long-term vision?

This section doesn't need to be particularly long. Often, just a few pages are enough. What's more important is that a new developer or a new AI chatbot can quickly grasp what it's all about.

The project overview serves, in a sense, as a roadmap for the entire project. Without this roadmap, even well-documented individual details can quickly become confusing.

Document the data model

According to the project overview, the data model is one of the most important components of the documentation. Virtually every application is based on data. Customers, products, projects, invoices, users, and documents are all interconnected and form the foundation of the system. Therefore, the following should be documented:

• What tables are available?
• Which fields are particularly important?
• What connections exist?
• What are the applicable business rules?

It’s not just about technical information. The business significance of the data is just as important. A field name alone often doesn’t tell us much. Only a description of its function makes it clear why it exists and how it should be used.

This context is particularly valuable for AI systems. The better the data structures are described, the more precise the resulting suggestions will be.

---

Current survey on the use of local AI systems

---

Document architectural decisions

One of the biggest weaknesses of many projects is that architectural decisions are made only verbally. At the time the decision is made, everything seems logical. A few months later, however, it is often unclear why a particular approach was chosen.

That is exactly why it is important to document key decisions. Not only should the decision itself be documented, but also the reasoning behind it.

• What alternatives were considered?
• Why were they rejected?
• What are the benefits of the chosen solution?

This approach often saves a tremendous amount of time down the line. Instead of having to revisit old discussions, developers and AI systems can draw on the existing information.

Open issues and known problems

Good documentation describes not only the current status but also what is still in progress. Many projects suffer from the fact that outstanding tasks are scattered across various locations. Some are in emails, others on sticky notes, and still others in chat histories.

This results in important information being lost. It has proven effective to compile open issues in a central location. These include, for example: planned enhancements, technical debt, known bugs, requests for improvements, and future ideas.

This provides a valuable overview, especially for long-term projects. New developers or AI systems can immediately see which issues have already been addressed and what work still needs to be done.

Documentation as a living system

A common mistake is to view documentation as a one-time task. People create a few documents at the start of a project and then rarely update them. As a result, the documentation quickly loses its value. Good project documentation is a living document. It grows along with the project. New decisions are added. Changes are recorded. Outdated information is updated or removed.

Ideally, this should be done on an ongoing basis throughout the development process. Modern AI systems can even actively assist with this. They can generate summaries, document changes, or update existing content. This significantly reduces the workload.

The most important investment in a project

Many developers invest large sums of money in hardware, software licenses, or external services. In doing so, they often underestimate one of their most valuable resources: their own knowledge of the project.

It is precisely this knowledge that documentation preserves. It ensures that experience is not lost. It prevents the same questions from having to be answered over and over again. And it creates a common foundation for people and AI systems.

The larger a project becomes, the more important this function becomes. Those who neglect their documentation may save time in the short term, but often end up losing many times that amount in the long run. On the other hand, those who establish a centralized knowledge management system early on create a foundation that can provide benefits for years to come.

That is why project documentation is much more than just a collection of technical information. It is the collective memory of a project—and thus one of the most important prerequisites for successful software development using AI.

Vibe Coding, Structure, and the New Generation of Software Development

The embedded video provides an interesting complement to the content of this article and demonstrates how modern AI tools can already be used today to develop custom applications with relatively little programming effort. Particularly noteworthy is the emphasis on a structured approach. Instead of simply letting the AI „just start programming,“ the video demonstrates how ideas are first carefully planned, database structures are built, and interfaces are defined.

Software Development with AI: The Right Approach (Instead of Chaos) | Sebastian Claes

This approach aligns perfectly with one of the key takeaways of this article: successful software development doesn’t start with the code, but with an understanding of requirements and processes. The video also highlights current tools such as n8n, Supabase, and MCP, as well as the possibilities offered by automated workflows. Particularly valuable are the insights into common pitfalls of so-called „vibe coding“ and the recommendations for stable, scalable, and long-term maintainable applications. In doing so, the video provides a practical insight into modern collaboration between developers and artificial intelligence.

Start prompts for new chats

One of the greatest strengths of modern AI systems is their ability to quickly familiarize themselves with complex topics. At the same time, this very same ability is also one of their greatest weaknesses.

Every new chat starts with the AI having no knowledge of your project. Of course, modern models have extensive general knowledge. They are familiar with programming languages, databases, frameworks, and many technical concepts. What they don’t know, however, are the specifics of your project.

They don't know what architectural decisions have already been made. They aren't familiar with your naming conventions. They know nothing about previous discussions or the goals behind certain features.

Many developers underestimate this point. They open a new chat, ask a technical question, and then wonder why the answer doesn’t quite fit their existing project. Often, the problem isn’t the quality of the AI, but rather a lack of project context. This is exactly where start prompts come in.

What a startup prompt actually is

A startup prompt is essentially nothing more than a standardized introduction for new chats. It contains the key information an AI system needs to get up to speed on the project as quickly as possible. You could compare it to an onboarding folder for a new employee. Instead of having to explain the same information over and over again, the AI receives the most important background information right from the start. This creates a shared understanding of how things work even before the actual task begins.

A good startup prompt doesn't just save time. It also ensures that different chats operate consistently and make similar decisions. The larger a project becomes, the more valuable this effect becomes.

Clearly define the role of AI

One of the most effective methods is to assign the AI a specific role from the start. Many developers simply include technical requirements in their prompts. However, describing the desired perspective in addition to these requirements often leads to better results.

For example, AI can function as a software architect, senior developer, database specialist, tester, or documentation writer. This often improves the quality of the responses. The AI is given a clear frame of reference and can better tailor its suggestions to the specific task at hand.

In an architecture chat, she will focus on different priorities than in a testing or documentation chat. This clear definition of roles creates structure and reduces misunderstandings.

Project documentation: required reading

A particularly important component of many startup prompts should be the core project documentation. Ideally, the AI should be instructed to familiarize itself with the existing information before developing changes or suggestions.

This step is surprisingly often overlooked. Yet many problems arise precisely because new chat groups operate without being aware of existing decisions. When documentation is consistently incorporated, the quality of collaboration often improves significantly.

AI identifies patterns more quickly. It understands existing structures better and automatically takes previous decisions into account. This results in significantly greater consistency within the project.

You could say: The documentation provides the knowledge, while the startup prompt ensures that this knowledge is actually put to use.

Establishing uniform rules

As projects grow in size, there is often a need for clear guidelines.

• How should fields be named?
• What documentation standards apply?
• What architectural principles must be followed?
• Which coding guidelines are mandatory?

A good prompt can help embed these rules permanently. This means they don’t have to be explained all over again for every new task. The AI already knows the guidelines and can tailor its suggestions accordingly.

This effect should not be underestimated. Many minor inconsistencies arise simply because rules are not consistently communicated. Start prompts help reduce this very problem.

Different startup prompts for different tasks

As a project progresses, it often becomes clear that not all chat channels have the same requirements. An architecture chat channel requires different information than a documentation chat channel. A testing chat channel operates differently than a front-end chat channel.

That’s why it’s often a good idea to develop multiple starter prompts. The core elements remain the same across all of them. All chats have the same project overview, the same documentation, and the same basic rules.

However, task-specific additions can also be defined.

• The Architecture Chat focuses on long-term decisions.
• The backend chat: technical implementation.
• The documentation chat focuses on traceability and knowledge retention.
• The quality assurance chat on error analysis and critical review.

This specialization often yields significantly better results than using a generic standard prompt.

Start prompts evolve as the project progresses

A common mistake is to create a kick-off document once and then never update it again. In practice, however, every major project is constantly evolving.

New modules are being developed. Processes are changing. Technical decisions are being made. That is why startup prompts should also be reviewed regularly. What was sufficient a few months ago may already be incomplete today.

It has proven effective to treat start prompts as living documents. They evolve alongside the project and reflect its current status. This ensures that new chats are always up to date.

AI should think for itself, not just follow orders

One interesting aspect of modern AI systems is that they can do more than just follow instructions. They can also question, analyze, and suggest improvements. A good starting prompt should therefore not consist solely of commands.

It is often worthwhile to explicitly ask the AI to point out potential issues. For example, you can specify that inconsistencies should be reported or that architectural violations must be actively addressed. This transforms the AI from a mere tool into an additional conversation partner.

Of course, it doesn't replace human judgment. However, it can help identify risks early on.

The Path to a Professional Work Ethic

Many developers start working with AI spontaneously and intuitively. That’s perfectly normal. However, as projects grow in size, it becomes clear that structured processes offer enormous advantages.

Start prompts are part of these processes. They establish a common foundation for all chats, reduce repetition, and ensure consistent results. Above all, they enable the systematic transfer of knowledge.

This very point is likely to become increasingly important in the future. After all, the larger the projects and the more powerful the AI systems become, the more the quality of preparation will determine the success of a project.

A good opening prompt is therefore much more than just a few introductory sentences. It’s the ticket to a project. And often, this ticket alone determines how productive the subsequent collaboration will be.

Iterative development instead of massive prompts

People working with modern AI for the first time often look for that one magic prompt that will solve all their problems. It’s a tempting idea. You describe your project in as much detail as possible, click „Send,“ and shortly thereafter receive a finished concept, a complete database structure, or even a fully functional software system.

At first glance, this approach seems logical. After all, modern AI systems have impressive capabilities. So why not try to have them handle as much work as possible at once?

In practice, however, the reality is quite different. The larger and more complex a task becomes, the more important a structured approach becomes. The best results rarely come from a single, massive prompt; rather, they result from a series of steps that build on one another.

Just as a house isn’t built in a single step but involves planning, laying the foundation, constructing the shell, finishing the interior, and fine-tuning, successful software is also developed step by step. AI speeds up this process, but it doesn’t replace it.

Why large-scale projects are problematic

Many developers initially encounter a similar situation. They formulate a very detailed requirement and receive an impressive response. Upon closer inspection, however, they realize that important details are missing or that certain assumptions do not align with the project.

This isn't because the AI isn't working properly. Rather, the complexity of the task increases with every additional requirement. The larger the task becomes, the more interrelated factors must be taken into account simultaneously. At the same time, the likelihood that individual details will be overlooked or misinterpreted increases.

This can quickly lead to problems, especially in larger software projects. A small error in the data model can potentially affect numerous other areas. An unclear requirement can result in extensive rework later on. That is why it usually makes more sense to break large projects down into smaller, manageable steps.

The Power of Small Steps

One interesting feature of modern AI systems is their ability to respond to new information with exceptional speed. This makes an iterative approach particularly appealing.

Instead of trying to develop an entire system all at once, we start by working on a small section. This section is reviewed, improved, and documented. Only then do we move on to the next step.

This approach is reminiscent of modern agile development methods. Instead of spending months working toward a single major end result, many small intermediate results are produced. Each of these results can be evaluated and corrected as needed. This significantly reduces risk. Errors are identified earlier, and adjustments are easier to implement.

From the big picture to the details

A best practice is to start by defining the big picture. The process begins with questions such as:

• What problem needs to be solved?
• What are the main modules required?
• Which users are using the system?
• What data needs to be managed?

Only once these fundamentals have been clarified can we move on to the next level.

• The individual modules will now be described in more detail.
• This is followed by the development of data models, processes, and user interfaces.
• This is followed by technical details and specific implementations.

This step-by-step transition from the general to the specific has a major advantage. The AI can develop each level based on decisions that have already been validated. This results in a significantly more stable structure.

The Importance of Midterm Exams

A common mistake is to accept results immediately without scrutinizing them thoroughly. Precisely because AI works so quickly, there is sometimes a temptation to move on to the next step right away. In the long run, however, it often makes more sense to consciously pause after each major milestone.

• Does the result align with the project objectives?
• Have all requirements been taken into account?
• Are there any potential vulnerabilities?
• Are the decisions documented in a way that is easy to understand?

While such interim reviews do take some time, they often save a considerable amount of effort in later project phases. The sooner problems are identified, the less costly it is to correct them.

Iterations as a learning process

Another advantage of iterative development is that it’s not just the AI that learns, but the developer as well. Many requirements only become truly apparent as work progresses.

• A process that initially seems sensible may turn out to be impractical.
• A data structure needs to be extended.
• A user interface requires additional information.

Such insights are a natural part of any project. The iterative approach does not treat them as problems, but rather as a natural part of the development process. Each iteration improves the team’s shared understanding of the system. As a result, quality improves step by step.

Why perfection rarely makes sense at the beginning

Many developers try to find perfect solutions right from the very first discussions. That’s understandable, but often unnecessary. In practice, the best systems usually evolve through many small improvements.

The first version of a data model doesn't have to be perfect. Neither does the first user interface. What's more important is creating a functional foundation that can be further developed later on.

This is exactly where AI really shines. It enables rapid adjustments and supports continuous improvement. This makes it much easier to test ideas and optimize them step by step.

AI as a sparring partner

Those who work iteratively don't just use AI as a tool for execution. It becomes a conversation partner. New ideas can be discussed. Alternatives can be compared. Risks can be analyzed.

This makes the development process more dynamic. Instead of having to wait a long time for an idea to be implemented, concrete proposals emerge within a short period of time, which can then be evaluated and refined.

This dialogue often leads to better results than rigid planning that spans many months.

The Path to Better Results

The larger a project becomes, the more evident the benefits of an iterative approach become. Large systems are rarely the result of a single brilliant design. They are the result of many decisions that build upon one another.

• Every step brings new insights.
• Each iteration improves our understanding.
• Every check improves quality.

Modern AI systems significantly speed up this process. However, they do not replace it. That is why developers should resist the temptation to try to solve everything with a single massive prompt.

The most successful projects rarely result from a single grand idea. They are the result of many well-thought-out small steps that, when combined, form a larger whole. And that is precisely one of the most important lessons of modern AI-driven software development.

AI as a virtual development team

Many people still view artificial intelligence as a particularly powerful tool. While this view is not wrong, it often falls short. Anyone who works with modern AI systems for an extended period of time will, sooner or later, have an interesting experience. The collaboration feels less and less like using a tool and more and more like working with a team.

Of course, AI has no consciousness, no interests of its own, and no personal responsibility. Nevertheless, it can take on various roles, offer different perspectives, and handle tasks that would previously have been divided among several employees.

This is precisely where one of the most exciting developments in modern software development lies. True strength often does not come from a single AI being particularly intelligent. Rather, it arises from combining multiple specialized approaches.

This does not replace the developer. Rather, the developer’s role shifts toward coordination, management, and quality control.

Why a single perspective is often not enough

In traditional software projects, not everyone involved typically shares the same perspective. An architect thinks differently than a programmer. A tester focuses on different aspects than a designer. A project manager asks different questions than a database specialist. These different perspectives offer a major advantage: errors are detected earlier, and solutions are considered from multiple angles.

This principle, in particular, translates surprisingly well to AI systems. Instead of using AI solely as a programmer, we can assign it various roles and have it examine the same problem from different perspectives.

This often leads to significantly better results. For example, an architecture chatbot can design a solution, while a quality assurance chatbot can critically review that same solution.

Although the discussion takes place within various AI systems, it follows the same principles as in traditional development teams.

The Virtual Software Architect

The role of the software architect is particularly valuable. This discussion focuses less on individual features and more on the long-term implications of decisions.

• What structure makes sense?
• Which modules should be separated?
• How can future expansions be taken into account?
• What risks arise from certain design decisions?

While developers are often understandably focused on the task at hand, the virtual architect takes a view of the entire system. This provides an additional layer of security.

Many problems down the line can be avoided if fundamental architectural issues are carefully considered early on. This approach can be particularly valuable in larger projects.

The Virtual Developer

The most obvious role, of course, remains that of the developer. This is where concrete solutions, database queries, interfaces, user interfaces, and business logic are created. The productivity of modern AI systems in this area is impressive. Tasks that would previously have taken several hours or days can often be completed in just a few minutes.

However, there is one important point that should not be overlooked. The speed of implementation must not lead to a neglect of analysis and review. Even the best virtual developer needs clear guidelines, well-defined goals, and solid documentation.

The stronger this foundation is, the better the results tend to be.

The Virtual Tester

There is one role that is still underestimated in many projects: the tester. Developers understandably focus on creating solutions. Testers focus on finding problems.

This approach is fundamentally different. A test chat can specifically search for vulnerabilities. It can simulate error scenarios, examine edge cases, and ask critical questions.

• What happens if the input is invalid?
• How does the system handle missing data?
• What security issues could arise?
• What special cases were overlooked?

This perspective often reveals insights that were not apparent during the actual development process. That is why it is often worthwhile to have new features reviewed by a separate AI role.

The Virtual Documentation Author

Documentation is rarely one of the most popular tasks in a project. At the same time, it is one of the most important. A virtual documentation writer can help systematically capture knowledge. They create project descriptions, document decisions, summarize meetings, and maintain technical documentation.

The main advantage is that this work can be carried out in parallel with development. Instead of catching up on documentation at the very end, it becomes an ongoing part of the project.

This ensures that knowledge remains permanently accessible, and new team members—whether human or AI—can get up to speed much more quickly.

The Virtual Critic

One particularly interesting role is that of the critical reviewer. This chat has a different objective than the other participants.

He shouldn't just agree. He should question things.

It analyzes assumptions, identifies weaknesses, and assesses whether decisions really make sense. Developers, in particular, sometimes tend to become attached to a particular solution. That’s only human. A critical AI chatbot can help bring alternative perspectives to light.

• Maybe there's an easier solution.
• Perhaps an important requirement was overlooked.
• There may be long-term risks.

Such tips are often extremely valuable.

People remain project managers

Despite all the enthusiasm surrounding modern AI systems, one thing should remain clear: the responsibility lies with humans. AI can make suggestions. It can analyze, review, and document. It can even simulate different perspectives. However, the final decisions are still made by the developer, entrepreneur, or project manager.

That makes sense. Only people know the business objectives of a project. Only people can fully assess economic, legal, or strategic considerations.

AI expands our possibilities. However, it does not replace responsibility.

The Future of Teamwork

The longer you work with AI, the clearer it becomes that successful projects increasingly resemble a collaboration between humans and digital specialists. Developers no longer work alone. At the same time, they are not being replaced. Instead, a new form of teamwork is emerging.

A person sets the direction, makes decisions, and takes responsibility for the outcome. Several specialized AI roles assist them with analysis, development, documentation, testing, and quality assurance.

That, in fact, could be one of the biggest changes in the coming years. The decisive factor will not be whether AI replaces humans, but rather how well humans learn to collaborate with a virtual development team.

Those who master this collaboration will be able to deliver software projects more quickly, in a more structured manner, and with higher quality than ever before.

AI Agents, Skills, and the Next Stage in Software Development

The embedded video from Fraunhofer IEM picks up on an idea that is also touched upon several times in this article: The future of software development could be shaped less by individual applications and much more by knowledge, context, and specialized AI agents. The focus is on so-called „skills“—structured knowledge and task modules that enable AI systems to perform complex tasks independently.

AI Agents & Skills: The End of Traditional Software Development? | Fraunhofer IEM

What is particularly fascinating here is the parallel to modern AI-driven software development: the focus is no longer on individual lines of code, but rather on the description of processes, rules, and relationships. The video clearly explains how technologies such as MCP (Model Context Protocol), agent-based systems, and central knowledge sources can work together. The question of whether traditional software will be supplemented or partially replaced by flexible agent-based systems in the long term is also discussed. Regardless of how quickly this development progresses, the video impressively demonstrates why context, documentation, and knowledge management could become among the most important resources for modern software projects in the future.

Common Mistakes in AI-Driven Development

The history of technology repeatedly follows a similar pattern. As soon as new tools become available, many people initially focus on the possibilities and pay far less attention to the risks. This was the case with the first computers, with databases, with the introduction of the Internet, and today with artificial intelligence.

The excitement is understandable. Modern AI systems can complete tasks in just a few minutes that used to take hours or days. They analyze requirements, develop concepts, write code, and assist with documentation.

But it is precisely this speed that sometimes causes problems. Many errors do not occur because the AI is performing poorly. They occur because people misjudge how the AI works or neglect important fundamentals.

Anyone who wants to develop AI successfully over the long term should therefore be aware of the most common pitfalls.

Mistake #1: Not enough context

Probably the most common mistake is providing the AI with too little information. Many developers formulate very brief instructions and still expect highly accurate results.

• The AI is supposed to develop a function, but it isn't familiar with the project.
• She is supposed to design a database structure, but she knows nothing about the business processes.
• She is supposed to design a user interface, but she doesn't know who the future users will be.

Of course, the AI can still provide answers. It will try to make reasonable assumptions based on its general knowledge. The problem is that these assumptions may not necessarily apply to your project. The larger the knowledge gap, the greater the likelihood of misunderstandings.

That's why there's a simple rule: If a result doesn't meet expectations, the cause is often not the AI itself, but a lack of context.

Mistake #2: Taking on tasks that are too big

Another common mistake is assigning too many tasks to the AI at once. Beginners, in particular, tend to write very lengthy instructions. They want to develop a complete ERP system, design an entire platform, or have a full-fledged business software solution created.

This idea is understandable. After all, the capabilities of modern models are impressive. In practice, however, the best results are usually achieved through a step-by-step approach. Large projects should be broken down into smaller, clearly defined tasks.

• First, the architecture is developed.
• Next, the data model.
• Next, individual modules.
• Next, the user interfaces.
• Finally, testing and optimization.

This approach not only improves the quality of the results but also makes it easier to monitor progress. Small steps are much easier to review than massive, comprehensive solutions.

Mistake #3: Lack of documentation

Many developers are already familiar with this problem from traditional projects. As long as everything is fresh in their minds, documentation seems unnecessary. A few weeks or months later, the situation usually looks quite different.

• Why was this table created?
• Why was that architectural decision made?
• Why was a particular solution chosen?

Without documentation, this information is lost. In AI projects, this oversight often has an even greater impact. New chatbots have no knowledge of previous conversations. New project members are unaware of the background context. Important decisions have to be explained over and over again.

This leads to unnecessary discussions and duplication of effort. Consistent project documentation is therefore one of the most important factors for success in modern software development.

Mistake Number 4: Blind Trust

The quality of today's AI systems can be impressive. That is precisely why a dangerous temptation sometimes arises: we begin to stop questioning the results sufficiently. This mistake is particularly common among developers who have just experienced their first major successes with AI.

Suddenly, complex queries work. Interfaces are created automatically. Documentation is generated in a matter of minutes. But despite all this progress, one important fact remains:

• AI can make mistakes.
• She may misinterpret the context.
• It may be based on outdated assumptions.
• It can develop technical solutions that appear plausible but still have weaknesses.

That is why every important decision should be reviewed. Trust is wise. Blind trust, on the other hand, is rarely so.

Mistake #5: Hopping from chat to chat without a plan

As project experience grows, many different chat groups often spring up. This is generally a good thing. However, it becomes problematic when there is no common structure. In that case, important information ends up scattered across different places.

• Architectural decisions are made in a chat.
• Documentaries are created in a different way.
• New features are being developed in a third version.

After a few weeks, no one can remember exactly where certain information is located. This leads to contradictions, inconsistencies, and unnecessary extra work. That is why projects should be clearly organized from the very beginning.

Specialized chat channels are helpful, but they require a shared knowledge base and centralized documentation. This is the only way to create a consistent overall system.

Mistake #6: Treating AI as an oracle

Another common misconception is to view AI as an infallible authority. Many of its responses are worded in a convincing manner. That is precisely where the danger sometimes lies. AI often presents its suggestions with great certainty, even when there are uncertainties. This does not mean that it is deliberately misleading; it simply operates on the basis of statistical probabilities.

That is why it is important to learn to view answers critically. Not every elegant formulation is automatically correct. Not every explanation that sounds technical is automatically correct. AI provides suggestions, not definitive truths.

The sooner you adopt this attitude, the better the collaboration will be.

Mistake #7: Not adapting processes

Some developers try to use AI in exactly the same way they used to work without it. They simply use the new tools as a faster code generator.

As a result, they are squandering a large part of its potential. The true strength of modern AI lies not only in writing code. It lies in analysis, documentation, planning, quality assurance, and knowledge management.

Those who fail to adapt their work methods often end up using only a small fraction of the available opportunities. Successful developers, therefore, learn to refine their processes. They systematically integrate AI into their workflows and create new forms of collaboration.

Mistakes are part of the learning process

Despite all the warnings, there’s one important point we shouldn’t forget: mistakes are normal. Every new technology requires experience. No one creates perfect prompts, perfect documentation, or perfect processes right from the start.

Ultimately, working with AI is also a skill that develops through hands-on experience. With each project, you gain a better understanding of what information is important, which approaches work, and which mistakes to avoid.

That is exactly why setbacks should not be viewed as failures. Often, they are simply indications that a process can be improved.

When you look at the most common mistakes, an interesting pattern emerges. Surprisingly, most problems have very little to do with programming. They arise from a lack of information, poor structure, inadequate documentation, or unrealistic expectations.

The technical implementation is often not the biggest challenge. The real challenge lies in organizing knowledge, making connections clear, and designing meaningful collaboration between humans and AI.

If you master these fundamentals, you will automatically avoid many of the typical mistakes. And that is precisely what ultimately results not only in better code, but usually in significantly better software as well.

DO NOT use Codex until you've watched this video! (The ChatGPT Super App) | Everlast AI

A real-world example of a large-scale project

So far, we've mainly focused on principles. We've discussed why context is more important than code, why documentation plays a central role, and how larger projects can be distributed across multiple specialized chat channels.

But what does all this look like in practice? The answer is: surprisingly unspectacular.

Many people imagine AI-driven development as a process where you simply enter a single prompt and receive a finished software system a few hours later. Such notions are further reinforced by promotional videos and impressive demonstrations.

The reality is quite different. Even with AI, large-scale projects are developed step by step. The difference is not that planning and structure become unnecessary. On the contrary: they are more important than ever.

To illustrate this, in this chapter we will examine a typical example of the development of a large software system. This is not about a specific product, but rather a generalized development process that can be found in many projects.

The Project Idea

Almost every project starts with an idea. You identify a problem, a gap in the market, or an inefficient workflow, and use that to develop a vision for a new software solution.

This is often where the first collaboration with AI begins. Instead of jumping straight into discussions about databases or user interfaces, the actual goal is described first.

• What problem needs to be solved?
• Who will be using the software later on?
• What benefits is it supposed to offer?
• What solutions are currently available?

This first step often seems simple, but it is of enormous importance. The more clearly the project idea is articulated, the easier it is for the AI to contextualize subsequent decisions. A good project description thus serves as a kind of compass for all subsequent development phases.

The data model is being developed

Once the basic objectives have been defined, the actual structuring of the project begins. In many cases, the initial focus is on the data.

• What information must be stored?
• What objects exist?
• What is the relationship between them?

This is where one of the major advantages of modern AI systems becomes apparent. They can help reveal connections that you might otherwise have overlooked.

At the same time, the responsibility remains with the developer. The AI can make suggestions, identify alternatives, and design structures. However, whether these suggestions are actually sound must still be verified by experts.

Often, several drafts are produced, which are then discussed and refined. The goal is not to create a data model as quickly as possible, but to develop one that remains viable in the long term.

The architecture is defined

As the data becomes clearer, the next phase begins. The question now is how the individual components of the system should work together.

• Which modules are required?
• What interfaces are required?
• How should extensions be integrated later on?

It is precisely during this phase that the strength of specialized chat groups becomes apparent. An architecture chat group can focus on long-term structural issues, while other chat groups are already developing initial detailed concepts.

At the same time, the project documentation grows. Every important decision is recorded—not just the outcome, but also the reasoning behind it. This results in the gradual development of a transparent knowledge base.

The first prototypes

There comes a time when theory meets practice.

• The first prototypes are being developed.
• User interfaces are being designed.
• Database queries are being tested.
• Workflows are simulated.

Many developers notice an interesting phenomenon here. The first visible results are hugely motivating. At the same time, new issues come to light that weren’t apparent during the planning phase. Perhaps certain fields are missing. Perhaps processes need to be adjusted. Perhaps it becomes clear that an initial assumption isn’t viable.

That's completely normal. Software development isn't a linear process. Even with AI, quality comes from iteration and continuous improvement.

Collaboration among multiple AI roles

As projects grow in size, the division of labor becomes increasingly important. Developers no longer work with a single AI, but with several specialized roles.

• A chatbot analyzes the architecture.
• Another person develops features.
• A third one documents decisions.
• A fourth person checks for potential vulnerabilities.

This results in a way of working that is remarkably similar to that of traditional development teams. The key difference is that these roles are flexible and can switch between different tasks very quickly.

Nevertheless, humans remain in control. They decide which suggestions to accept and which to reject.

The Importance of Continuous Documentation

As larger projects progress, it becomes increasingly clear why documentation plays such a crucial role. At first, the project still seems manageable. After a few months, however, there are often hundreds of decisions, numerous modules, and a multitude of technical details.

Without documentation, a significant portion of this knowledge would be lost. That is why documentation is not viewed as a chore, but rather as an active part of the development process. This allows new team members to get up to speed quickly. Past decisions remain traceable. The entire project becomes easier to maintain in the long term.

Especially in AI-driven development, this is one of the most critical factors for success.

The inevitable changes

No major software project remains unchanged. New requirements arise. Customer needs evolve. Technologies continue to advance. Some ideas turn out to be excellent, while others prove less practical.

That is why every architecture should be flexible enough to accommodate changes. This once again highlights the importance of thorough documentation and a clear structure. The stronger the foundation, the easier it is to implement changes later on.

AI can help analyze the impact of changes and develop alternatives. However, the strategic decision remains the developer’s responsibility.

What successful projects have in common

When looking at various AI projects, similar patterns emerge time and again. Successful projects start with a clear vision. They have a well-defined structure. They document key decisions. They break down large tasks into smaller components.

And they don’t view AI as a magic solution, but rather as a powerful partner within a broader development process. The true strength of modern AI doesn’t lie in generating software at the push of a button. Its strength lies in supporting developers with analysis, planning, implementation, and documentation. That is precisely what creates new opportunities.

The journey is more important than the first prompt

People who are new to AI development often spend a lot of time searching for the perfect prompt. After working on a few larger projects, this perspective usually changes. The success of a project rarely depends on a single prompt; rather, it is the entire process that matters most.

• The project idea.
• The Analysis.
• The architecture.
• The documentation.
• Collaboration among different roles.
• Continuous improvement.

AI can support all of these areas. However, it does not replace the need to think in a structured way and work systematically. That is why successful AI-driven development ultimately resembles successful software development in general.

The only difference is that much more powerful tools are available today. And that is precisely why it is not the best prompt that will determine a project’s success, but rather the quality of the entire development process.

The Future of Software Development

If you follow the current debate on artificial intelligence, it’s easy to get the impression that everything has already been decided. Some are convinced that developers will soon become obsolete. Others view AI as a short-lived fad that will fade away in a few years.

Based on my experience so far, I think both perspectives are too simplistic. The real development is just getting started.

As I write this article, I am working on a large-scale software project that has been developed with AI support from the very beginning. The point isn’t simply to let the AI write code. What’s far more interesting is the question of how development processes change when an intelligent assistant is suddenly available around the clock.

After just a few weeks, clear differences from traditional working methods become apparent. Ideas can be tested more quickly. Concepts take shape in less time. Documentation grows almost automatically as the project progresses. At the same time, however, it becomes clear that good results still depend on clear structures, thorough planning, and clear communication.

The tools may change, but the fundamental principles of good software development remain remarkably consistent.

From Programming to Systems Thinking

For many decades, the focus was on actual programming. Anyone who wanted to develop software had to master programming languages, learn libraries, and write large amounts of code themselves.

This picture is changing rapidly. Code is increasingly becoming a resource that can be automated. The real challenge is shifting toward analysis, architecture, and understanding the system.

The developer of the future will likely spend less time writing individual functions and significantly more time describing systems, analyzing requirements, and coordinating interdependencies.

The ability to explain complex concepts in an understandable way is therefore more important than ever before. In a sense, we are witnessing a return to the very fundamentals of software development. The focus is not on the syntax of a programming language, but on understanding the problem.

Documentation is becoming a key component

One trend is already becoming clear. While documentation was often viewed as a necessary evil in the past, it is increasingly becoming the cornerstone of many projects.

AI systems can only work with the information available to them. The better a project is documented, the more productive the collaboration can be. This creates an interesting shift.

Documentation is no longer intended solely for people. It is also becoming a knowledge base for digital assistants. One could say that modern projects increasingly consist of two layers. On one side is the actual software. On the other side is the knowledge base, which explains why this software exists in the first place and how it works.

In the future, these two areas will likely become increasingly intertwined.

Virtual teams instead of individual tools

Collaboration with AI will also continue to evolve. Today, many developers still work with individual chats or individual models. In the future, we will likely work more and more frequently with entire groups of specialized AI systems.

• A system designs the architecture.
• Another one develops features.
• Another one creates tests.
• Another one maintains the documentation.

In this model, humans take on the role of project manager and set the direction. This model already bears a striking resemblance to traditional development teams. The only difference is that the team members are digital and can switch between different tasks in a matter of seconds.

The Significance of Human Experience

Despite all the technological advances, one thing remains clear: experience is no less important. On the contrary, the more powerful the tools become, the more valuable the ability to make good decisions becomes.

• An AI can make suggestions.
• She can analyze.
• She can suggest alternatives.
• It can even find errors.

However, the responsibility for making final decisions remains with humans. Those who understand processes, recognize connections, and can think long-term will continue to have a significant advantage in the future.

True strength does not come from AI alone. It comes from combining human experience with artificial intelligence.

From AI Chat to Project Memory

Anyone developing large-scale software projects involving AI quickly realizes that it is not the code that becomes the bottleneck, but rather the knowledge about the project. Requirements, architectural decisions, data models, and discussions often accumulate over weeks or months. This is precisely where an interesting connection to the topic of data export arises. After all, much of this information is already available from previous AI discussions. Anyone who Chat history exported and systematically archived, ...lays the foundation for a long-term project memory. Instead of having to explain important decisions over and over again, past analyses, concepts, and solutions can remain permanently accessible. Step by step, individual chats thus form a knowledge base that can later be used for documentation, development, and even for proprietary AI systems. Software development with AI therefore means not only faster programming, but also the deliberate creation of a digital knowledge archive.

My personal conclusion

When I look back on my experience with AI-driven development so far, one thing stands out above all else:

Technology hasn't made me think less. It has made me think differently. Many tasks that used to take up a significant portion of my workday can now be completed much more quickly. At the same time, the importance of structure, planning, and documentation has grown.

My current project, in particular, keeps demonstrating just how valuable clear context, a centralized knowledge base, and clearly defined processes are. It’s not the individual prompt that makes the difference. It’s not the individual line of code. It’s not even the AI system used.

The key factor is the ability to organize information and provide a project with a clear direction.

Perhaps in a few years, people will look back on the present day in the same way they do on the introduction of the Internet or the first personal computers. Many possibilities are already apparent, but it is still difficult to fully assess the long-term implications.

One thing, however, already seems certain today. Software development is going to change. Not because machines will suddenly do everything on their own, but because people have been given new tools that expand their capabilities. Those who use these tools wisely can work more productively, learn faster, and tackle larger projects than ever before.

The future therefore likely belongs neither to humans alone nor to artificial intelligence alone. It belongs to the collaboration between the two. And this collaboration does not begin with code.

It starts with an idea, a clear structure, and a willingness to try new things.

---

---

Frequently asked questions

1. Can AI already develop entire software projects on its own today?
   Modern AI systems can handle impressive aspects of a software project. They can design data models, generate source code, develop interfaces, write documentation, and even create tests. Nevertheless, successful software development does not come about solely through writing code. Requirements must be understood, business processes analyzed, decisions made, and results reviewed. These tasks remain the responsibility of humans. AI can massively increase productivity, but it does not replace the need for expertise, experience, and project management.
2. Which AI is best suited for software development?
   There is no one-size-fits-all answer. Different systems have different strengths. Some models excel at architectural questions, while others are better at code generation or documentation. Often, the quality of the information provided is more important than the choice of tool. Even the most powerful AI can only work with the knowledge provided to it. Good processes, clear documentation, and a well-defined context are usually more important than the specific model name.
3. Do I need to know how to code to develop AI software?
   A basic understanding of technology remains extremely valuable. While AI systems can handle many programming tasks, results still need to be evaluated, errors identified, and decisions made. Those who understand databases, software architecture, and business processes generally achieve significantly better results. While the barrier to entry is dropping considerably, specialized knowledge remains an important competitive advantage.
4. Why is context so important in AI development?
   At first, the AI doesn’t know anything about your project. It doesn’t know your goals, your processes, or your data structures. Without sufficient context, it has to make assumptions. The more relevant information is available, the better it can develop suitable solutions. In many projects, the quality of the results depends more on the context provided than on the actual task at hand.
5. How detailed should project documentation be?
   Good documentation should be comprehensive enough to make the context clear, but it shouldn’t be unnecessarily complicated. Key elements include project goals, data models, architectural decisions, naming conventions, open tasks, and technical requirements. The goal is not maximum volume of text, but maximum clarity. Clear documentation is often more valuable than hundreds of pages of unstructured information.
6. Why should you split larger projects across multiple AI chatbots?
   As projects grow in size, so do their complexity and the volume of information. When all topics are discussed in a single chat, important information often gets lost. Dividing discussions into separate chats for architecture, development, documentation, and testing creates clearer lines of responsibility and improves clarity. At the same time, this approach allows for the targeted use of different perspectives.
7. What is a startup prompt, and why is it important?
   A startup prompt serves as a standardized introduction for new chats. It describes the project, provides links to the documentation, defines rules, and explains the desired role of the AI. This ensures that new chats immediately have the necessary context. It saves time, reduces misunderstandings, and ensures consistent results throughout the project.
8. Should every decision be documented?
   Not every minor detail needs to be documented. What matters most are decisions that could later affect the architecture, data model, or processes. It is particularly valuable to document the reasoning behind a decision. Often, the problem isn’t the decision itself, but the fact that the original reasoning is later forgotten.
9. How can we prevent AI from coming up with incorrect solutions?
   There is no such thing as 100% certainty. The best strategy consists of several key elements: providing sufficient context, breaking tasks down into smaller steps, reviewing results, conducting tests, and documenting important decisions. AI should be viewed as a support tool, not as an infallible authority.
10. How important is real sample data?
    Sample data is one of the most effective tools available. It helps AI better understand structures, relationships, and typical use cases. Often, a few realistic data sets convey more insight than several pages of theoretical descriptions. Of course, data protection and confidentiality must be taken into account.
11. Can AI also be helpful in existing software projects?
    Yes. Existing systems in particular often benefit from AI support. Documentation can be expanded, legacy code analyzed, data structures understood, and new features planned. However, this requires that sufficient information about the existing system be available. The better the initial documentation, the more effective the collaboration will be.
12. What role will developers still play in the future?
    The role is increasingly shifting from pure programming toward analysis, architecture, communication, and quality control. Developers are increasingly taking on the roles of project managers and system architects. The ability to describe complex relationships in an understandable way is becoming increasingly important. Programming remains relevant, but it is no longer necessarily the main focus.
13. How should one deal with conflicting AI responses?
    Discrepancies are normal. Different discussions or models may suggest different approaches. That is precisely why important decisions should always be made based on clear criteria. Architectural rules, documentation, and testing help to objectively evaluate the quality of various proposals.
14. Should AI be given access to all project documentation?
    Generally speaking, yes, provided that data protection, confidentiality, and company policies allow it. The better the AI understands the project, the higher the quality of the results tends to be. Especially for long-term projects, it’s worth consistently integrating key knowledge sources and keeping them up to date.
15. How is AI changing the development timelines of software projects?
    Many tasks can now be completed much more quickly than before. Concepts, documentation, data models, and initial prototypes are often produced in a fraction of the time it used to take. At the same time, the need for planning, testing, and quality assurance remains. As a result, successful projects do not automatically become more hectic; rather, they are often more structured and productive.
16. Can small businesses benefit from AI-powered software development?
    Smaller companies, in particular, often benefit significantly. Whereas entire teams were once required, today individual developers or small groups can carry out projects that would have been economically unfeasible in the past. AI lowers the barriers to entry and boosts productivity without requiring large investments in large development teams.
17. What are the most common mistakes beginners make?
    The most common mistakes include providing too little context, lacking documentation, setting overly broad tasks, and blindly trusting AI results. Many users initially focus on individual prompts and underestimate the importance of structure, knowledge management, and long-term project organization.
18. Will AI completely replace traditional software development?
    As things stand, that seems unlikely. A more likely scenario is a profound change in the way we work. Many technical tasks will be automated or significantly accelerated. At the same time, analysis, communication, architecture, and strategic thinking will gain in importance. The future of software development is likely to lie less in the replacement of humans than in an ever-closer collaboration between human experience and artificial intelligence.

---

---