Is AI killing open source?
In January 2026, Adam Wathan revealed in a GitHub comment that Tailwind Labs had cut 75 percent of its engineering team, three of four engineers, after an 80 percent revenue drop. He blamed the "brutal impact" AI has had on the business. Usage, meanwhile, was at an all-time high, about 75 million monthly npm downloads, running on 51 percent of web projects per the 2025 State of CSS survey.
AI didn't touch open source's code. It broke two assumptions the whole model depended on. Maintainers could fund the work because developers visited their sites. Companies could install packages without much worry because published code was assumed safe. Tailwind shows the first assumption failing. The npm supply-chain attacks show the second. What replaces them, I don't know.
The funding assumption just broke
Tailwind's own numbers show what happened. Docs traffic fell about 40 percent over two years while downloads climbed to their highest point ever. Developers still use Tailwind as much as ever. They just stopped visiting the site.
An AI assistant hands you the utility classes directly, in the editor, with no detour through the documentation. The business depended on that detour. The framework is free; Tailwind Labs makes its money selling component templates and UI kits, and the docs were where developers found out those exist. When nobody visits the docs, that income dries up, even while downloads keep climbing.
Google AI Studio and Vercel have since stepped in with sponsorships, and that money is keeping the remaining team employed. But a sponsorship lasts only as long as the sponsor decides it's worth paying for, and that decision comes up again every year.
AI-assisted development cut out the step where a developer opens your website. Nobody has built a new way to fund the work yet, for Tailwind or for anyone else.
The trust assumption just broke too
The other assumption is trust in the supply chain, and it's had a rougher two years than the funding side. In September 2025, a self-replicating worm named Shai-Hulud started harvesting CI/CD secrets out of compromised npm packages. The first day's count was around 40, including several published by CrowdStrike; a week later, when CISA issued an alert, the number had passed 500. Two months later, Shai-Hulud V2 compromised more than 700 npm packages and spun up over 27,000 malicious GitHub repositories.
Over a 48-hour window on May 11–12, 2026, a variant
nicknamed Mini Shai-Hulud compromised 172 packages across npm
and PyPI, 403 malicious versions in total. The
compromised scopes included @tanstack,
@mistralai, and @opensearch-project
— the first single campaign to cross both registries.
These are credential-theft worms
exploiting the fact that a package manager treats
"already published" as "safe to install."
At the same time, AI has gotten very good at finding vulnerabilities nobody planted. Google's Big Sleep had autonomously found about 20 vulnerabilities in widely used open-source software, mostly FFmpeg and ImageMagick, by August 2025. In June 2025, an autonomous agent built by XBOW topped HackerOne's leaderboards, outranking thousands of human researchers with more than 1,000 vulnerability submissions. In January 2026, OpenSSL shipped 12 zero-day vulnerabilities in a single patch release, all 12 found by one AI system called AISLE. Curl is on pace for roughly 50 published CVEs in 2026.
Finding vulnerabilities at this scale isn't hypothetical anymore. It's already happened, repeatedly, in libraries half the internet depends on.
AI now finds vulnerabilities far faster than AI, or humans, can correctly fix them. OpenSSL and curl's numbers show discovery running far ahead of the pipelines that are supposed to fix what it finds.
I've watched that gap turn into cost firsthand, on teams working under FedRAMP or SOC 2. What used to be routine hygiene, a Dependabot PR here, a version bump there, is now a standing line item. It's someone's job, every sprint, triaging which of the week's flagged packages are real. A lot of my own team's time now goes into that gap between finding a vulnerability and actually fixing it.
The fixes are their own problem now
This part I know firsthand, and it's why I don't think the problem stops at finding more vulnerabilities. On the team I lead, we've been through an ocean of AI-generated pull requests that were supposed to close a flagged CVE and didn't.
The same pattern keeps coming up. The PR bumps a version number in
package.json while the vulnerable code path
is still reachable underneath it. Or it fixes the flagged
issue but breaks the product, because the model reasoned
about the CVE in isolation from how the dependency was
being used in our code.
That's the same blind spot I've written about with full rewrites: an agent producing something clean and plausible without carrying forward the reasoning that made the original correct. Review catches most of these before they ship. Catching them isn't free, and every one that slips through creates a second incident on top of the first.
It got bad enough that code owners brought it up in meetings and asked people to stop opening these PRs altogether. Reviewing them more carefully wasn't the answer, because the assistant writing the fixes didn't understand the code well enough to get them right. That's a step past engineers leaning on AI before they've earned the judgment to check it. This is senior engineers making the same call about a narrower, higher-stakes task.
My own library hasn't noticed any of this
None of this shows up in the library I maintain. No unusual PR volume, no new attack surface, no funding question, because there was never funding to lose. So far this is hitting big infrastructure like Tailwind and heavily used ecosystems like npm — projects big enough to be worth attacking, or with enough revenue to be worth undercutting. A small library maintained by one person for the reward of maintaining it isn't a target, at least not yet.
One thing did change, just this morning. I asked one of the newest AI models to go through the codebase, the same question I had put to earlier models more than once, and they always came back with some version of "everything looks good." This one found almost 20 real improvements. Same code, same question, much better model. The vulnerability numbers earlier in this post come from that same jump in capability, applied to much bigger codebases.
What comes after: one hope and three guesses
There's an obvious objection. Open source has been declared dead before, and it has survived every time. That's fair.
Funding has always been precarious; ask any maintainer who's begged users to sponsor a daily dependency. Package registries have carried malware since long before language models existed. What's different is that both broke at the same time, and at the scale of whole ecosystems rather than single projects. I can't point to another time that happened.
I don't know what comes after that. Whatever comes next, I hope it keeps the best thing open source gave this industry: someone without capital, or a company behind them, could build something that mattered, in public, for free. That's worth protecting no matter how the funding problem gets solved.
Beyond that, I have three guesses. I'm not confident in any of them:
- The gap closes from the fixing side. Finding vulnerabilities at scale is already solved — Big Sleep, XBOW, and AISLE proved that. If fixing them correctly catches up to that pace, sneaking a new one in gets genuinely hard, and the race tips toward defense instead of staying even.
- A new language or ecosystem emerges, built from the ground up for AI-generated and AI-reviewed code, with supply-chain trust as a native feature.
- The industry regresses toward something like the pre-open-source norm. Companies protect the code that's actually worth money. What stays public is the hobby project, published by someone who never expected it to pay them back.
Which one wins depends on decisions nobody's made yet: how registries verify publishers, whether AI vendors treat fixing vulnerabilities as a product worth building. It also depends on whether Tailwind turns out to be the outlier or the first of many. I don't have that answer yet. Neither, as far as I can tell, does anyone else.