Can I have software developed using AI?

Blog  — Wed 18 Nov 2026

I have been avoiding this topic for a while. It would almost be hypocritical to write about this issue, considering that Exclusive-IT has been delivering custom software for twenty years.

Still, I would like to take an honest look at the subject.

The reason for this is that more and more services are appearing that seem to promise software development through AI. From quick assistance via ChatGPT (OpenAI) to specialised tools such as Google Antigravity and all kinds of AI agents that can now work on projects independently.

The promise is attractive. Describe what you need, give the AI access to your project and let it do the work. Whereas you previously needed a developer, in some cases you can now have a working application created with just a few instructions.

But what if we take a closer look at this? What can it actually do? What does the long term look like? How does it help an organisation, and how might it actually work against one?

I think there are a number of issues that are not receiving enough attention in the current discussion.

Access is necessary, but also a risk

One of the first questions that comes to mind is information security. This has always been important, but perhaps even more so in today's world.

For AI to genuinely help with software development, it needs sufficient context. After all, a few isolated lines of code are not always enough to understand how an application works. The architecture, dependencies, configurations, documentation and existing implementations are at least as important.

Providing access to entire projects is therefore almost a necessary evil if you want to get the assistance you are looking for.

But that is quite remarkable.

For years, we have been thinking about information security, access management and limiting the amount of information an external party can access. Yet now, we sometimes give an AI agent access to a significant part of our software environment.

That does not necessarily mean that information is actually extracted from a system. However, it does create new possibilities for accessing and processing information, and potentially moving it outside its original environment.

We also need to distinguish between different forms of access. An AI that can only read source code presents a different risk from an AI agent that can also modify files, execute terminal commands, access databases or access production environments.

And it is precisely this distinction that sometimes seems to get lost in the promise of convenience.

Because the more an AI is allowed to do independently, the greater the potential consequences when something goes wrong. Think of accidentally including access credentials in a prompt, exposing internal configurations or executing a command that turns out, in hindsight, not to have been such a good idea.

The risk does not lie exclusively with the AI itself. The integrations, the permissions that have been granted, the extensions being used and the service provider's infrastructure all play a role as well.

Who will manage the knowledge?

Another question I ask myself is what this will mean in the long term for an organisation that increasingly allows AI to develop and manage its software.

A potential problem arises that is not immediately visible.

When an organisation outsources most of its software development to an AI service, a gap in its own internal knowledge can gradually emerge. The software still exists and may function perfectly well, but the people within the organisation increasingly understand less about how it actually works.

Every follow-up question will then have to be put to the AI again.

Knowledge is inherently lost, and a dependency on the AI service provider emerges.

This is not necessarily different from outsourcing software development to an external IT partner. In that situation too, an organisation can eventually become dependent on a party that is the only one with a precise understanding of how a system works.

Still, I do notice some differences.

You can hold a human IT partner contractually accountable, make agreements about documentation, handover and confidentiality, and in principle require them to transfer their knowledge.

With AI services, there are additional questions. What information is processed? Where is it stored? Which parties have access? Is the information used for further training or product improvement? What happens to the data when the agreement ends?

These are not theoretical questions. They partly determine whether an organisation still has actual control over its own software and the information associated with it.

The legal reality does not disappear because of AI

This is where things get even more interesting, in my opinion.

Because who is actually responsible when software is written by AI?

Suppose an AI introduces an error that causes personal data to become publicly exposed. Or an application performs a calculation incorrectly, resulting in financial damage. Can we then say that the AI is responsible?

No, it is not that simple.

An AI service is not automatically an independent legal entity that takes over the responsibility of the user or client. Legal responsibilities must be assessed based on the parties involved, their roles, the agreements made and the circumstances in which the damage occurred.

For personal data, for example, the GDPR is relevant. An organisation that determines why and how personal data is processed may remain responsible as the data controller, even when it uses external services for this purpose. A supplier may act as a data processor, in which case agreements under Article 28 of the GDPR are required, among other things.

And that is an important point to consider.

Using an AI service for software development does not automatically mean that the supplier is exclusively a data processor. That depends on the actual processing and the purposes for which the data is used. A service provider that also processes data for its own purposes may have a different legal role for that processing.

In addition, we now have the European AI Act. This legislation introduces obligations for various parties in the AI chain, depending on their role and the type of AI application. Not every use of AI in software development automatically falls into the high-risk category. Nevertheless, it is important to realise that here too, responsibility cannot simply be shifted to the supplier or the technology. The specific application and the roles of the parties involved remain decisive.

There are also questions surrounding intellectual property. Who owns the rights to the code that is generated? To what extent is generated code protected? What if the AI produces code that strongly resembles existing software? And who bears the risk when this infringes the rights of third parties?

Here too, the answer is not simply that the client automatically owns everything the AI produces. This depends, among other things, on the applicable law, the human creative contribution and the contractual agreements.

