I could not imagine the pain being being the head of a Libre/Open project nowadays.

It used to suck when there was almost nobody contributing because it felt isolated. Worse was if your project did become popular, you would be managing loads of code AND spending loads of time managing the community than the code.

Nowadays, you probably don't have the community to push back and converse with, just a flood of code with few people you can't actually question it with. So back to isolation but with a million lines of code.

It feels like you would have to have a project with an direct artificial limit to increase the quality of submissions. Like, all submissions must be able to run on a 486 25Mhz and 4MB of RAM, this would keep the code small and manageable. Don't do that, but you get the idea.

There is also the fact that Maintainers simply don't need contributions any more. This I've noticed also happens at work. Everyone is maintaining their own mini stacks of things. Contribution is up cooperation is down. Why go talk to a colleague when you can talk to Claude? Change is everywhere.

I feel this deeply... but as an engineer at a big tech company. Over the past decade, I meticulously learned the code base and frameworks, attained readability of various programming languages, etc. I carefully wrote and reviewed code from engineers that took the time to understand what was there and how to make it better or add to it. Carefully crafting comments for feedback every so carefully to not over critique. Over the past 6 months, I have come to realize that world no longer exists. With scores of seemingly high quality code reviews from folks that don't understand what they are contributing to, it's impossible to keep up. I am also not at a place where I can say, I'm making a smaller trusted circle. Many folks in my circle are simply ramping up the quantity of code they want me to review. I simply have to rely more and more on AI to review the code and help me figure out what exactly it does. At the same time, I am also needing to generate more and more code to keep up with the expectations of those around me. We are now instructing our agents to leave comments, having the agents respond to those comments, even long threads where the agents debate technical decisions either both human author and human reviewer almost totally removed from the loop.

We are all getting more and more removed from the profession of writing code. It's like we abstracted away all of the details of writing code and we are spending our days just sending 100 interns on project quests.

I think some will adapt with the times and others will get burned out. This may be the end of open source as we know it, and maybe altogether...

I think the answer is straightforward. You complain that a substantial PR is no longer evidence of good faith. What is evidence? Participation in the community.

I think mailing lists (or an equivalent) are coming back. In a big way.

We just banned gen-AI PRs, it seems to be working so far.

Commercial dev is about results and money, and that makes AI almost impossible to resist.

OSS has always been about process. The pleasure is in tinkering with code, collaborating with friends on a fun new idea, and helping people. I don't care about speed.

this could be siloed into complaints about github and pr workflows moreso than being related to FOSS. zero mention of mailing lists or patches, lol

There was a time before programming, hacking, open source, and related communities. These things did not exist even 60 years ago. There will be a time after them, and we’ll move on to something else.

The internet is now a token cache, and we reap those tokens into agents, ethics be damned.

It sounds like part of the problem is that AI tools are machine generated content acting like humans in a comment forum designed for humans. GitHub already has a variety of CI tools which generate huge volumes of machine generated text, and that text is appropriately buries for those that want it without spewing all of it in a developer’s discussion forum.

While it is more challenging to stop genuine imposters, we could also add new features to places like GitHub so that maintainers who do run automated tools can make automated analysis available to PR creators without drowning out human discussion threads. It sounds like part of the problem is that new tools have popped up so fast that we haven’t figured out how to integrate them properly yet.

It's sad when a technology so thoroughly changes what you love. It's life as a human I guess. I hope people like this can still find a way to enjoy themselves, differently. Usually humans do, given time.

Learned from this thread that I can disable PRs from external contributions.

Enabled this feature.

Earlier in the days, PR was better than issue, now, I prefer and issue, as Codex with my guidance can create a much better PR.

> I don't know what the fix is

You said it was dead. How could there be any fix?

Better workflow may require contributors to establish the problem and receive agreement before producing large patches, regaardless of whether AI is involved.

Part of me is wondering, maybe it’s time for part of open source to move from code to just words or prose? Since it’s possible to use AI to fix bugs and add features arguably more easily than before, what we could share with each other are ideas, thoughts, additions to each other’s prompts or skills that could be reviewed by the community.

