Vibecoding – that is, generating software by describing to an AI model in natural language what it should build – delivers visible results in a short time. That is precisely what explains the enthusiasm with which the method is currently being tried out in teams. However, the lawyer Niklas Mühleis points out that the legal situation is anything but clear.
For companies, this is not an academic problem. Experience shows that a prototype created on a Friday afternoon quickly ends up in a discussion about whether it could simply be put into production. At the latest at this point, speed and demo effect no longer count, but rather questions about rights, obligations and responsibilities.
Three areas where things become unclear
Copyright. Who owns code that a model has generated on request? Classically, copyright protection presupposes a human creative achievement. How much of one's own contribution is contained in a prompt and whether the result is even protectable cannot be answered in general terms. For a company, this means in case of doubt: one cannot simply assume that one holds exclusive rights to what has just been created.
Licences. Models are trained on large quantities of third-party code. Whether and to what extent training material reappears in generated outputs is hardly comprehensible from the outside. This also raises the question of which licence terms could attach to such code – a topic that can become particularly unpleasant with open-source licences that carry copyleft obligations.
Liability. If generated code contains a security vulnerability, processes data incorrectly or causes an outage, the model is not liable. In the customer relationship, the company that delivered the software remains liable. The note that an assistant wrote the section does not absolve anyone.
Why this is becoming relevant right now
The discussion is shifting because vibecoding lowers the threshold. In the past, code was written by those who could program – and who usually also brought a basic understanding of licences, dependencies and reviews. Today, functional applications are also created in specialist departments where these questions have never played a role.
Add to that the sheer volume. A team can generate more code in a day than it can carefully review. Anyone who does not scale the review steps along with it simply shifts risk to a later point – into operations, into audits, into contract negotiations with customers.
What companies can do in practice
Legal uncertainty cannot be organised away, but it can be contained. Organisational measures in particular have proven effective:
- Define clear zones. Determine where prompt-generated code is permitted – for example in internal tools and prototypes – and where it is not, for example in security-critical or heavily regulated components.
- Document provenance. Keep track of which parts of a system were machine-generated. Without this information, later review is hardly possible.
- Do not abolish review. Human scrutiny remains the decisive filter, precisely because generated code often looks clean at first glance.
- Check dependencies. Automated licence and security analyses in the build process at least detect the obvious cases.
- Adapt contracts. Clarify with customers and service providers how AI contributions are handled, who grants rights and who is accountable for what.
- Read the terms of use of the tools. Providers regulate differently what happens with inputs and which rights are granted to outputs.
A prototype is not the same as a product
The most important step is often a simple distinction: a prototype may be fast, messy and experimental. It serves to test an idea. A production system requires maintainability, test coverage, documented provenance and someone who bears the responsibility.
The transition between the two states should be a conscious decision, not a side effect of a successful demo. Where this transition is clearly defined – with a checklist, a review and, if necessary, a partial reimplementation – legal uncertainty loses much of its explosive power.
For web and software projects, this means: prompt-driven development is a legitimate tool, but not a substitute for architecture, review and clean contract design. Anyone who documents AI contributions from the outset and treats the leap from prototype to production system as a separate, reviewed step can use the speed without relinquishing responsibility. Since the legal situation continues to evolve, it is worth keeping these rules as a living document and regularly checking them against the current state.