Do You Own the Code an AI Game Maker Writes?

2026-11-01 · 9 min read

A few weeks ago I wanted to move a small browser game off the tool that built it. Nothing dramatic — I wanted to run it on cheap hosting instead of paying for the builder's plan, and I wanted a friend to be able to open the project and poke at the jump physics.

It took me about four hours to establish that I couldn't, and most of that time went into refusing to believe it. The tool had an export button. The export produced a folder of minified JavaScript and an index.html. There was no project, no readable source, no way to change the jump height without going back into the tool and asking again. I owned a build. I did not own a game.

That distinction is the whole subject, and it's the one almost every "AI game maker" page skips past, including the ones that are otherwise honest. So here is what I check now before building anything I might still care about in a month, what I think the real answers are, and the part where I have to tell you I don't know.

"Do I own it" is three separate questions

Ask this on a forum and you'll usually get a confident answer to a question you didn't ask. The word "own" is covering three things that have almost nothing to do with each other.

Can I take the files with me? A technical and contractual question about export. Can you get a zip, put it in git, open it in another editor, host it somewhere else? You can settle this yourself in ten minutes, and it's the only layer where the answer is genuinely binary.

Does the tool let me sell it? A question about their terms, and specifically about your tier. Several tools tie commercial rights to a paid plan. Some restrict free output to non-commercial use outright. This is the layer that bites people who read the homepage instead of the terms.

Does anyone own the copyright at all? A legal question no tool provider can answer for you, because it isn't theirs to answer. Every serious source I've read lands in roughly the same place: prompts alone probably don't get you there, and substantial human authorship might. That isn't a yes. It also isn't a no.

Most public arguments about AI ownership are two people answering different lines off that list and each concluding the other is wrong.

Layer one: the take-it-with-you test

Before I build anything I intend to keep, I run a deliberately crude test.

1. Build the smallest possible version — one screen, one mechanic.
2. Find the export. Read what comes out, not what the button says.
3. git init the exported folder, change one number in the source, and see if the game still runs.

If step 3 turns out to be impossible, I've learned the most expensive thing about that tool in twenty minutes rather than three weeks. If step 3 works, everything else stays negotiable.

The thing you're hoping for is a project: recognizable files in a format a human reads, that another tool could plausibly open. GDScript, C#, readable JavaScript with the actual game logic in it, something named after what it does. The thing you don't want is a build: flattened or minified output with the logic pressed down into it.

The failure mode here is subtle, and it usually isn't malice. Plenty of browser-native builders genuinely cannot give you a project, because their "game" is a data structure interpreted by their runtime rather than code in the ordinary sense. They aren't hiding anything. They built something that can't be exported, then added an export button anyway because everyone has one.

I want to be fair about this, because there's a version that works fine. If you want a toy that lives on someone else's site and you never need to touch it, none of this matters. It starts to matter the day you want the game to outlive your subscription.

Layer two: read the plan, not the homepage

I went through the terms of the tools I'd actually used, and also a roundup someone else published in October 2026 that had read the terms of more of them than I had. Same pattern both times.

Coding agents and AI editors — the kind that work on files on your own machine — tend to assign you whatever rights they hold in the output. Anthropic's consumer terms, for instance, say that provided you follow the terms, the company assigns you its right, title, and interest "if any" in Outputs. Cursor's terms do something structurally similar for code it suggests, and add that its suggestions may be similar to suggestions given to other users, with no rights in theirs.

Prompt-to-game platforms are where the catches live, because these tools also generate the art and the audio and usually host the result. A roundup published on dev.to that checked each maker's terms directly on 2026-10-20 reported several flavors of restriction: commercial rights tied to a paid tier, source download locked behind higher tiers, one platform claiming rights in content made on its service, and one limiting free output to personal non-commercial use with no export at all. A Godot-compatible desktop builder in the same roundup was reported to allow commercial release with project export and no revenue share.

I'm summarizing someone else's reading of those terms as of a specific date, and I haven't re-verified every line since. Terms change, quietly, and rarely in your favor. If a store page or a paycheck depends on a sentence, open the terms and read the sentence.

The two words to look for are "if any." Every assignment clause I've read hedges with them, and the hedge is doing real work. The provider is handing you whatever interest it holds. It is not promising the interest exists. That's not them being slippery — it's them not being able to promise something nobody has settled.