And in this case carefully crafted, clear, and expressive words that are not too verbose would be the contributions of tomorrow.

I keep going back to LLM Wiki. It has found itself in so many other skills because of its fundamental value. Maybe we don’t have as many pull requests. But that one skill has proliferated in so many other skills because of its value.

I dunno. I've been making free software for 3 decades and I still think it's fun. While I do get slop PRs sometimes, it's not frequent. And when I want to land a patch in someone else's project, I haven't really been having difficulty doing so.

The main change for me has been... if I want to send someone a patch, it's more important now to talk to them about it first. But I was doing that anyway. Join the chatroom, let people know I found an issue and am working on fixing it, maybe get their advice on how they think it should be solved (to make sure it fits with their project and goals), and then send code. And stick around to help with testing and stuff. It's not much different than how things were before everything moved to GitHub.

Talk to people. Be a part of the community. That's what made free software work in the past, and it's what makes free software work now. As the article said, it was never just the code.

Yeah, the people aspect is dead or dying. I was having fun over the past few months, putting some AI assisted things I'd always wanted into the world.

Nobody cares anymore, because literally everyone on the planet can literally make their own mini stacks of things, as another commenter just said.

It's sad, but I don't see any way to put the bunny back in the box.

Close those PRs. No hesitation. No remorse.

My project exists for the concrete purpose of helping the community get things done, not for the abstract goal of making good software. (It actually isn't very good software, to be honest.)

If you're a real human being who needs help fixing a bug or implementing a feature, I will gladly take the time to help you. But if you're a bot that is just trying to tidy up my software in accordance with some ideal design pattern, unrelated to the specific needs of any human being, then you can just go help yourself.

Open source projects have had gatekeeping mechanisms for decades. Remember ESR's popular (albeit exaggerated) posts about how to fit in with hacker culture? It's the same thing. There's nothing wrong with it. New contributors must prove that they know how to be a good member of any community they're trying to enter. There's no abstract ideal of openness-to-all that we must somehow all strive for. Follow the needs of the actual community that you care about. Don't feel sorry for spammers, especially non-human spammers.

I'm customarily adding a "LLM disclosure: no LLM was used while drafting this issue text" to issues now (when that is true), to at least give some explicit signal that two humans are talking. Of course the text you write yourself is often distinct from slop grenades, but emphasizing that can't hurt.

And of course, you can write that and still paste completely slop, but nobody seems to be doing that yet, and if they would it's probably not convincing.

I personally find it better than ever, even with the current issues outlined in the post. We'll work through them, the linux kernel team has, the rest of us can too. But never has been easier to work on or hack up unfamiliar projects to learn from, build on, and extend. Many projects have more refined features with fewer bugs. It's not all bad stuff happening.

One has to hope that this is mostly just the "uncanny valley" of AI as it climbs up the ladder of general intelligence.

At some point I think AI technology available to us will be advanced enough that "slop" is largely a thing of the past. Some of the issues here will still remain, but hopefully at that point a PR review could be largely automated, in a trustworthy way.

> It was the people. It was fixing a typo in a README and having someone say thanks. It was a stranger on the other side of the world finding a bug in my code and sending a fix before I'd even woken up.

All of this still happens in a world where people aren’t typing the individual code lines by hand.

You just have to adjust and move on. Don’t let your code quality decrease, fight off those that submit vibe coded bullshit and push forward. You’ll find there’s people still behind the prompts.

It’s not totally equivalent but there was a time where all programmers wrote assembly or the like. They’d look at JavaScript with disdain if they saw it in their day. Yet people kinda just.. moved on.

open source as the name suggests has never been unambiguously about open contribution. It's the code that's open, not the automatically the community that builds it. SQLite is sometimes brought up for its idiosyncratic developer code of conduct. Openness especially of very popular software with high reliability requirements has usually been on the user side.

I'm not too surprised by the recent problems but I see them as intensifications, not a new problem. As development platforms became larger, low quality contributors and people who wanted something on their CV became more and more common. That there's never been any kind of trust system makes these issues inevitable.