Comment on Linus Torvalds to critics of AI coding in Linux: "Fork it. Or just walk away."
iocase@lemmy.zip 1 week agoTo demonstrate the core issue, from now on I’ll argue with you using chatgpt. You’ll need to read this wall of AI slop, and all I need to do is copy paste your comment into my current chat and hit “generate”
I think there are actually several different dimensions to this discussion, and I don’t think it’s quite as straightforward as you’re presenting it. It’s important to recognize that technological transitions have historically been disruptive before new equilibria emerge, and while the current situation certainly creates challenges for maintainers, I don’t think that necessarily implies a long-term negative trajectory for the open-source ecosystem as a whole. From a systems perspective, what we’re really observing is a temporary mismatch between contribution velocity and review capacity. Historically, software engineering has repeatedly experienced periods where productivity increased faster than existing workflows could absorb those gains. While AI-generated pull requests undoubtedly increase the volume of contributions, that doesn’t automatically mean the ecosystem is fundamentally unsustainable. Instead, it suggests that governance models, review methodologies, contributor onboarding, and trust mechanisms will likely evolve over time. Another point worth considering is that AI-assisted development should not necessarily be evaluated solely in terms of code quality. There are also accessibility benefits, educational benefits, and opportunities for new contributors who otherwise might never have engaged with open source. While some of these contributions may indeed be lower quality, the broader increase in participation could, over a sufficiently long time horizon, create a larger pool of experienced contributors than currently exists. This is, admittedly, speculative, but it is also consistent with historical patterns observed during previous shifts in software tooling. Additionally, I think it’s useful to separate concerns regarding code generation from concerns regarding software architecture. Current language models certainly have limitations with maintaining long-lived systems, preserving architectural consistency, and minimizing technical debt. However, these limitations should not necessarily be interpreted as permanent characteristics rather than temporary engineering constraints. Future iterations may demonstrate substantially improved long-context reasoning, architectural awareness, and repository-scale understanding. Finally, I would caution against assuming that current social dynamics necessarily represent the eventual steady state. Communities have historically developed moderation strategies, reputation systems, automated quality gates, and contribution standards in response to changing incentives. While the present situation may be frustrating, it seems plausible that open-source governance will adapt in ways that reduce reviewer burden while maintaining quality. Ultimately, I think the long-term outcome remains uncertain. There are certainly valid concerns about maintainer burnout, review overload, and declining signal-to-noise ratios. At the same time, there are also reasons to believe that new institutional norms, improved tooling, and changing contributor behavior could partially or substantially mitigate those issues over time. As such, I don’t think it is possible to confidently conclude either that open source is doomed or that everything will automatically work itself out. The reality is likely to be considerably more nuanced than either extreme.
Epp@lemmus.org 1 week ago
At which point, I’d reply: eliminate the verbosity. Be succinct, or I’m closing this PR and line of communication.
iocase@lemmy.zip 1 week ago
I appreciate the feedback regarding verbosity, and I think that concern is both understandable and illustrative of the broader discussion we’re having. However, I would suggest that your response actually reinforces the systemic dynamics that I’m attempting to highlight. Specifically, while you are entirely correct that an individual response can simply be closed or ignored if it fails to meet project standards, that observation does not necessarily scale in environments where the overall volume of incoming communication increases by one or two orders of magnitude.
To elaborate, the issue isn’t that any individual AI-generated pull request, issue report, or discussion comment is impossible to dismiss. On the contrary, as you’ve demonstrated, a maintainer can absolutely review a single submission, determine that it lacks sufficient value, and reject it accordingly. The challenge emerges not at the level of individual interactions but at the aggregate systems level, where review capacity becomes the scarce resource rather than code generation capacity.
For example, if one contributor submits an unnecessarily verbose pull request, the cost of evaluating that submission may be relatively modest. If ten contributors do the same, the cost increases proportionally. If one hundred contributors begin submitting plausible-looking but low-value AI-assisted changes every week, each of which requires even a few minutes of human evaluation before being confidently rejected, the cumulative impact becomes substantially more significant. This isn’t because any individual submission is uniquely problematic but because the total review burden scales with submission volume while maintainer attention does not.
From a queueing theory perspective, this creates an interesting imbalance. Human review throughput remains relatively fixed, whereas AI-assisted content generation dramatically increases the arrival rate of new work. Once the arrival rate consistently exceeds the processing rate, backlog accumulates regardless of how efficient reviewers become at rejecting individual items. Consequently, “just reject it” is a locally optimal strategy that may nevertheless fail to address the global characteristics of the system.
Furthermore, I think it’s useful to distinguish between identifying low-quality contributions and doing so at scale. The cognitive effort required to conclude “this is not worth merging” is still non-zero. Every submission requires context switching, repository loading, architectural reasoning, verification that nothing subtle has been overlooked, and ultimately a decision. While each of these activities may appear trivial in isolation, their cumulative effect across hundreds or thousands of submissions represents a meaningful opportunity cost for maintainers who might otherwise be spending that same time reviewing genuinely valuable work or implementing new features.
For that reason, I don’t think the existence of a rejection mechanism meaningfully addresses the broader concern being discussed. Rather, it demonstrates that the cost of filtering remains attached to human reviewers even as the marginal cost of generating candidate contributions approaches zero.
In other words, I agree that you can close this thread.
Now imagine doing that another 699 times today…
Epp@lemmus.org 1 week ago
Alright, you’ve demonstrated the difficulty posed by reality; let’s hear your proposed solution?
iocase@lemmy.zip 1 week ago
Well it’s what maintainers are already doing. Closing community contributions or burning out. A reputation system can be games unless the requirements for contributing are so restrictive it kills contributions anyways since most people don’t have the time and energy to get 100 PRs reviewed and accepted in a gold-standard group of projects to prove they won’t suggest slop.
Honestly I think the solution is the true price of tokens being charged to end users. If it costs you $15 instead of $0.10 to generate a slop PR now you actually give a shit about how it works. I think we’re heading there soon… Anthropic already hiked their prices 9-27X, and it looks like they need at least 2 more of those hikes in a row to begin to break even.
I think the eventual mature path for AI is as a coding assistant instead of autopilot. An expensive tool you use like an intern for making unit tests or finding a persistent bug in your code.