
Did vibe coding kill free software? The math is more complicated than the headline
The other day, I read a line that sounded like it belonged at an end-of-the-world vigil: free software as we knew it was dying because of AI and vibe coding. Whoever wrote it seemed to have already buried open source in a corner of the timeline, complete with flowers and a synthesizer soundtrack. It got me thinking, because there is a small piece of truth in that claim and a huge helping of exaggeration.
The term deserves an explanation, since it has already become part of the slang. Vibe coding means asking an AI to write an application by describing what you want in everyday language, giving the result a quick look, accepting what works, and moving on.
I have some personal experience with this. When I wrote about Cursor and learning Go, I could already feel the tool taking me somewhere strange: I would ask for an explanation, it would give me a polished example, and I would keep going because it worked. Until one day I realized I was writing less and reviewing more, and that reviewing required precisely the knowledge I was outsourcing. This is no complaint against the tool. It is a warning to myself, and I think it applies to people who work with software in general.
But the claim that open source is coming to an end deserves to be taken seriously, not just laughed off. So let’s look at the cases.
The paper that gave the discussion its name
There is a paper titled exactly “Vibe Coding Kills Open Source”, released as an arXiv preprint on January 21, 2026, by Miklós Koren, Gábor Békés, Julian Hinz, and Aaron Lohmann. It is an economics paper, and that detail matters: it did not measure the death of free software. It built a model of what would happen to the ecosystem if AI became the intermediary between users and libraries.
The mechanism goes something like this: a user asks an agent for an application; the agent selects and integrates open-source libraries; the user gets the result without ever visiting the documentation or learning about the projects involved; library usage increases, but contact with maintainers declines; because many projects rely on that contact to attract customers, recognition, or funding, the rewards fall, along with the incentive to create, share, and maintain.
The formulation I like best, and the one that sums up the problem, is this: a library can become more widely used while becoming less able to support the people who work on it.
But the model itself does not point to an inevitable outcome. Its results depend on assumptions about costs, compensation, and contact with users. If AI reduces costs without undermining the mechanisms that provide a return, the outcome can be different. The problem is not simply that productivity rises, but what happens to the compensation of the people who build the components that make that productivity possible. That sentence rarely fits into a headline.
Tailwind: usage grows while revenue shrinks
The most concrete case came from Tailwind CSS. In a comment on January 7, 2026, Adam Wathan, the framework’s creator and CEO of Tailwind Labs, reported record growth for Tailwind, a roughly 40% drop in documentation traffic since early 2023, and revenue down nearly 80%. He also said that 75% of the engineering team had lost their jobs the previous day. That percentage refers to engineering, not the company’s total headcount.
I need to add a caveat here, because this is exactly the sort of thing we tend to skip. These figures are Wathan’s statements, not an independent audit. He attributed the crisis to AI’s impact, but his account does not let us isolate how much of the revenue decline came from fewer documentation visits and how much came from other factors.
Tailwind’s business was not just the framework. It sold commercial components and interfaces, and the documentation served as a storefront. One possible explanation is that when an agent answers the questions and delivers a finished screen, the user no longer visits that storefront or discovers the paid products. It is as if a bookstore lent its books to a robot that reads them aloud outside the customer’s house, while the customer never sets foot in the shop. The image helps explain the mechanism; it does not prove what caused the decline.
There was another revealing episode. A contribution proposed collecting the documentation into a file for language models. Wathan acknowledged the idea’s value but said he could not prioritize it while trying to turn the business around, fearing it might make the situation worse. That deserves a pause: making life easier for users can conflict with funding the people who maintain the software.
Google AI Studio announced a sponsorship, and Vercel also appears among Tailwind’s partners. I found that support interesting precisely because it points to a possible way forward: companies that benefit from the infrastructure contributing directly to its upkeep. It does not solve the problem for the whole ecosystem, but it suggests a direction. There is sponsorship revenue alongside the commercial products, too; the storefront is not the only part of this equation.
curl: generating reports got easy; checking them is still hard
curl adds another layer to the problem, and this one gives me plenty to think about. In January 2026, the project announced the end of its vulnerability bounty program, effective February 1. Daniel Stenberg explained that the volume of poor, badly researched reports was overwhelming the security team. The goal was to remove the financial incentive for those submissions, whether AI-generated or not. Reports of real flaws would still be accepted, just without payment.
The decision did not mean giving up on security reports. After trying to receive them through GitHub, the project returned to HackerOne on March 1, because the GitHub experience had not worked as expected. Bounty payments remained discontinued.
The rule Stenberg advocated is simple and almost obvious: do not report a bug or vulnerability without understanding it and being able to reproduce it. It boils down to a sentence I would like to see hanging in every tech office: the cost of generating a report is not the same as the cost of checking whether it is right.
But the story is not that simple, and Stenberg himself made sure to complicate it. In an April 22 post, he said that poor AI-generated reports had practically disappeared, and that the project was receiving a growing number of good reports, almost all, in his assessment, produced with AI assistance. Yet that unprecedented frequency placed a serious burden on the team, and many findings were ordinary bugs rather than security vulnerabilities. In other words, the machine can help find real problems and still require people to triage them, make decisions, and implement fixes.
That detail seems essential to me if we want to avoid writing a biased account. AI can generate useless contributions that consume time. It can also help uncover real flaws. In both cases, maintainers still have to read, test, and decide. My reading is that automation can increase the demand for maintenance faster than it increases the capacity to provide it. curl illustrates that without requiring us to claim that every AI-assisted contribution is garbage, which is not the argument here.
What about productivity, then?
An assumption comes up often in this debate: if AI makes development faster, maintaining projects gets cheaper too. That can happen in some contexts, but it should not be treated as a universal fact.
An experiment by METR, using early-2025 tools, followed 16 experienced developers completing 246 tasks in open-source repositories where they had, on average, five years of experience. When allowed to use AI, they took an average of 19% longer than when they were not. The result has clear limits: it does not cover every tool, every developer profile, or the capabilities of more recent versions. But it gives us reason to question the idea that higher productivity is automatic, especially in mature codebases, where context matters a great deal.
The curious part is that participants expected a 24% reduction in time before the experiment and still estimated a roughly 20% gain afterward. The measurement showed the opposite.
We cannot freeze the discussion at that result, either. In a February 2026 update, METR reported that a later experiment suggested speed gains, but selection problems involving participants and tasks prevented a confident estimate of the tools’ current effect. The researchers considered it likely that the gains had increased.
In other words, AI can help with certain tasks and get in the way of others, even when the developer knows the code deeply. The 2025 experiment did not compare new prototypes with old codebases. Productivity depends on context, and that context tends to disappear from advertising promises.
Freedom is not the same as sustainability
Here we reach the point that, in my view, separates the serious argument from the social-media argument.
Under GNU’s definition, free software guarantees the freedoms to run, study, modify, and redistribute software, with access to the source code required for some of them. The OSI, in turn, describes open-source licenses as those that allow software to be used, modified, and shared according to the Open Source Definition. Neither definition requires the code to have been typed by a person. So using AI in development does not, by itself, stop the result from being free software.
That does not settle everything, of course. Using AI does not guarantee that every generated snippet can be distributed without concern: questions remain about provenance, reproduction of third-party code, and licensing. Authorship and legal protection also require care. In the United States, for example, the Copyright Office distinguishes AI assistance from generation without sufficient human contribution. That guidance should not automatically be transplanted to other jurisdictions. But what the economics paper and the Tailwind case call into question is not the freedom of the code. It is the relationship between usage and returns: documentation, recognition, professional opportunities, services, and complementary products. A project can remain available under a free license and still see the community that sustained it disperse.
So when someone says free software is over, we need to ask what exactly they mean. The set of freedoms? The habit of learning by reading documentation and participating in communities? Funding for independent maintainers? Public collaboration between people who use software and people who write it? These cases suggest changes in the last three areas, but they do not demonstrate a general deterioration of the ecosystem. As for the first, they do not show that AI use is, by itself, eliminating the freedoms that define free software.
The counterarguments we cannot leave out
Before wrapping up, it is worth mentioning the strongest arguments against the death thesis, because they exist and are reasonable.
The first is that AI will not replace every library. The very paper that talks about death describes agents selecting, combining, and modifying existing components. Its central concern is the loss of returns for the people providing those components, not proof that the components are no longer needed. Generating an application using libraries is one thing; maintaining those libraries is another, and the latter still requires people.
The second is that, if code remains available under a free license, the possibilities for using, studying, modifying, and redistributing it are preserved. Public code alone does not guarantee those freedoms. That distinction matters. But availability alone does not answer the more practical question: who will have the time and resources to keep looking after that code? Freedom without maintenance eventually becomes a nice-looking file in an abandoned repository.
The third is that there is no single economic model for free software. Some projects are supported by donations, foundations, support contracts, or companies that need them for their own products. Losing direct contact with users can hurt some of those models much more than others. Tailwind is a significant case, but it does not necessarily represent the whole ecosystem.
A hypothesis that holds up in conversation
The interpretation I would defend, making clear that it is my reading of these cases rather than revealed truth, is this: AI is making it easier to consume the work of free software without building a relationship with the people who maintain it.
Tailwind’s account is consistent with the hypothesis that AI intermediation reduces the attention that used to help generate revenue. curl shows how automated tools can increase the volume of reports, including useful ones, that a team needs to evaluate. These are different mechanisms, but both raise the same question: do maintainers’ resources keep pace with the usage and work coming their way?
A more productive editorial question, instead of an “is it over?” designed to drive engagement, would be: how can increased usage and productivity also benefit the maintenance of the infrastructure everyone uses?
A few proposals worth defending, without pretending there is a universal solution:
- Recurring funding for the projects that companies and tools depend on. Not an occasional donation, but a maintenance subscription, a bit like paying the electricity bill for the house you live in.
- Visibility into the dependencies agents use, so the people benefiting know where the parts come from.
- Contributions accompanied by reproduction steps, tests, and an explanation the contributor actually understands. The person sending the report needs to be the first to verify it.
- Recognizing triage, review, and maintenance as work, rather than a free, unlimited resource that someone will always take care of over the weekend.
So, did free software die?
I do not think so. I think it got left holding the bill. AI can make producing and consuming software cheaper, but it does not guarantee that maintenance will share in those savings. In some cases, it can even increase maintainers’ workload. Maintainers can use AI to their advantage too; the balance depends on the context. The problem lies in that gap between the people benefiting from automation and the people who remain responsible for the infrastructure. Someone using free software today may never have read its documentation, opened an issue, or learned the name of the person looking after it. That is no crime, but it is a sign that the relationship has become lopsided.
The good news is that none of this is inevitable. Tools do not decide on their own who gets what. That depends on licenses, funding, users’ habits, and decisions by companies that now ride over other people’s work without even noticing. If we want free software to keep existing as a community, rather than merely as available files, we need to treat maintenance with the same enthusiasm we bring to code generation.
So the next time you ask an AI for a finished application and it delivers everything working in thirty seconds, pause before saying thank you. Ask which libraries it was built with and who is looking after them. The answer may not change your day, but it might change the future of the project that saved your afternoon.