Open Source is dead. Long live Open Source.

LLMs changed one thing about the economics of software: generating code became nearly free. Verifying it didn’t. Reviewing a patch, checking that a fix is correct in its context, deciding whether a bug report is real: all of that costs what it always did.

That asymmetry is the whole model. Generation cost collapsed; verification cost didn’t. Three consequences follow:

1. The moat around code was never the license. It was the cost of reimplementation, a generation cost, and it’s gone.
2. Owning the codebase and adapting it to your exact needs becomes such a big advantage that most software goes internal. What stays shared is what’s too expensive to verify alone.
3. Shared projects stop accepting outside code, because reviewing it costs more than generating your own.

None of this means copyright or open source “dies” in some dramatic legal sense. The economics shift first; the law catches up, slowly.

The moat was never the license

Copyright protects expression, not ideas, and software copyright was always thin; clean-room BIOS clones built an industry on that decades ago. Where reimplementation isn’t legal, it happens anyway. What actually protected closed software was that reimplementing it was expensive. Now you point a model at an application, its documentation, its protocol, its observable behavior, and get a working reimplementation for a fraction of the old price. Whether it’s legally clean is contested, and moot: nobody litigates over a weekend clone of a mid-sized tool.

Source-available licenses defeat themselves. Most of these projects started as open source to harvest contributions, PR, and adoption. When cloud vendors harvested them back, they switched to source-available licenses (BSL, SSPL and friends): the semblance of open source, without letting competitors use the code. That bargain only worked while code was expensive to reproduce. Now the visibility that buys adoption is the same visibility that feeds the clone.

Distribution becomes a liability. Anything you ship, binary or source, is input for someone else’s reimplementation. Closed software survives only where its value isn’t in the software surface: proprietary data, network effects, operational depth, algorithmic depth that can’t be inferred from behavior. Things that belong to the service, not the artifact.

There’s an irony here. This sounds like Stallman’s dream of software freedom arriving without the license. It isn’t. Copyleft’s leverage was that you wanted their code, and share-alike was the price. When reimplementation is cheap, nobody needs their code, and the leverage is gone. And value migrating to services you can’t inspect or fork is exactly the outcome Stallman fought. We get freedom over artifacts and lose it over everything that matters.

Patents face the same asymmetry: filings, prior art, and litigation are all cheap to generate now, and all of it lands on human examiners and courts. Stalemates between large portfolio holders are stable, so I don’t expect abolition. I expect patents to stop working as an innovation incentive and survive as ammunition for whoever can afford to fire it. But ammunition needs a visible target, and private, never-distributed code is invisible infringement.

Buy versus build flips

For decades the default was to buy software, or to use an open-source project as-is and contribute upstream. Both defaults rested on modification being expensive. It isn’t anymore. An LLM can extend a codebase, adapt it to your exact use case, and strip out everything you don’t use. Public projects support functionality for everyone, and every feature you don’t need is bug surface and attack surface you carry for nothing.

The traditional objection to forking is maintenance: you spend your life porting upstream fixes. Half of that cost collapsed; an agent can generate the port. Checking it is the half that didn’t. A fix is correct only in its context, and the more you diverge, the more each port becomes a fresh change to verify. The cost scales with divergence, so the projects worth forking are the ones with a small core.

The other objection is field experience: a mature project has been hit by thousands of users in thousands of configurations; your fork hasn’t. But field testing concentrates in shared code paths, so stripping the periphery loses little. The periphery you add is field-tested by exactly one user: you. For much software that’s enough, because yours are the only needs it has to meet. In high-variance, high-risk domains it isn’t. Those domains standardize their operations, standardized operations mean standardized software, and standardized software pools field experience across everyone running it. That’s where the minimal cores come from. Infrastructure is a public utility.

So shared software shrinks to minimal cores, protocols, and specs, and most of what sits above becomes private periphery. Software whose value is compatibility (protocols, file formats, crypto libraries) stays shared, because sharing is the point. Everything whose value is fit to your process goes internal.

The deliverable of a minimal core is no longer mainly its code. Value moves to the side of the model that stayed expensive: verifiable specs are the product. A verifiable spec is what lets your agent port a fix and know it worked. It’s also where intent becomes explicit, and agents, unlike humans, don’t bring intent with them. Multiple models reviewing the same code give less independence than it seems; they’re trained on overlapping corpora and share blind spots. A verifiable spec is the one check that isn’t correlated with any model.

Open source was always about knowledge

The most interesting objection: open source didn’t just distribute code, it distributed knowledge. Patterns, failure modes, hard-won lessons about what breaks. If everyone forks privately, don’t we lose that?

Open source’s real product was always knowledge. Code was the delivery vehicle. LLMs replace the vehicle. You don’t need to share code for a model to know that a pattern is racy or that a retry loop without backoff melts things.

But the vehicle was also the feedback loop. Models learn from public artifacts: code, issues, CVEs, postmortems. If new failure knowledge stays inside private forks, the corpus that trains the next model starves. Faster training cycles fix lag; they don’t fix starvation. The commons problem moves up a layer, from code to knowledge.

Cooperation returns, around capital

In the early 1980s software went proprietary, and the hackers at MIT lost the code they used to share. The answer was GNU, and eventually Linux. Cooperation re-emerged because the bottleneck, labor, could be volunteered. You could write a compiler on nights and weekends. You can’t volunteer a frontier training run. The bottleneck now is capital, hardware, and data, so cooperation re-forms around those.

