Elatify
Enterprise AI

Who Wrote This? Provenance as the Next Enterprise Control

The question arrives as a licensing question, and the answer is usually a list of approved tools. It should be a question about records: for this file, can you say where it came from and who is answerable for it?

Elatify Strategic Insights
9 min read

Ask an engineering organisation for its position on AI-generated code and you will get a procurement answer: which assistants are sanctioned, which repositories may contain model output, what header goes on top. That answer is necessary and it is not the one that matters. The load-bearing question is smaller and considerably harder to answer after the fact. For the file in front of you, who wrote it, under what terms, and who read it before it shipped?

In November 2026 Jakub T. Jankiewicz published an essay titled All AI-generated code should be Open Source, which reached the front of Hacker News and drew a long argument — the thread ran past twelve hundred points and roughly six hundred and fifty comments. Most of that argument was about licensing, which is where the essay points. He calls the piece a hot take, and it is one. It is also a useful forcing function, because it separates two things enterprises conflate: the terms you grant on an artefact, and the record you can produce about it.

The Argument, in Four Claims

The proposal rests on four arguments usually recited as one; they fail or survive independently. The first is training-data provenance. Models, on this account, were trained on a large corpus of open-source code scraped without permission or attribution, plus Stack Overflow and Stack Exchange material that is Creative Commons licensed and requires attribution. Converting that into proprietary code is what the author calls “license laundering”. The second is copyrightability: code that a human did not write, he argues, should not be copyrightable at all, grounded in the Monkey Selfie dispute, where a non-human was held unable to hold copyright — a precedent the US Copyright Office later cited when it addressed AI authorship. The third is jurisdictional divergence: countries treat computer-generated works differently, and the UK is named as a jurisdiction that grants them limited protection. Because the rules differ, he wants an explicit open licence or a CC0 dedication rather than an outcome left to whichever court hears it. The fourth is human effort: code is rarely wholly manual or wholly automated, but output produced with minimal human contribution — prompt in, merge out — he argues clearly owes something back.

Four Claims, Four Different Burdens
They are argued together and they do not stand together.
ClaimWhat it assertsWhat it needs to be true
Training-data provenanceModels were built on a large body of open-source code scraped without permission or attribution, plus Stack Overflow and Stack Exchange material whose Creative Commons terms require attribution. Turning that into closed code amounts to “license laundering”.That the training corpus creates an obligation which travels to the output. The essay asserts this; it does not demonstrate the mechanism.
CopyrightabilityPurely AI-generated code is not written by a human, so it should not be copyrightable — grounded in the Monkey Selfie dispute, where non-humans were held unable to hold copyright.That “purely generated” is a state a file can actually be in. Real artefacts are mixed, often at line level.
Jurisdictional divergenceCopyright treatment of computer-generated works differs by country, with the UK granting limited protection to such works. Uniformity of fairness therefore requires an explicit open licence or a CC0 dedication.That harmonising by dedication is preferable to harmonising by contract, and that a dedication is meaningful without a right to dedicate.
Degree of human effortCode is rarely fully manual or fully automated, but output shipped with minimal human contribution — prompt in, merge out — should be open.That effort is measurable per artefact, and that a threshold can be defined without becoming a compliance exercise of its own.

What Is Settled, and What Is Not

This is not a settled area of law, and an architecture decision that assumes otherwise is borrowing risk it cannot see. What can be said with some confidence is narrow. The US Copyright Office has addressed AI authorship. The Monkey Selfie precedent is the commonly cited foundation for why non-humans cannot hold copyright. Copyright treatment of computer-generated works differs by jurisdiction, with the UK the named example. Stack Exchange content is Creative Commons licensed with attribution requirements.

What is emphatically not settled is whether any of that creates an obligation on the output. That training on open code obliges you to license what a model emits is the essay's central claim, not a finding. That purely generated output is uncopyrightable as a general rule is a contested reading. And whether any of it is enforceable in practice is a third question again. A commenter in the thread put the forecast bluntly: he was sceptical that “anything that comes out of AI can't be copyrighted” would end up holding. That scepticism is as reasonable as the essay's confidence, which is exactly why the enterprise answer has to be designed to work under either outcome.

Nothing here should be read as a conclusion about the law. It is a description of a live disagreement and its operational consequences, which is a different thing and, for an architect, a more useful one.

The Objection That Bites Is Mechanical, Not Moral

