When an AI coding assistant suggests a function and you accept it, you don't know where that code came from. It might be a novel synthesis derived from general programming patterns. It might also be a lightly paraphrased version of a GPL-licensed algorithm lifted from a GitHub repository you have never visited. The difference between those two outcomes carries real legal weight — and, as of 2026, the tooling to tell them apart at the speed of development does not broadly exist.
That gap is what the phrase "license laundering" describes: the concern that generative AI models, trained on publicly available source code under diverse licenses, can reproduce or closely derive from copyleft-licensed material while stripping the obligations that originally attached to it. The resulting output carries no attribution, no LICENSE file reference, and no SPDX-License-Identifier header. From the perspective of the accepting developer and their employer, the code looks clean. The legal argument is that it is not.
How the Mechanism Works
The training pipeline is where the problem originates. Large language models used for code generation are trained on datasets that include hundreds of millions of files scraped from public repositories. GitHub's public archive, for example, contains code under GPLv2, GPLv3, AGPL, LGPL, Apache 2.0, MIT, and no discernible license at all — often interleaved within the same dataset batch. The models are not trained to track license provenance per token; they are trained to predict statistically likely next tokens given a context.
When such a model generates output, the output can be a novel recombination, an independent solution, or something measurably close to a specific licensed source. Researchers examining Copilot's outputs in 2022 found cases where the tool reproduced recognizable verbatim sequences from licensed code — the Codex-era behavior that became the evidentiary foundation for Doe v. GitHub, the ongoing class action against GitHub, Microsoft, and OpenAI filed in November 2022. The district court dismissed direct copyright infringement claims in 2023, partly because plaintiffs did not identify specific verbatim reproductions in sufficient detail, but DMCA § 1202 claims and breach of contract claims survived and are now before the Ninth Circuit on an interlocutory appeal.
The "laundering" framing comes from a specific downstream concern: a developer accepts an AI suggestion, ships it in a proprietary product, and the snippet turns out to be functionally identical to GPL-licensed code. Under the GPL, that would obligate releasing the entire product's source under GPL terms — the so-called "copyleft surprise." Nothing in the developer's workflow flagged the risk. No license header appeared in the suggestion. The AI intermediary effectively washed the provenance information out of the delivery.
A related concern has gotten sharper lately: whether a deliberate AI-assisted rewrite of GPL code to produce a "clean-room" reimplementation is legally valid. A recent Hacker News thread surfaced a case in which an FFmpeg developer publicly accused a project called OxideAV of exactly this — claiming their MagicYUV implementation was a "clean-room implementation with zero third-party source consulted," while the developer alleged that an AI assistant had in fact incorporated FFmpeg's code in producing the output. The specific legal outcome of that dispute is not yet established, but the incident attracted significant discussion because it crystallizes what a plausible laundering attempt looks like in practice: use an AI tool to produce functionally equivalent code, then claim it as independent implementation.
What Open Source Projects Are Actually Doing
The concern is not hypothetical to maintainers. QEMU formally banned AI-generated code contributions in 2025. The project's policy states that with "AI content generators, the copyright and license status of the output is ill-defined with no generally accepted, settled legal foundation." Two specific problems drove the decision. First, QEMU requires contributors to sign a Developer's Certificate of Origin attesting that the code was "created by me" — a statement that is legally difficult to make when an AI produced substantial portions of it, particularly given that AI output lacks recognized copyright in many jurisdictions. Second, training data transparency is insufficient: contributors cannot certify which licensed sources a given suggestion may have drawn on.
QEMU is not alone. The FFmpeg project's developer mailing list hosted a detailed 2025 thread on AI contribution policies, with one senior developer arguing that blanket bans are counterproductive but acknowledging that license compliance is the central constraint. The broader ecosystem is watching. An open letter signed by ten open source foundations in September 2025 warned that open source "operates under a dangerously fragile premise" reliant on community goodwill — a statement that, while addressing a range of issues, was partly motivated by AI-generated contribution floods creating review burdens and provenance uncertainty.
The quantitative evidence on the enterprise side is striking. Black Duck's 2026 Open Source Security and Risk Analysis (OSSRA) report, based on audits of 947 commercial codebases across 17 industries, found that 68% contained license conflicts — up from 56% the prior year, the largest single-year jump in the report's history. The report explicitly links part of this increase to AI-generated code introducing snippets potentially governed by restrictive licenses. Separately, Black Duck found that while 76% of organizations screen AI-generated code for security risks, only 54% evaluate it for IP and licensing risks.
If your team uses AI assistants to generate code shipped in a commercial product, not auditing for license provenance is a governance gap — not a theoretical risk. The OSSRA data suggests most organizations have exactly that gap. One audited codebase in the report contained 2,675 distinct license conflicts.
What Is Known Versus What Is Speculated
It is worth being precise about what remains genuinely unsettled, because the discourse on this topic oscillates between dismissiveness and catastrophism.
Established: AI models can and do generate code that is close to or verbatim from their training data in certain contexts. This was observed empirically with Copilot in 2022, and the Doe v. GitHub litigation proceeds on that factual premise. The case's ongoing survival through multiple dismissal motions suggests the courts do not regard the claim as frivolous.
Established: Copyleft licenses like GPLv2 and GPLv3 contain obligations — attribution, source disclosure, reciprocal licensing — that are real legal requirements, not advisory guidelines. Violating them is actionable. The Software Freedom Conservancy has litigated GPL compliance for two decades, and GPL enforcement actions are not rare.
Contested: Whether AI-generated code that is functionally similar but not verbatim identical to GPL code "triggers" copyleft obligations. This turns on whether the output is a derivative work under copyright law. Courts have not resolved this for AI-generated material. Vendors take the position that their outputs do not carry the training data's licenses; critics argue that position reflects a conflict of interest and is not yet legally validated.
Contested: Whether a deliberate AI-assisted "clean-room" rewrite of GPL code is legally equivalent to a legitimate clean-room reimplementation. Traditional clean-room development involves a strict firewall between engineers who read the original code and those who write the reimplementation. Using an AI trained on that same original code as the intermediary may not satisfy that standard — but no court has tested this specific fact pattern as of this writing.
Speculative: That AI-assisted relicensing, if accepted by courts, would effectively end copyleft licenses. This is a plausible downstream scenario argued by some open source advocates, but it depends on a chain of judicial decisions that has not happened.
Practical Steps to Reduce Provenance Risk
You cannot fully eliminate the uncertainty from the legal environment — that is a problem for courts and legislators over the next several years. You can, however, make deliberate choices that reduce your exposure and put you in a defensible position if a provenance question ever arises.
Run AI suggestions through a license scanner. Tools like FOSSA, Black Duck, and the OSS Review Toolkit can scan your codebase for license signatures and known snippets. They are not foolproof against paraphrased code, but they catch verbatim reproductions and common license-conflict patterns. Making this part of CI means you catch conflicts at merge time, not at audit time.
Use Copilot's "duplication detection" filter. GitHub Copilot has an optional filter that suppresses suggestions matching public code it has seen. Enabling it does not provide legal certainty, but it materially reduces the probability that a suggestion is a close reproduction of a specific licensed source.
Document AI use in commits and PRs. If you accept an AI suggestion, noting it in the commit message or PR description creates a traceable record. If a license question arises later, "we reviewed this output and verified it against our license policy on this date" is a stronger position than "we have no records of how this code was produced."
Establish a policy for GPL and AGPL dependencies. The copyleft surprise is most likely to be catastrophic when it reaches a GPL incompatibility in a proprietary product. Having an explicit dependency policy — approved license types, review process for exceptions — limits the surface where an AI suggestion could silently introduce a problem. LGPL, Apache 2.0, and MIT are generally safer in commercial contexts; GPL and AGPL require deliberate review.
Apply extra scrutiny to "clean-room" claims. If someone on your team or a third party provides code claiming to be a clean-room implementation of a licensed original, and that code was produced with AI assistance, you should treat the clean-room claim as unverified until a human review confirms it. The OxideAV incident suggests this claim can be made in good faith or bad faith — and that verification matters either way.
The legal framework for AI-generated code is genuinely unsettled. The QEMU project's language — "no generally accepted, settled legal foundation" — is accurate as of mid-2026. What is not unsettled is that the obligations in copyleft licenses are real, that open source maintainers are watching, and that organizations are accumulating license debt faster than they are auditing for it. A developer who understands the mechanism is in a better position than one who assumes the AI's output is automatically clean.
Originally published at pickuma.com. Subscribe to the RSS or follow @pickuma.bsky.social for new reviews.