Data’s value is in aggregation. My biometric data is nearly worthless alone and valuable pooled with millions of others, which is why individuals hand it to vendors: the vendor is the pool. Governments do the same with health records. The more boutique software becomes, the more small holders of low-value fragments there are, and the stronger the incentive to pool. The mechanism is reciprocity: contribute data, get access to the pooled model or corpus. It looks like share-alike one layer up, but data has even thinner copyright than code, so what enforces it is access control. A club, not a license.

Who runs the pool matters less than it seems. Vendor, government, cooperative: same economics, same incentives, converging behavior. Most stock exchanges began as member-owned cooperatives and became for-profit companies without changing much about what they do.

Open source, closed contribution

The corollary for the cores that remain: they have no reason to accept outside code.

Integrating outside contributors was always expensive: review, style, architectural drift, the cost of saying no. What changed is the ratio. Why review a patch from someone else’s LLM when yours is better configured for your project, has more context, and follows your governance? Take the bug report, generate the fix yourself.

Monoculture is an advantage here, not a risk. One generator under one governance produces more coherent architecture than a hundred contributors in a hundred styles. Its cost is correlated blind spots, which is exactly what the verifiable spec is for: coherence from the generator, independence from the spec.

This model already exists. SQLite is public domain, closed to outside code, accepts bug reports and test cases, and is one of the most reliable pieces of software ever written. Its own documentation calls it “open-source, not open-contribution.” Its most valuable asset is its test suite, and the most thorough part, TH3, is proprietary: the code is free, the verifiable spec is what’s sold. It’s funded by a consortium of the companies that depend on it: cooperation around capital, decades early. Lua works much the same way. I expect the surviving cores to converge on this model.

Spam economics

It’s already happening for a second reason. Spam filters worked because mass-produced spam was near-identical, something a statistical filter could learn. LLMs make each piece of junk unique, coherent, and almost free. Filtering is verification. When producing junk costs far less than filtering it, content filtering loses, and the network closes.

Before LLMs, only extreme targets paid this price; when I worked at a VC firm, inbound email was effectively a whitelist. LLMs bring the tradeoff to the mass market. Recently a vendor started selling LLM-driven voice telemarketing in Israel, and within about three days the entire country was bombarded with automated sales calls. Content filtering had nothing to grab; every call was unique and coherent. So filtering moved to reputation. Android and iPhone pool their users’ spam marks (the same aggregation as data: one mark is worthless, a million are decisive), and within a week the bulk of the 073-262 block and similar SIP ranges was blocked by everyone. The phone network is still technically open. Nobody answers unknown callers anymore.

Open source is following the same curve. tldraw now auto-closes all external pull requests, after my favorite incident in this whole story: the maintainer’s own AI-generated issues were fed into contributors’ AI tools, producing pull requests that fixed hallucinated problems. Ghostty accepts AI-generated pull requests only for accepted issues. curl shut down its six-year bug bounty. GitHub itself has been weighing restrictions on pull requests.

curl’s case shows it isn’t just code. Bug reports are prose, prose is now free to fake, and reports become spam the same way patches did. What survives is evidence a machine can verify. A failing test either reproduces or it doesn’t. Telemetry attested by a real deployment is far harder to fake than prose; harder, not impossible. Trust moves from the reporter to the evidence, and where evidence can’t be attested, back to the reporter’s identity.

The open problem: vetted field reports

For boutique software this barely matters. For the minimal cores everyone depends on, it’s the unsolved problem.

A core needs field reports, and the field is the forks. Don’t expect them to give back out of goodwill; taking upstream fixes while upstreaming nothing is already common, and cheap forks will make it more so. A fork reports only when it has a strong incentive not to run its own code on that path, which is the case for public utilities, the cores nobody wants to own. Minimal cores again: the narrower the core, the more of the failures that matter land in it. Knowledge flows back without code flowing back, but only through the core.

What’s missing is making those reports trustworthy. Signing proves origin, not truth, and keys are free. Multiple independent reports fail the same way: one actor can generate fifty “independent” reports. Everything reduces to Sybil resistance, binding a report to something costly: attested hardware, a known deployment, a vouched identity. Worse, corroboration fails exactly where it hurts. Security bugs usually have a single reporter, and rare configurations in private forks rarely produce a second report.

I don’t know what the solution looks like. I’m fairly sure it doesn’t exist yet.

What’s dead

• The open-contribution model. The drive-by patch, the “send a PR” social contract. Contribution becomes evidence: failing tests, specs, attested reports.
• Reputation for code. Reputation moves to knowledge and judgment: specs, analyses, field reports, the writing models learn from.
• Copyleft. Reimplementation routes around it. Permissive licenses become irrelevant but harmless, except Apache 2.0, whose patent grant gets more valuable.
• Any business model whose value is the software surface, including lock-in by obscurity. Bluetooth device apps exist to lock you into a vendor’s hardware; Home Assistant broke that by hand, and LLMs make each new integration nearly free.

Assumptions, Assumptions, Assumptions

I’m assuming humans still direct software work. If AGI arrives (whatever your definition), all bets on knowledge industries are off.

I’m also assuming in-house verification capacity. A five-person startup and a bank get very different answers from “fork everything,” and regulated environments add compliance costs that reimplementation doesn’t remove. But end users have firsthand experience with what they use, and for boutique software that’s often all the verification they need. Decades of industrial, mass-produced software taught us that “users are idiots who don’t know what they need.” I think that’s about to be contested.

And one problem stays open, one open source shares with the whole industry: if agents do the work juniors learned on, and outside contribution stops being how maintainers are recruited, where do the next maintainers come from? That’s a separate post.