15 minute read
I spent an hour last week debating an intellectual property lawyer. He is a partner who chairs his firm’s IP and internet practice, has been practising since 1989, and spent senior in-house years at technology companies before that. This is not a generalist with an opinion about AI; IP is his life’s work. The proposition on the table, which he and a colleague have been presenting at conferences under the banner Who Owns the Code? , runs like this: AI-generated code is not copyrightable. Therefore a company whose software was built with AI holds no protectable asset. Therefore it is worth nothing at sale.
The title of this piece is borrowed from theirs, deliberately, because it is exactly the right question. We disagree about less of the answer than you would think: almost none of the AI, and almost all of the value.
He conceded within the first five minutes that the framing carries deliberate hyperbole, the kind that fills conference rooms, though he stood by the core claim as legally defensible. I conceded that my framing carries hyperbole too. What was left once we had both put the hyperbole down was considerably more interesting than either headline, and it is worth writing down, because almost everyone building software with AI agents right now is exposed to some version of this question and most of the discussion of it is worse than useless.
I should say up front what I told him: I will not win a copyright argument against a copyright lawyer, and I did not try. My argument was never really about copyright. It was about what copyright is load-bearing for.
Two Different Kinds of Question
The proposition welds two questions together, and they are not the same kind of question.
“Does copyright subsist in this code?” is complicated. It is hard, it requires expertise, and it has an answer. Lawyers are exactly the right people to work on it, and more legal expertise genuinely gets you closer to that answer.
“What is this company worth?” is complex. It is emergent and context-dependent. It depends on who is buying, why, when, what else they own, and what they intend to do with the thing. There is no correct answer sitting in a book waiting for a sufficiently expert person to retrieve it. Ask two analysts to value the same private company and you will get two numbers and two narratives.
The error in the headline proposition is not that the legal analysis is wrong. It is that certainty from the first kind of question is being transferred to the second kind, where it cannot survive. Everything that follows splits along that line.
What I Conceded, Early
There is a well-worn example in this debate: a monkey steals a photographer’s camera and takes a selfie. The selfie has no copyright, because the author was not human. Courts have actually dealt with this . It is settled, and it is correct.
So I conceded the strongest part of the opposing case before we argued about anything, because I do not need it to make my argument:
- Vibe coding is the monkey with the camera. If you write a description of what you want, press generate, and press it again until you like the result, you have not authored the output. You have selected it. There are a lot of people building products this way right now who have no idea how the code works and could not direct a change to it if they had to. I would not defend a copyright claim on that work in any jurisdiction.
- Prompting alone is not authorship. Current US Copyright Office guidance says so directly, and I am not arguing with it. “Build me an authentication system” does not make me an author, however sincerely I wanted one.
- Approval alone is weak. Saying “approved” to something a machine produced independently does not convert its expression into mine.
Everything I just conceded describes a person using a chatbot. It does not describe how software is actually built by a competent engineering organisation, and that is where the disagreement lives.
The Development Model the Debate Is Actually About
I do not write code any more. The agent performs every edit: the letters, the numbers, the semicolons. And across a single file there might be thousands of directed changes in which I determine the architecture, the boundaries and responsibilities, the abstractions and interfaces, the behavioural requirements, and the implementation constraints. I reject implementations I do not like. I say things like: that has the wrong responsibility, split the orchestration from the execution, move validation behind that interface, make this immutable and have that return a value instead of mutating its argument. The thing that survives all of that is the product.
My claim is that this constitutes enough human involvement to substantiate authorship even though I never typed a line. Typing is evidence of authorship. It was never the definition of it.
Here is the part I did not expect. The lawyer agreed. Not grudgingly, and not as a debating concession. His own working heuristic, developed long before this conversation, is what he calls one-to-one correspondence: if you can trace a detailed correspondence between what the human specified and what appears in the output, he could be convinced there is sufficient human authorship. His example is a five-thousand-word prompt describing a log cabin on a lake, down to the smoke curling from the chimney and the truck parked outside, checked item by item against the resulting image.
My addition was iteration. I rarely write the five-thousand-word specification up front. I write it across two hundred exchanges, each one a decision, a rejection, or a directed correction. The overlay of all of those iterations is functionally identical to his long prompt. The machine on its own could not have produced, and did not produce, the thing that shipped. On that, stated exactly that way, he said we were in one hundred percent agreement.
So where is the disagreement? In the law’s current state, not in the principle. In the United States there is a decided case, Thaler v. Perlmutter , establishing that an AI cannot be named as an author, which is a different question. The question we were actually debating, whether sufficiently detailed iterative human direction rises to authorship, is the subject of Allen v. Perlmutter , litigation that is still pending in a federal district court in Colorado as I write this. Until a court rules, both of us are extrapolating. He extrapolates cautiously, as a lawyer should. I extrapolate from how the work is actually done. Neither of us can cite a decision that settles it. Treat anyone who claims otherwise, in either direction, accordingly.
Code Is a Literary Work, and That Is the Problem
His strongest technical point deserves to be stated properly, because it changed how I think about the evidential side.
Copyright does not look at source code as a machine. It looks at it as a literary work, the same category as a novel, and it explicitly does not consider functionality, which is patent territory. So when a dispute arrives, a court appoints an expert to read the code as text and to trace correspondence between what the human directed and what the code expresses. With an image, a judge can see the cabin and the smoke. With half a million lines of C#, the correspondence between an English-language architectural instruction and the code that embodies it is invisible to anyone who cannot read code fluently, and people who read code the way the rest of us read prose are rare in expert-witness pools.
I pushed back that the correspondence between English words and an image is exactly as constructed as the correspondence between English words and code; it is simply that judges happen to be able to see pictures. He took the point. But his practical observation stands, and it leads somewhere important: the barrier for agentic development is not primarily doctrinal. It is evidential.
That cuts both ways, and I tested it. I asked how anyone would prove that a codebase from 1985, written entirely by humans, was written by humans. The answer is the same answer as for anything in civil law: the person asserting ownership proves it with a preponderance of evidence, through forensics, testimony, and discovery, at a cost he estimated as six months and half a million dollars. There is no property of source code that announces its origin. There never was.
Which means the practical advice for anyone building with agents is boring: keep the record. The architecture decisions, the instructions, the rejected implementations, the review discussions, the thing you said no to and why. Agentic tooling increasingly keeps this by default. That record is simultaneously your authorship case and, as I will get to, a fair chunk of what an acquirer is actually buying.
The Jurisdictional Wrinkle Almost Nobody Mentions
One more legal point, because it undermines the word “absolute” in the headline claim all by itself.
The proposition is a statement about US doctrine presented as a statement about the world. In the UK, where I work, the law offers two routes rather than one. The first is the same as everywhere: sufficient human authorship makes it an ordinary copyright work. But if a court decided the machine had made too many of the expressive decisions, UK law does not fall to nothing the way US law does. The Copyright, Designs and Patents Act 1988 provides that for a computer-generated work with no human author, the author is the person “by whom the arrangements necessary for the creation of the work are undertaken.” That provision is nearly forty years old. It was written so that someone who directed a computer to generate artwork could own the result, long before anyone had heard of a transformer model.
Nobody knows precisely how “arrangements necessary” maps onto a developer running a local agent against their own repository, defining the architecture, issuing the instructions, and committing the results. It has not been tested against modern AI, and the government has acknowledged the uncertainty while explicitly declining, so far, to reform the provision . But the structural point stands: in the US, losing the authorship argument is the end of the road. In the UK, losing the authorship argument redirects you to a different question, one that is considerably easier to answer in the developer’s favour. A company selling to a UK or European acquirer is not being valued against US Copyright Office registration guidance.
Does It Even Matter?
This was my second assertion going in, and it is the one I actually care about: the value of a software company was never in the copyright of its code.
A business exists to create a customer. Its value at sale is the expectation that it will keep doing so. Everything an acquirer pays for, the revenue and its durability, the customers and what it would cost to replace them, the data, the distribution, the team that built version one and will build version four, is a proxy for that expectation. The source code is the current implementation of it, and it is the fastest-depreciating asset on the list.
The claim “no copyrightable code means no value” also proves far too much. Every consultancy owns essentially no product code and sells. Most SaaS runs overwhelmingly on open source the company does not own, and sells. Companies are routinely acquired for customers, team, and distribution, and the acquired codebase is deprecated soon after. If unowned code zeroed a company’s value, whole categories of routinely-acquired businesses would be worthless, and they are not.
But I want to represent the other side of this properly, because the strongest argument I heard all hour was here, and it was not about copyright doctrine at all. It was about transactions. No sane buyer pays ten million dollars for something the seller cannot demonstrate they own. Acquisition agreements and software licences carry a warranty of title: the seller represents that it has good right, title, and interest in what is being sold. Banks take security interests in IP when they lend. If you cannot make the warranty, the deal structure starts to wobble, and the hundred-million-dollar government licensing deal your acquirer planned to sign the next day wobbles with it.
That is true, and it matters, and it is also a different claim from the one on the conference slide. It is not “your company is worth nothing.” It is “your deal will have friction: representations you cannot cleanly make, diligence that takes longer, escrow and indemnity where there would have been a signature.” Friction prices in basis points and lawyer-hours. It does not price to zero. And notice what actually resolves it: not a court ruling five years from now, but the boring provenance record from three sections ago. The correct response to the title-warranty problem is a process change, not a write-down.
Copyright Was Never the Moat
There is one more leg to the argument, and it is the one that I think ultimately dissolves the headline claim.
The implicit premise underneath “no copyright, no value” is that copyright in the code is what stops a competitor. It is not, and it never was. Copyright protects a particular expression. It has never protected function, method, or behaviour; that exclusion is the deliberate design of copyright law, not a loophole in it. Clean-room reimplementation, in which one team describes what software does and a separate team that has never seen the source builds it fresh, is a decades-old lawful practice. It is how competing implementations have always been built.
What AI changes is the cost. There are now services that will take a codebase, have one system describe in prose what it does, and have a second, air-gapped system generate new code from the prose alone. The output is functionally equivalent and expressively unrelated. In our debate I claimed the owner of the original “can’t” stop this. The lawyer corrected me, and the correction is fair: the initial act of reading the code without authorisation is itself infringement, injunctions against downstream use exist, and the honest word is “won’t,” at least until someone is sued, because so far nobody has been. I accept that. We agreed, in his phrase, that this is all academic until somebody gets sued.
But notice what the correction leaves intact. If a competitor with lawful access to your product’s behaviour, and every competitor has lawful access to your product’s behaviour, can re-express it at a fraction of the old cost, then copyright in your tokens was doing very little of your defending. What defends a software business is what always defended it: trade secrets, contracts, accumulated data, customer relationships, switching costs, and above all rate of change, because a perfect clone of today’s system competes with the version you have already replaced. Every one of those is untouched by the question of who typed the characters.
What Would Change My Mind
A claim I cannot state falsification conditions for is an opinion, not an argument, so here are three.
I would revise the authorship position if a court ruled that human direction and review of an agent cannot constitute authorship at any level of abstraction, not merely that it failed on particular facts. I would revise the valuation position if someone showed me an acquisition priced explicitly on source-code copyright, not a deal where IP was diligenced, every deal diligences IP, but one where the price moved on the registration. And I would revise the whole argument if evidence emerged that acquirers systematically discount AI-built codebases toward zero, as a pattern rather than an anecdote.
None of the three exists today. The pending US litigation could produce the first within a few years, and if it goes against the position I have argued here, I will write that article too.
Where We Landed
An hour of genuine disagreement with a genuine expert produced more agreement than either of us advertised. Purely machine-generated expression with no human author is not copyrightable, and should not be. Detailed, iterative, directed human involvement probably crosses the threshold, and both of us think so; the law simply has not said so yet. The hard problem is evidential rather than philosophical, which makes it an engineering problem, and engineering organisations solve those. The trade went both ways: I left with the evidential problem lodged in my thinking, and he left saying the valuation argument was going back into his practice.
And underneath it all: “who typed the code?” is the wrong test, asked of the wrong asset. The questions that matter are who determined the expression, whether that determination can be evidenced, and what the copyright was ever protecting. For software built the way software is now built, all three answers point at the same place. Not at the artefact, but at the system of work that produced it: the architecture, the decisions, the rejections, the record of a human mind directing a very fast machine. That system is unambiguously human. It is also, not coincidentally, the thing the buyer was paying for all along.
If you want the strongest version of the other side of this argument, made by the people who spend their working lives in it, start at whoownsthecode.com . Disagreement this useful deserves the traffic.
If you are building with AI agents and thinking about what that means for your IP position, your diligence readiness, or the provenance record your tooling should already be keeping, let’s talk .
Smart Classifications
Each classification [Concepts, Categories, & Tags] was assigned using AI-powered semantic analysis and scored across relevance, depth, and alignment. Final decisions? Still human. Always traceable. Hover to see how it applies.