Do You Own the Code Cursor Writes For You?

Cursor's been carrying half your codebase. Tab, accept, tab, accept. The diffs fly by, the tests pass, the feature ships. At some point a fair question surfaces, usually right before a funding round or an acquisition: do you actually own this code?

The uncomfortable answer is that you own some of it, the AI's solo work probably belongs to nobody, and you currently have no way to tell which lines are which. That last part is the real problem, and it's fixable.

"Own" hides two different questions

When a developer says "do I own this code," they usually mean two things at once and don't realize it.

First, who has the rights against your contract. If you wrote it on the clock, your employer likely owns it through work-for-hire. If you're a contractor, your agreement decides. That's contract law, and AI doesn't change it much.

Second, and this is the one AI breaks, is there a copyright to own at all. Copyright only attaches to expression authored by a human. If a chunk of code was authored entirely by a machine, there may be no copyright in it for anyone to hold, regardless of what your contract says. You can't assign a right that never existed. So you can have working, shipped, business-critical code that sits in a copyright gap, owned by no one and copyable by anyone who gets their hands on it.

That second question is what the rest of this is about.

The human authorship rule, applied to your editor

The law here is settled enough to plan around. Copyright protects works of human authorship. A machine can't be an author. The Copyright Office said so in its 2025 guidance, and a federal court confirmed it in Thaler v. Perlmutter the same year, refusing to register a work that named an AI as author. No human author, no copyright, work falls into the public domain.

For protection, a human has to control the expressive elements. The Office names three forms of control: selection, arrangement, and modification. Translate that into how you actually work:

Selection. Cursor offers a completion, you accept it or reject it, you pick this implementation over that one. Choosing among machine outputs is selection.

Arrangement. You pull the generated function into a module, wire it into your architecture, structure how the pieces fit. That composition is yours.

Modification. You rewrite the AI's approach because it picked the wrong data structure, you fix the error handling it botched, you refactor its naming to match your domain. That's modification, and it's often where the real authorship lives.

Do enough of that on top of the machine draft and the human contribution becomes protectable. The expressive choices are yours, made deliberately, on top of what the model produced.

Prompts and comments don't carry the weight

Here's where developers get optimistic and shouldn't. The detailed comment you wrote describing what you wanted, the elaborate prompt steering Cursor toward a specific design, those don't make you the author of the code that comes out.

The Office has been clear that prompts alone are insufficient, and length doesn't fix it. A precise spec is a request, not authorship. When you write "implement a thread-safe LRU cache with these constraints" and the model produces 80 lines, you described the result but the model made the expressive choices: the locking strategy, the eviction logic, the exact structure. You don't control the specific expression, so your authorship in those 80 lines is thin until you go in and exercise real control over them.

That gap, between what you asked for and what the model expressed, is precisely where solo-AI code lives. And there's no percentage that rescues it. No "I wrote 40% of the lines" threshold. The Office decides case by case, on the expressive elements a human actually controlled. Any tool promising you a human-authorship score for your repo is selling a number the law doesn't recognize.

Why this stays invisible until it's expensive

Copyright on code is quiet until there's a fight, and then it's the only thing anyone cares about.

Picture the scenarios. A contractor builds a client's internal platform mostly through Copilot and Cursor, the relationship ends badly, and both sides claim the codebase. Two cofounders split and argue over who owns what. An acquirer's lawyers run IP diligence and go file by file: who authored this, and can you prove it? For most AI-heavy codebases today, the honest answer is a shrug. git blame shows your name on the commit. It says exactly nothing about whether you authored the expression or whether the model did, because committing is not authoring.

The precedent that should worry you is Zarya of the Dawn, the AI-assisted comic. The Office protected the human's selection, arrangement, and text, but disclaimed the raw AI-generated images. Same work, split decision, element by element. Your codebase is the same situation at scale: some functions reflect heavy human authorship, some are accepted machine output verbatim, and right now the two are indistinguishable in your history.

You can't reconstruct authorship from a finished repo

This is the trap. The expressive control you exercised, the rejected completions, the rewrites, the architectural decisions, leaves almost no durable trace. The repo is an end state. It shows what the code is, not who authored which expression or why.

Try to reconstruct it two years later in a deposition. "I'm pretty sure I rewrote most of that file" is not evidence. The burden of proving human authorship sits on the person claiming the copyright, which is you, and memory is a terrible witness. You might have done genuinely substantial creative work and still lose the argument because you can't show it.

Capture the authorship while you're authoring

You can't change the law, and you can't retroactively manufacture a record. What you can do is keep one as you work.

The defensible position isn't "AI helped a bit." It's a concrete trail of expressive decisions: what the model produced, what you accepted, what you rejected, what you rewrote and why. Selection, arrangement, modification, recorded in the moment instead of guessed at later.

That's what Copyrightable is built to capture. It records your actual creative process and ties that trail to the finished Work as evidence, then scores it against a published Authorship Methodology, currently v0.1, that measures the kind of control you exercised. It deliberately doesn't emit a percentage or claim some volume of human input crosses a magic line, because the Office doesn't work that way and a fake number won't survive a real examiner. It's evidence, not legal advice, and it won't conjure copyright where only machine output exists. It just makes sure that when the question finally lands, you can point at the human authorship instead of shrugging.

So, do you own the code Cursor writes for you? The parts where you exercised real expressive control through selection, arrangement, and modification, often yes. The parts the model authored on its own, probably nobody owns. The line runs through your actual contribution, and it's invisible the moment you close the editor. If your codebase is worth anything to a client, a cofounder, or an acquirer, start keeping the record now, while you still remember which lines you fought for.