"Is AI Actually Killing Open Source?"

A developer writing at jross.me published a short, personal essay this week titled "Open Source as We Know It Is Dead," and the first thing to say about it is that the headline is, by the author's own admission, a bit hyperbolic. But the essay behind it is worth sitting with, because it names a feeling a lot of people who learned to code over the last fifteen years quietly share: that something about the open source world they grew up in is slipping away.

His story will feel familiar to anyone self-taught. He opened his GitHub account on June 17, 2011, and within minutes had filed his first issue — teleporting was broken in TShock, a Terraria server mod, and he wanted to know why. Before GitHub there were SVN checkouts that "broke if you looked at them wrong," DarkRP tinkering on Garry's Mod servers, and SourcePawn plugins for Counter-Strike: Source. What GitHub did, he writes, is make it feel like everyone was finally "in the same room."

His argument, stripped of the dramatic title, is that open source as he's known it is dying — and that AI is what's killing it. The thing he says is being lost isn't the code, which is more openly available than ever, but something harder to measure: the social fabric of contribution, the apprenticeship loop where a stranger reads your code and patiently explains why your issue was "probably a bit dumb."

There's a genuinely sharp observation buried in the essay. For decades, the default way to learn software was to read it — clone a repo, trace a function, ask a maintainer. That "read the code" step is now being short-circuited, because the fastest answer to "why does this break?" is to ask a model rather than dig through the source. It's quicker, and often good enough, but it quietly removes the part of the process where people actually absorbed how a codebase was put together.

The second pressure point is the one maintainers already feel. The same AI that lets a newcomer generate a plausible patch also lets them generate a plausible-looking-but-subtly-wrong patch, and the cost of reviewing a flood of those lands on the handful of unpaid humans who keep a project alive. Burnout was already the defining problem of open source before AI arrived; a tool that multiplies incoming patches without multiplying reviewers doesn't ease it.

But there's a real counterargument the essay leaves mostly unexamined, and it's the constructive half of the story. A newcomer who can't yet parse a million-line codebase now has a way to make a first contribution at all — AI can explain the unfamiliar file, draft the boilerplate, and translate a maintainer's terse comment into plain language. For people who were never going to "read the source" the way the author did, AI isn't the thing blocking the door; it's the ramp that gets them through it.

The essay's most important line is the fragment it opens onto — "It was never just the code." That's the real thesis. Open source's value was never only the MIT license and the public repo; it was the mentorship, the issue threads, and the small miracle of a stranger merging your pull request. Licenses and weights can be copied endlessly. A community of patient maintainers cannot.

There's also a long history of people declaring open source dead, and it's worth remembering before sounding the alarm. The rise of SaaS and the cloud was supposed to kill it; "open core" was supposed to hollow it out; big companies "embracing" open source was supposed to co-opt it. Each time, the thing that was actually happening was more complicated — the model evolved rather than expired. AI is likely to be the same kind of inflection, not a funeral.

This is where the essay dovetails with a thread I picked up in August about Tim O'Reilly's claim that the big AI labs are "reading the future wrong." O'Reilly frames the stakes as an architecture of participation versus control. This essay is describing the same fault line from the ground level — participation, in its telling, is the thing AI is quietly eating, one skipped "read the code" step at a time.

The honest read is that open source isn't dying so much as being re-brokered. The code stays open, the weights stay downloadable, the license stays intact. What's genuinely at risk is the human apprenticeship — whether the next generation learns by reading code and talking to maintainers, or by prompting a model and never seeing the source. That would be a real loss if it happens, but it's a loss we can still choose to prevent.

The essay, for all its melancholy, is really a prompt rather than a verdict. The most useful response isn't to argue about whether AI is good or bad for open source, but to actively preserve the parts worth keeping: fund and recognize maintainers, build AI tooling that helps review and triage rather than just generate, and — as unglamorous as it sounds — keep telling newcomers to read the code and ask the "dumb" question. The small miracle of a stranger merging your pull request is still available; it just needs people willing to keep the lights on.

Originally reported in the essay "Open Source as We Know It Is Dead" at jross.me, with the Open Source Initiative and its definition of open source as reference points for what the term has historically meant.