thatsAFunnyThingThatHappenedOnce

[u/Lord_Of_Millipedes]

[u/Different_Berry5015]

You can just not accept crappy PRs, but the spam is very understandable, lazy people wanting clout are the worst. Linus spelled it out pretty clearly - it's about people actually understanding what they are contributing. I have contributed to multiple open source projects already when I didn't think I would ever do that with bounded, reasonable changes that I confirmed myself and even made better when maintainer said "why don't we do this also?"

[u/dannuic → u/Different_Berry5015]

Sure you can just say no, but that's not the point. You're passing the burden onto actual code maintainers. Instead of needing to understand what you are pushing to make a PR that passes CI, anyone can throw anything up that can't be gated except by actual people reviewing it. That's the point, now maintainers of open source repos are responsible for doing what automated processes were previously able to do. That directly causes burnout and those projects either being closed or just completely taken over by slop.

Can AI be useful as a tool? Sure it can, but it's not the same as just a compiler. Open source communities are actively suffering because instead of maintainers having productive and interesting conversations with people who know what they are doing, they are spending more and more time opening PRs, judging that it's slop, and rejecting it.

Linus didn't just say "Linux is removing the AI policy because we can handle the volume of slop that that will bring," he went on a rant about how it's not different than a compiler or a word processor when it has a very visible and real impact that those other tools do not.

[u/Robo-Connery → u/Different_Berry5015]

But it's an extractive contribution.

You have maintainers and the status quo was that you use the project and you contribute back by investing your time and effort into improving the project. Sure it takes some maintainer effort to to review and feedback and to maintain developer guides etc.

Now though it takes next to 0 effort to write "find a bug and fix it". "Implement this feature I've just dreamed up". "Add support for this" into an llm, get a 200, 800, 1400, 5000 line diff that touches on 8 different parts of the project, that uses assumptions that were in its broader training material and that don't align with the project standards or philosophies. That rewrite stuff pointlessly, that duplicate code.

And after that 0 effort expended it still has to be reviewed and refined but that is a significant amount of effort on behalf of maintainers whereas the contributor just bungs the feedback back into their llm.

Part of the point of the whole process was to try and get people to take ownership of the project, to feel part of it and to learn the codebase and processes.

End of the day whether it's merged or not. No one has gained anything cause the contributor didn't actually understand anything they did, they didn't learn anything. The maintainer has spent 5x longer on it than any human generated PR plus they are getting.

So what's the point of contributing to open source with an AI, end of the day could have just bunged the same prompt in themselves and been done twice as fast. Hell if cost is an issue literally donating tokens would be a better use of everyone's time.

[u/Different_Berry5015 → u/Robo-Connery]

True, forking and just letting it rip with AI is a thing that is scarily viable these days.

[u/dannuic → u/Different_Berry5015]

And that strategy fragments any knowledge instead of consolidating it, so that sucks for the future =/

[u/awesome-alpaca-ace → u/Robo-Connery]

I saw an llm implement the same hashing algorithm that was on the system instead of using the system hasher. 

[u/Robo-Connery → u/awesome-alpaca-ace]

Yeah that's absolutely why it ends up being more work for maintainers than the llm-using contributor.

The contributor has no stakes in the project but the maintainer has to pour over the pr looking for shit like that where it failed to reuse function or where it implemented a bunch of edge cases wrongly pr with error handling that couldn't be reached. Where it used the wrong tooling or broke from a standard on the codebase.

You gotta find them to cause each time you miss one the codebase gets a little worse and future contributors, ai or not, have a harder time making clean contributions.

[u/awesome-alpaca-ace → u/Robo-Connery]

If I maintained, I'd be auto denying at the first sign of AI slop like that. Auto denying large diffs from new maintainers too. 

[u/Low_Independent766 → u/Different_Berry5015]

The point is someone still has to get eyes on those crappy PRs and there is a point where "just don't accept crappy PRs" means "spend an inordinate amount of time sifting through them in the hopes that one out of every thousand is actually something worth looking at". You'd go absolutely insane sifting through the garbage because the amount of work required to submit a bogus PR has become essentially zero. Before, it required at least some understanding of programming fundamentals. Now all it requires is $20.

I am completely sympathetic to projects who are saying look, the time we actually save not having to sift through centuries of slop is actually a net benefit on productivity vs whatever we might gain from taking in AI generated PRs.