What happens when open source is used more than ever, yet visited less than ever?
In early January 2026, an apparently minor PR intended to improve Tailwind's discoverability for AI systems triggered a widely shared discussion. What initially looked like a technical detail quickly revealed a much deeper tension affecting the open-source ecosystem—and surfaced a paradox that is increasingly hard to ignore.
A Quiet Shift in Value Flows
Around the same time, Tailwind Labs said docs traffic was down about 40 percent from early 2023 despite skyrocketing popularity—mostly due to the popular choice of Tailwind as the default framework by vibe coding agents—and the company laid off most of the team. As it turns out, AI—the very force that has propelled adoption and expanded Tailwind's reach—is at the same time undermining the economic and social dynamics that once sustained the framework's ecosystem.
Beyond the Tailwind case, this dynamic is now increasingly documented (e.g. see "Vibe Coding Kills Open Source," arXiv:2601.15494v1, Jan. 2026), as research evidences how AI-mediated coding tools can increase usage while weakening the engagement and economic feedback loops that open-source projects historically relied on for sustainability.
That gap—more usage, weaker renewal—is the heart of this piece. And it naturally invites a comparison with the industrial extractive paradigm, and the risks it poses to natural ecosystems that are not truly renewable.
Is AI a Systemic Extractor?
As Christophe Tricot framed it, AI operates as an extractive system: it ingests human traces at industrial scale—text, images, code, documentation—and turns them into production input.
The ongoing shift of AI infrastructure from Silicon Valley toward regions like Texas should not be read as a mere cost-optimization story. It is deeply symbolic. Texas is not just cheaper or more energy-abundant; it is historically an extractive territory, shaped by oil, pipelines, and industrial-scale resource exploitation. As AI systems move closer to energy, land, and infrastructure, they begin to resemble heavy industry more than knowledge work. This geographic re-centering signals a broader transformation: AI is no longer only about software and talent—it is about scale, power, and extraction.
Extraction is not inherently bad. But it always raises the same question: what renews what it consumes? As "AI is eating software," open source sits at the center of this shift.
Open Source Is Renewable, Not Self-Renewing
Open source software is often described as renewable because code can be copied endlessly. That is only half true. The scarce resources are not code; they are maintenance, review, security hardening, governance, and the patient work of keeping systems reliable.
Open source is also a sedimented humus of knowledge, not an infinite stock—this is where the oil and coal analogy fits. It was formed slowly, through maintenance, debate, error, and transmission. AI did not create this humus, but it is now actively drilling into it.
Renewable resources collapse when extraction exceeds regeneration. Forests, fisheries, soils, and open source share that vulnerability.
The Loop That AI Breaks
Historically, open source relied on an implicit fair-use social contract that went far beyond licenses. Humans used projects, read docs, opened issues, asked questions, fixed bugs, contributed features, sponsored maintainers, and helped communities thrive. Even when money was not involved, there was a loop—a renewal loop.
AI changes the topology. With vibe coding, the agent becomes the interface. Developers get answers without visiting the docs, without engaging with maintainers, without entering the ecosystem. Usage can go up while engagement goes down, so the sustainability problem becomes inevitable.
The nuance matters: AI does not necessarily break licenses, but it breaks the loop.
Designing Renewal Mechanisms
We should not turn this into a nostalgic defense of a past that will not come back. We need paths forward, not to slow down AI, but to make its relationship with the commons sustainable.
How to rebuild the loop? Are recontribution mechanisms by models feasible? If we extract open source at machine scale, we must re-contribute at machine scale.
Several early signals already suggest how such renewal mechanisms could take shape—some emerging directly within the software ecosystem, others borrowed from adjacent domains that have faced similar extractive dynamics before.
Compute or agent "tithe." Organizations running agents at scale would dedicate a fixed percentage of budget, tokens, compute, or agent time to open-source work: bug fixes, security hardening, tests and CI, documentation, and debt reduction. This is credible precisely because compute plus orchestration already produces substantial artifacts. Anthropic recently demonstrated this by orchestrating sixteen Claude instances to build a functional C compiler in a largely autonomous manner.
Accountability and pay-per-maintain. Machine-scale consumption should be measurable and governable. The web is exploring pay-per-crawl, not as a tax on openness, but as a way to prevent invisible free-riding at scale. In software, that becomes pay-per-maintain: when agents consume docs, issues, repos, or dependencies at scale, they trigger automatic contributions to maintainer funds or sponsorship pools.
Renewal credits. Closer in spirit to carbon credits than speculation. The goal is not to commoditize open source. It is to internalize an externality: if you extract at scale, you help fund regeneration at scale. In practice, they could be allocated to foundations, maintainer collectives, or security funds, turning scale of use into scale of care.
Machine-readable stewardship. If agents can negotiate access at scale, they can also negotiate attribution and compensation at scale. RSL-style licensing terms point to a future where rules are machine-readable and enforceable without PDF legalism.
AI That Gives Back
If orchestration plus compute can produce meaningful software artifacts, then part of that capacity should be dedicated to maintaining the commons. Not as charity, but as a default design choice: a fraction of agent budgets devoted to upstream bug fixes, tests, documentation, and security improvements in the dependencies that made the work possible in the first place.
The signals are not all aligned yet, but they are meaningful. AI clearly boosts code productivity, while also putting new strain on the underlying ecosystem: first, through a progressive exhaustion of our software "natural resources" as the economic models that once sustained them begin to erode. Secondly, if re-contribution is not framed with clear standards, shared responsibility, and protection against overload—as AI-generated contributions multiply, early signs point to risks around quality and governance when contributions bypass human discussion.
None of these ideas are perfect. But they share one feeling: if open source scaled and brought so much, by relying on a human social contract, we now need renewal mechanisms that remain valid in a world of machines.