Layer three: the part nobody can sell you

This took me longest to internalize. Even in the best case, where the tool assigns you everything it has and you're on the top tier, you may have been assigned something close to worthless.

The U.S. Copyright Office's January 2025 report on copyrightability — Part 2, on works containing AI-generated material — came down broadly where you'd expect if you've been following this: prompting alone generally isn't enough to make output protectable, but a human's own creative arrangement, selection, or modification of that output can be. I'm paraphrasing a document I read rather than quoting it line by line, and other jurisdictions are working through their own versions of the same question. I'm not a lawyer and this isn't legal advice.

Two practical things fall out of that, and they're why I changed how I work.

Your edit history is the asset. If protection attaches to the human-authored layer, then the valuable thing is the record of what you chose, arranged, and changed. "I typed these prompts" is a weak story. "Here's the commit where I rewrote the collision code because the generated version failed this specific test" is a much better one.

You can't brute-force this with volume. Two thousand lines you didn't write are not two thousand lines of value. They're a maintenance liability with an unclear ownership story stapled to them. The version of this that actually works is small games where a person made the decisions.

What I changed in my own workflow

None of this is clever. It's the list of things that stopped costing me an evening at the worst possible moment.

Git from commit one, even for a toy. git init before the first prompt, not after the first working build. The history is the only artifact that separates what you did from what the model did. It's also, unexpectedly, what makes an AI-authored codebase navigable: reading a diff of what the assistant touched is dramatically easier than reading the file.

Export on a schedule, not on a deadline. Once a week, export, unzip on a machine that doesn't have the tool installed, and confirm it still runs. Export paths rot quietly. Discovering yours is broken during a jam submission is a special kind of night.

Keep the decisions in a NOTES.md in the repo. Not the prompts — those are mostly noise. The decisions: why the jump feels this way, why enemies spawn on this timer, what I rejected and why. That file is the human layer, written down, in a form another person could actually read.

Match the tool to how much I care. For a thirty-minute prototype I'm going to delete, I use whatever is fastest and stop worrying. For anything I might sell or maintain, the requirement is a readable project I can open elsewhere. Those two categories blurred constantly at first, and everything expensive happened in the blur.

Check the engine license too. Owning your scripts doesn't help much if they only run inside an engine whose terms you never read. Godot being MIT-licensed is a real reason the Godot-compatible builders are easier to say yes to: one fewer unknown in the stack.

The parts I'm still not sure about

Being straight about the edges, because this topic attracts far more confidence than the situation supports.

• Whether I could enforce anything against a copycat. My guess is that for a small game the practical answer is no, regardless of who technically owns what, because enforcement costs more than the game earns. I haven't tested this and would rather not.
• What platforms will ask for, and when. Store submissions now include AI disclosure steps. I read those as: disclose AI-generated content and confirm you hold the rights. I'm deliberately not reproducing exact wording from memory, because it has changed more than once, and getting it wrong on a real submission is worse than being vague here.
• Whether heavy editing actually helps. Everyone I believe says it should. I've seen nobody test it in a way that produces a clean precedent. The edit history is cheap to keep so I keep it, but I don't want to oversell what it buys.
• Whether any of this survives contact with a real dispute. Unknown. The honest framing is that my system is built around never having to find out.

The quick answers

Can I sell a game an AI helped build? Usually, assuming the tool's terms permit commercial use on your tier and you have the rights to the assets. Check both — asset provenance is the more common blocker, and it's the problem I keep coming back to.

Can I put it on Steam? There's an AI disclosure step in the submission flow. I'm not quoting it from memory because the wording has moved. Read what the form actually asks at the moment you fill it in, and answer it straight.

Can I open-source it? You can publish the files if the tool lets you export them. Whether you can attach an open-source license to code nobody may own is a question I don't have a confident answer to.

What if the tool shuts down? Exactly what happened to me. If you have a project, you carry on in another editor. If you have a build, you have a build, and a deadline.

The one-sentence version

Take the files. Rights you can't exercise aren't rights, and "the AI wrote it" is not a provenance story for anything you plan to put in front of players. Ask about export before you ask about features, because export is the one thing you can't fix later.