Open source has always been bottlenecked by attention, not effort. Time, judgment, and context are the scarcest resources and no wave of automation has changed that. You can now generate patches, issues, even design docs at scale, but you still can't replace the human who decides what matters, what gets merged, or where a project should go. That layer is the last to fall: not the writing, but the deciding.
What's changed is the other side of the equation. Contributors no longer arrive empty-handed. They come equipped with effectively “infinite” compute—models, agents, pipelines that can produce orders of magnitude more output than before. The question now isn't how much can be done, but where that effort is directed.
The incentives shaping this moment are skewed. Large labs are rewarded, for now, by compute consumption: the more tokens burned, the better. Unstructured generation isn't a bug for them; it's a feature. It drives usage, benchmarks, and growth narratives. But it also creates a kind of digital inflation: more code, more PRs, more suggestions, more noise. Most of it goes unread and unaligned with what projects actually need. Output volume is mistaken for contribution.
Open source was built for a world where human attention and effort were the limiting factors. Mailing lists, issue trackers, code review—the whole stack assumes contribution is expensive and coordination is cheap. That assumption has flipped. The question used to be: how do we get more contributions? Now it's: where do we aim the contributions—and the compute they bring?
Today most of that capacity is dark: agents writing code no one reviews, running experiments no one reproduces. The same work repeated in parallel, results lost, effort duplicated. Compute, unseen and wasted.
Now that code generation is cheap, the answer is everything around the code. The work that was always too tedious, too large-scale, or too thankless for humans alone. Reproductions: turning vague bug reports into deterministic cases. Intent generation: translating scattered ideas into concrete, reviewable proposals. Test expansion: probing edge cases no one has time to enumerate. Experimentation: running variants and benchmarks at previously impractical scale. None of this is really new. What's new is that it can run continuously, in parallel, at scale.
If direction is the bottleneck, the missing layer isn't more compute—it's coordination. The real question is whether we can build the interfaces, incentives, and norms to direct it.
Think of how much GitHub helped proliferate the commons, because it had the right primitives—until it didn't. Can we do the same for agents?