The strongest reply in the thread does not dispute the ethics. It points out that the proposal may be self-undermining. If output genuinely is not copyrightable, one commenter observed, it would be “un-licensable ... but it can still be made open by publication”. The reasoning is not subtle once stated: a licence is essentially an agreement not to sue for infringement, so with no copyright there is no infringement to promise not to commit. You can put the code in public. You cannot attach terms to it.

For an enterprise that is a stranger outcome than the essay proposes, with downstream consequences that matter more than the licensing debate itself. If a permissive licence over machine output may have little behind it, then so may the warranties, the indemnities and the escrow arrangements built on the same assumption. On the opposite reading — that the output is copyrightable and training creates no obligation — those instruments are fine. The point is that nobody in the room can currently say which reading will prevail, which means the instruments are being signed on a coin flip and nobody has written down that this is what is happening.

That observation reframes the discussion. The enterprise does not need a position on whether AI code should be open. It needs to know, per artefact, which of these worlds it is in — and to have kept enough evidence to act when the answer arrives.

The Reframe Worth Stealing

The most durable line in the thread was a definition rather than an argument: open source is “human-validated code”, and releasing generated code without validation adds no value. A second commenter made the same point from the other side — you can always generate more code; what open source genuinely gives you is the ability to read the code for one particular piece of software and see what it does. A third supplied the trigger condition: openness only becomes relevant when the binary reaches somebody else.

Put together, those three observations invert the metric most AI coding programmes report. A team that announces a large number of accepted model-authored changes is describing production, not assurance. The number that would mean something is how many of those changes a person read closely enough to defend in review — because review is the only step in the pipeline that converts output into something an organisation can stand behind.

The volume argument also fails as a defence. “Most of our code is AI-generated” is not a claim about capability; it is a claim about how little human judgement entered the process. The honest enterprise position is therefore not a licence choice at all. It is a statement about where the review gate sits.

Where the Paper Trail Breaks

Enterprise audit and procurement run on artefacts that were designed for a world where a person wrote the code. Each of them still exists in an AI-assisted repository, and each of them quietly stops meaning what its consumer thinks it means.

Four Artefacts That No Longer Prove What They Used To
None of them is missing. All of them are weaker.
ArtefactWhat it used to establishWhat it establishes now
Commit authorIdentifies a person who can be asked why the change exists.May name a human who clicked accept, or a service account that represents no one.
Licence headerStates the terms the file travels under, inherited from a repository policy.Asserts terms over content whose origin may be a corpus nobody audited.
Review approvalEvidence that a second engineer understood the change before it shipped.Evidence that a diff was opened. Understanding is not implied by the click.
Design rationaleExplains why this shape rather than another, months or years later.Often reconstructible only by re-prompting and hoping for the same answer.

The essay names three consequences, and they are the useful summary. Where nobody authored the artefact, attribution loses its subject — there is no one to ask why the change exists, only a tool and a prompt. Licensing loses its lineage — obligations normally travel with provenance, and provenance is the thing that is missing. And review loses its meaning, because approving a diff you cannot explain is a signature, not a judgement. “We wrote it” becomes a claim about prompting rather than about engineering. None of that requires agreeing that AI code should be open: an estate nobody can attribute is already a control failure.

The Jurisdictional Split Is a Design Constraint

The third claim is the one architects underestimate, because it looks like a legal footnote rather than an engineering input. If treatment of computer-generated works differs by jurisdiction — and it does, with the UK granting limited protection to such works while the position elsewhere remains contested — then a single artefact can carry a different status depending on where the organisation wrote it, where it hosts it, and where it sells the product containing it.

A multinational cannot resolve that once, centrally. What it can do is keep the evidence that lets each market answer separately: which files are model-authored, which human reviewed them, what licence decision was recorded. That is not a legal position; it is the substrate one can be built on later.

The same record pays for itself in less exotic settings. Diligence during an acquisition, an escrow arrangement, a customer security questionnaire, an indemnity negotiation — every one asks a provenance question, and none of them cares about the merits of the open-source argument.

What a Provenance Control Looks Like

The good news is that the work is unglamorous and mostly already invented. It is supply-chain hygiene with one new input: the model, and the human who accepted its output. Five properties make a workable control, and none of them requires a position on whether generated code should be open.

