Is AI-Generated Code Copyrightable?

You typed three words into Cursor. It wrote a 200-line parser. Do you own it?

Short answer: maybe, and the part the AI wrote on its own probably isn't yours. The longer answer is the one you actually need, because "maybe" is what loses arguments with clients, co-founders, and acquirers.

Let's separate two things that usually get mashed together. There's the code, sitting in your repo, doing its job. Then there's the copyright in that code, which is a legal right that only attaches to expression authored by a human. Those are not the same. You can have working code that nobody owns. That happens more often than developers realize.

What the US Copyright Office actually says

The rule is narrower than the headlines suggest, and it has nothing to do with how clever your prompt was.

In its 2025 guidance and in Thaler v. Perlmutter, the Copyright Office and the courts landed on a consistent position: copyright protects works of human authorship, and a human has to control the expressive elements of the work. Control shows up in three ways the Office names directly: selection, arrangement, and modification. You pick which outputs to keep. You arrange them into something. You modify what the machine produced. Do enough of that, and the human contribution becomes protectable.

Here's the part that trips up engineers: prompts alone are not enough. Doesn't matter how detailed. The Office's view is that a prompt is closer to an instruction than to authorship, because you don't control the specific expression the model generates in response. You asked for a binary search; the model decided the variable names, the loop structure, the edge-case handling. That gap between what you requested and what came out is exactly where your authorship runs thin.

And there's no magic number. No "51% human" threshold, no line count, no percentage you can cite. The Office evaluates case by case. Zarya of the Dawn, the AI-assisted comic, is the clearest example: the human's selection and arrangement of the images earned protection, but the individual Midjourney-generated images did not. Same work, split decision. The expressive elements a human controlled were in; the rest was out.

So what does this mean for the code you shipped Tuesday?

Walk through a normal session. You're using Claude Code. You ask for a rate limiter. It generates one. You read it, decide the sliding-window approach is wrong for your traffic pattern, tell it to switch to a token bucket, rename things to match your domain, pull two functions into a shared module, and rewrite the error handling because the AI's version swallowed exceptions you care about.

Every one of those moves is the kind of control the Office is looking for. Selection (you kept this, killed that). Arrangement (you restructured the modules). Modification (you rewrote the error handling). That's a human authoring expressive choices on top of a machine draft.

Now the other session. You prompt "build me a CRON job that backs up the database," accept the output as-is, and commit. You barely read it. If someone later copies that file, your copyright claim is weak, because there's almost no human expression in the chain. You requested a result. The machine expressed it. You pressed enter.

Same tool. Same developer. Wildly different copyright posture. The difference isn't the technology, it's how much of the expression you actually controlled, and right now you have no record of either way.

The problem nobody mentions until there's money on the line

Copyright is silent until it's loud. Nobody asks about it while you're shipping. They ask during a dispute.

A contractor builds an internal tool for a client, mostly with Copilot. Eighteen months later the relationship sours and the client claims they own everything, including the parts the contractor wrote. Or two founders split and fight over a codebase. Or an acquirer's lawyers run diligence and ask, file by file, "who authored this, and can you prove it?" The honest answer for most AI-assisted code today is a shrug. Git blame shows your name on the commit. It says nothing about whether you authored the expression or whether the model did.

That shrug is the whole problem. You might have done genuinely substantial creative work. You restructured, rewrote, made dozens of judgment calls about how the thing should be expressed. But "trust me, I did a lot" is not evidence, and the burden of showing human authorship sits with you, the person claiming the copyright.

Documenting control is the part you can actually do something about

You can't change the law. You can change whether you have proof.

The defensible position isn't "the AI helped a little." It's a concrete record of the expressive decisions you made: what the model produced, what you kept, what you threw out, what you rewrote and why. The selection, the arrangement, the modification, captured as it happened instead of reconstructed from memory two years later in a deposition.

This is the gap Copyrightable is built for. It captures your actual creative process, the prompts, the edits, the iterations, and ties that trail to the finished work as evidence. It scores the result against a published Authorship Methodology, currently v0.1, which measures the kind of creative control you exercised. Note what it deliberately does not do: it never spits out a percentage or claims some volume of human input crosses a magic line, because the Copyright Office doesn't work that way and any tool claiming otherwise is selling you a number that won't survive contact with a real examiner. It documents the categories the Office cares about, so when the question finally gets asked, you have an answer with receipts.

The honest takeaway

Is AI-generated code copyrightable? The code the AI generates on its own, no. The expressive work you build on top of it through selection, arrangement, and modification, often yes. The line runs through your actual contribution, not the tool you used to get there.

The catch is that the line is invisible until someone challenges it, and by then the work is done and the memory is gone. If you're shipping AI-assisted code that matters, whether for clients, a startup, or anything you'd hate to lose in a dispute, start keeping a record of the creative control you're exercising while you still remember exercising it.

If you want to see what that record looks like in practice, take a look at how Copyrightable captures it. Then go check who actually authored the code in your most important repo. You might be surprised what you can't prove.