Who owns code that an AI wrote?
With Adrian, you own what you build — that is written into the terms. The more interesting question is what ownership means for code a machine produced, because there are two separate issues underneath it: what your agreement with the tool says, and what copyright law says about machine-generated work. The first is settled in your favour. The second is genuinely unsettled, and anyone telling you otherwise is overselling.
This is not legal advice, and nothing here substitutes for a lawyer on a contract that matters.
What your agreement with the tool says
This is the part you can check, and the part that varies most between products. Adrian's terms cover your ownership of what you build. There is no licence-back clause, no claim on your output, and no arrangement where the tool keeps rights to what it produced for you.
Worth checking on any tool you use, because it is not universal. Read for three things: whether the provider claims any rights in the output, whether they may use your code or prompts to improve their models, and what happens to your project if you stop paying. The third is the one people discover late.
Possession is not the same as ownership, and it matters more than it sounds
You can own something you cannot get to. If the generated project lives only inside a vendor's platform, your legal ownership is real and practically thin — you still need the platform to hand it over, in a form you can use, when you want to leave.
With a desktop tool this collapses into a non-question. The project is a folder on your disk; you can commit it, copy it, hand it to a developer, or walk away. That is also why the distinction matters for client work, where handover is a deliverable rather than a convenience.
What copyright law says, and does not
Here is the honest part. Copyright has traditionally attached to human authorship, and purely machine-generated output sits awkwardly against that. Different jurisdictions are reaching different conclusions, guidance is still moving, and the cases that would settle it are in progress.
What that means in practice: your right to use, modify and sell what you built is not seriously in question. What is less certain is how strong a claim you have to stop someone else copying it, if the code was generated with little human input. Those are different rights and they get conflated constantly.
The pragmatic reading is that the more you shaped, edited and assembled the result, the more comfortable the position — which is an argument for reading and changing generated code rather than shipping it untouched, quite apart from whether it works.
What changes when a hosted model is in the loop
Running a local model keeps the question small: the weights are on your machine, nothing about the project reaches a provider, and there is no third-party agreement covering the output at all.
Bring your own API key and a second set of terms applies — the provider's, between you and them. Adrian takes no cut and claims nothing, but your code context does go to that provider, and their terms govern what they may do with it. That is a relationship you already have if you hold a key, and it is worth having read it once.
The question people actually worry about
Usually it is not ownership at all — it is whether generated code might reproduce someone else's. Models learn from public code, including licensed code, and for short conventional fragments the output converges on the obvious answer, which is not anyone's property. A standard sorting loop is a standard sorting loop.
The risk is not zero for longer, more distinctive passages. If you are shipping something commercially significant, the sensible precautions are the ordinary ones: keep the dependency list something you recognise, be suspicious of any long block that looks unusually polished, and get a review on anything where a claim would be expensive.
If you did not build it alone
Two situations catch people out, and neither is really about AI — the tool just makes them arrive sooner.
If a contractor generated the code for you, ownership follows your contract with them exactly as it would for hand-written work. Generation does not change assignment; a contract silent on ownership is silent whether a person typed it or prompted it. The same goes the other way when you are the contractor.
And if a colleague generated it on a personal account with a personal key, the company's claim rests on employment terms rather than on the tool. That is worth sorting out before the thing becomes load-bearing, because the conversation is much easier before there is a product depending on the answer.
What to do about it
- Commit generated code to version control immediately, like any other code. A project whose source of truth is a prompt has no source of truth — regenerating gives you different code.
- Check the tool's terms for output rights and training use before you build something that matters on it.
- Keep the output somewhere you control, so ownership and access are the same thing.
- On client work, let your own contract govern. Your agreement with them is what decides who gets what, not the tool's terms.
- Read what you ship. It is the best answer to almost every version of this question, legal ones included.
If you want to see where the code lands before trusting any of this, the desktop app is free on local models and writes to a folder you picked — which is the shortest route to answering the ownership question for yourself.