Five Properties of a Workable Provenance Control
All process and record-keeping. None of it depends on how the law lands.
PropertyWhat it has to specify
A record per artefact, not per toolWhich model, which task or prompt reference, which human accepted it, at which commit. Tool-level policy statements (“we permit Copilot”) answer a procurement question, not an audit one.
Review as the gate, not the afterthoughtA named reviewer who can explain the change in their own words. This is the single cheapest provenance signal available, and the one most often skipped at volume.
A deliberate licence decisionDecided per repository and recorded, rather than inherited by default. Where the underlying status is genuinely unclear, say so in the record instead of asserting a licence.
Retention long enough to matterDiligence and disputes arrive years later, when the tool has been replaced and the engineer has left. A record that lives only in a vendor dashboard expires with the subscription.
Third-party material marked separatelySnippets lifted from Stack Exchange or another project carry the clearest attribution obligations of anything in the estate. They are also the easiest to lose track of, because they arrive as answers.

Recording the model per artefact sounds expensive, and is cheap if it is a commit trailer and expensive if it is a spreadsheet assembled after an incident. And yes, review slows delivery at the margin — a gate that never slows anything is not a gate. None of it answers the legal question. It preserves the option, which is the thing a competitor with an empty file will not have when the position clarifies.

Short Answers, Because These Get Asked

The argument, in one sentence: generated code derives from scraped open-source and Creative Commons material, and pure machine output arguably has no author, so it should be released openly rather than enclosed. Is that the law? No. The Copyright Office has addressed AI authorship and the Monkey Selfie precedent is the commonly cited foundation, but whether training creates an obligation on the output is unresolved.

The strongest objection? That output without copyright cannot be licensed at all, so the proposal may produce something publishable but not licensable. The sharpest reframe? Open source is human-validated code, so the value was never the volume — it was that somebody read this specific piece of software and can tell you what it does. And the practical answer, the one that survives every version of the legal outcome: know which code is model-authored, review before merge, record the licence decision deliberately, and keep enough provenance to answer where a file came from.

Ask These at the Next Architecture Review
  1. For a file shipped last quarter, can we name the model, the human who accepted it, and the commit?
  2. Which repositories have model-authored code without a recorded licence decision?
  3. Can a reviewer explain any given AI-assisted change without re-running the tool?
  4. Where do third-party snippets enter our codebase, and are they marked?
  5. If diligence asked this question in eighteen months, would the record still exist?
  6. Who owns the answer — platform, security, legal, or nobody in particular?

Enterprises have spent two years measuring what their assistants can produce and comparatively little measuring what they can account for. Production is the easy half, and it improves on its own. The record does not: it exists because somebody decided it should, and it decays the moment nobody maintains it.

So the reframe worth carrying into the next design review is not “should AI code be open source?” It is narrower and more demanding: can you still say where this code came from, under what terms, and who is answerable for it — and would your answer survive a question asked in eighteen months by somebody who was not in the room?

Elatify builds supervised AI workforces with the records that make them defensible: L7 for orchestrating agent teams, and AI Guardrails for the controls an auditor can actually test — including the ones that apply to the code your agents produce.

The Law Is Not Settled

Whether training creates an obligation on the output, and whether pure output is copyrightable, are open questions. A policy that treats either as decided is a guess with a document number.

A Licence Needs Something to Licence

If the output is not copyrightable, you can publish it but cannot grant terms on it. That is a stranger outcome than the essay proposes, and a harder one to warrant in a contract.

Review Is the Asset

Open source is human-validated code. Generated volume is not a contribution; a person reading a specific piece of software closely enough to defend it is.

Provenance Outlives the Debate

However the licensing question lands, the enterprise still has to answer where an artefact came from. That work is worth starting before the answer is known.

Provenance Is the Control You Can Build Now

The licensing question will be answered by courts and legislatures on their own schedule. The record of what your organisation produced, and who reviewed it, is yours to build this quarter. Elatify helps teams put governance around AI workforces — including the code they write — so the answer exists before the question is asked.

Related Insights

When the Counterparty Says No: Agent Identity as the Real Blocker
An agent on a borrowed credential has no identity a counterparty can verify.
Your AI Workforce Needs a Blast Radius
What an agent was permitted to do, on whose authority, and whether you can prove it.
The Missing Layer in Enterprise AI: Why Agents Need a Runtime, Not a Dashboard
Why a runtime that models blocked state makes supervision governable.