These are issues that do not simply disappear because software is produced more quickly and cheaply.

In fact, I suspect they will become even more important as organisations have more software produced without having sufficient insight into its origins and how it works.

The scale of our dependency

Another thing I find remarkable is that, once again, it is a relatively small group of large technology companies, many of them based outside Europe, that are taking on an increasingly important role in our digital infrastructure.

The business model itself is nothing new. First, offer a service at a low cost, sometimes even for free, to build up a large user base and a certain level of dependency. After that, the investments need to generate a return.

That is not, in itself, an unlawful or unusual business strategy. But it does raise questions.

What happens when the price of an AI service increases significantly? What if the terms and conditions change? What if a feature that an organisation has built its entire development process around suddenly disappears? Or what if a service provider decides to stop serving a particular market?

Of course, an organisation can switch to another provider. But how easy is that when the entire development environment, the workflows and perhaps even the knowledge of the software have by then been organised around one specific AI service?

An exit strategy sounds simple on paper. The actual implementation can be a very different story.

There is also a geographical and legal dimension to consider. Where is the supplier located? Which law governs the agreement? Which legislation may apply to the processing of data? And to what extent can a European organisation actually enforce compliance with agreements when the supplier and its infrastructure are located elsewhere?

This does not mean that an American or other non-European supplier is inherently unsafe. That would be an incorrect conclusion. However, jurisdiction, contractual options and actual control over data certainly deserve attention.

The risk is mainly in the scale

I think the risk lies mainly in the scale.

Good software security should not depend on keeping the source code secret. This is a well-known principle in information security. Software should also be secure when its operation and implementation are known.

But that does not mean that exposing source code has no consequences.

For example, source code may unintentionally contain access credentials, expose internal system structures or include information that helps an attacker find vulnerabilities. The same applies to configuration files, log files and documentation.

And that is without even considering personal data, customer data, trade secrets and other confidential information.

The problem is not necessarily that one AI service has access to one project. The problem may arise when large amounts of business software from a large number of organisations are processed through a limited number of services.

This creates an interesting concentration of risk.

An incident at a single individual supplier could then have consequences for a large number of organisations. Not because all those organisations use the same system, but because they may share the same infrastructure, service provider or dependency.

This increases the potential impact of an incident.

And that is different from saying that an incident is inevitable. Good security measures can limit many risks. But as the amount of shared information and mutual dependency increases, the importance of those measures only grows.

AI is good at code, but does it understand what we are building?

Then there is the technical side of things.

AI is currently particularly good at supporting programmers. It can find errors, analyse existing code, write tests and implement features relatively independently.

That is impressive. And I would not want to pretend that this is just a hype.

But producing code is not the same as developing software.

Software development is not just about solving a technical problem when it arises. It is also about understanding the organisation, making architectural decisions, maintaining consistency and taking future developments into account.

A solution can be technically correct and still turn out to be a poor choice.

For example, an AI might implement a feature perfectly well, while the chosen solution eventually leads to an unnecessarily complex architecture, additional maintenance overhead or a dependency on a specific technology.

That may not be immediately apparent. Perhaps everything works perfectly today. But software is generally not built for today alone.

Context is king, and AI is a tool, just like a dishwasher.

And context is precisely something that is not automatically available to an AI in its entirety. After all, a large part of an organisation's knowledge is not contained in the source code. It exists in people, processes, exceptions, historical decisions and sometimes even in the reasons why certain things were deliberately NOT built in a particular way.

At Exclusive-IT, we do not use AI for code. We do, however, use internal AI as an additional tool.

Just like a dishwasher: incredibly useful, takes work off your hands and probably does so more efficiently than I do myself. But I would not simply hand over responsibility for my entire household to it.

What does this mean for organisations and society?

The philosophical question of what this means for the labour market, and consequently for society, is an interesting subject in its own right. I will leave that aside for now.

I mainly want to focus on the implications for organisations, citizens and our legal systems.

Because we are at a remarkable point in the development of software. The barrier to having software developed is getting lower and lower. This offers enormous opportunities, including for organisations that previously did not have the resources to have custom software developed.

But at the same time, something is shifting.

We are handing over more and more control of our digital infrastructure to systems and service providers that we cannot always fully understand. We share information to get better results, build dependencies and outsource knowledge to technology that is developing at a rapid pace.

None of this necessarily has to be a bad thing. But it does require conscious decisions.

Perhaps, therefore, we should not only be asking whether AI can create software.

The question that concerns me much more is what we are handing over when we do so.

Who is responsible when things go wrong? Who ultimately has control over the software? Who has the knowledge to maintain it? And how do we ensure that organisations do not unknowingly lose their independence?

AI is an exceptionally powerful tool. I have no doubt about that.

But anyone who uses a tool should also understand the risks associated with it.

And perhaps that is currently the most important part of the discussion.