AI writes code. It does not take responsibility.

For some time now, many companies have been harboring the same hope: if AI can write code, software development should finally become faster, cheaper, and easier. Less effort, fewer developers, more output.

At first glance, it certainly seems that way. A prompt, a block of code, a working result. Then a few tweaks, a few tests, maybe some optimization. Done.

Our stance on this is clear: We think AI is great. We use it every day. And it makes us better, because AI truly empowers experienced developers. Anyone who claims today that AI is a threat to good software development hasn’t understood what makes good software development. But software development isn’t simply about producing code.

Artificial intelligence can do many things today that would have been impressive just a few years ago. It can recognize patterns, speed up routines, provide designs, supplement existing logic, and noticeably lighten the load for developers in their day-to-day work. The problem arises when this strength leads to the false conclusion that the human aspect of software development can simply be eliminated.

Because good software isn’t created where as much code as possible is produced as quickly as possible. Good software is created where someone understands what needs to be built, why it must be built that way, and what consequences technical decisions will have later in everyday use.

Statements like these strike a chord because they sound like they promote simplicity and efficiency. In practice, however, they often lead to solutions that look good in the short term but create complexity, costs, and new dependenciesin the long run .

AI can generate code. But it cannot take responsibility for whether a solution actually works properly within the company. It cannot tell on its own

• if an architecture is built quickly but becomes nearly impossible to maintain later on.
• what the actual consequences of a technical error in a production system are,
• when processes grind to a halt, costs rise, or operational risks suddenly become apparent.

What matters, therefore, is not only whether something works today, but also whether it will still be understandable, resilient, and capable of meaningful further development tomorrow.

Anyone who reduces software development to writing code underestimates what professional projects are really about.

The hardest part is finding the right solution to a real-world problem: prioritizing requirements, identifying conflicting goals, clearly mapping data flows, identifying risks early on, and making decisions in a way that results not just in an initial release, but in a system that remains understandable and scalable in the long term.

The true quality of software only becomes apparent later on. That is, when new requirements arise, interfaces need to be adapted, performance becomes a concern, audits are pending, or bugs appear that no one can explain right away.

In many teams, the initial adoption of AI is going quite well. Routine tasks are completed faster, initial drafts are produced quickly, and skilled developers can work more efficiently with it.

Things get critical when support is suddenly turned into a replacement. When no one seriously questions why something was built a certain way, architectural considerations become secondary, and a usable result on the screen is already considered a good technical solution. That’s when companies often end up with exactly what they wanted to avoid:

• Code becomes unnecessarily complex.
• Logic becomes duplicated.
• Dependencies grow.
• Resources are used inefficiently.
• Security aspects are considered too late.

The problem here is not merely technical in nature but quickly becomes a business issue. Technical ambiguity leads to real consequences:

• higher operating costs
• more coordination effort
• slower development
• greater risk of errors
• a growing dependence on specific individuals who have a basic understanding of how the whole system was put together.

Especially when it comes to business-critical applications, people often underestimate what truly makes a good solution. It’s not enough for a process to simply work. A solution must remain stable under load, be able to handle real data, be secure and auditable, and be designed in a way that’s easy enough for a team to adopt, operate, and further develop.

AI can provide useful suggestions for this. However, the responsibility for evaluating these suggestions correctly from both a technical and a business perspective remains with humans. The crucial question is not whether AI is useful, because that has long been answered. Yes, it is useful. Very useful, in fact. The more decisive question is: Under what conditions is it useful without causing harm later on?

AI is transforming software development, and that’s good news. It will make teams more efficient, simplify certain tasks, and permanently change some ways of working. It makes experienced developers more valuable, not redundant, because AI allows their strengths to shine through more than ever before.

That is why a good and experienced partner is particularly important— someone who not only knows how to work with AI but also understands how custom software is built, what matters in software solutions, and which decisions will ultimately determine quality, security, and future development . AI is a powerful tool, but it is no substitute for responsibility.

Thanks to AI, custom software is now more affordable than ever before. Factors that long made standard software the obvious choice—such as lower costs and faster availability—no longer apply without exception.