There is an implicit social contract with writing that the writer has put more effort into writing than the reader will need to read something. Sure you get crackpots still, but there are only so many Gene Rays in this world, so the volume is limited.

I think the same applies to PRs. Pre-AI , it was usually obvious when a PR was either completely terrible or very half-baked, and the required effort to create even a shitty PR was usually more than that required to reject it.

AI makes it trivial to make a completely terrible PR, and much easier to make a not-immediately-obviously-bad PR.

As a maintainer of a few FLOSS projects, this tracks.

The Pavlovian PR notification response has gone from, "Oh! What do we have here?" to "Groan. Do we have _anything_ here?"

I won't get specific but I just had to remove a contributor from a project after multiple submissions of either cutesy, fluffy bullshit (add ASCI animations!) or "rewrite entire project in other language". Not only did the PRs result in wasted time and energy but they also resulted in conversations about how to deal with this sort of spam. (Probably good to get out of the way and set policy but still...) So, this person probably spent fifteen minutes prompting together these stupid PRs and multiple maintainers had to spend hours agonizing over what to do about them.

We almost need like ... noncanonical software? Not so much forks, but like ... Maybe software as like a cluster? an ecosystem? On-demand app store where features / forks are shared/upvoted/evolved by the community where the maintainers don't have to get burnt out, and when it inevitably becomes a ball of mud oh well it does the job? I really don't know!

I hope we can think about some answers and not get tribal though because this is really a huge problem and also a huge opportunity and so a minor reminder that there is a baby in that bathwater?

I feel bad for people like him who get the brunt of dilettantes who can "code" polluting his time and focus. Reminds me of that mitch hedberg joke: "When someone hands you a flyer, it's like they're saying here you throw this away." but for PRs

I ran a bunch of different compilers on it, including some open source ones.

Some of them failed some tests, and it was natural to have my LLM (Claude Fable 5) root-cause the issues, and to double-check my test bench wasn't to blame.

But now I stood with all these patches that I couldn't just throw at the upstream maintainers all at once. I ended up just filing a few issues and moved on to other things.

It felt weird to just file issues when my LLM had already spent a lot of time root-causing and fixing the issues. But then, maybe they could just have their LLMs do the same.

Still not sure if it was the right call?

I maintain the hope that those technically minded who are really interested in coding and care about doing things properly using their own reasoning on all levels of detail will find each other and maybe become less diluted as a community by the coding-just-for-money crowd than in the past decade or two.

> My initial task when a new unexpected PR arrives is to determine if there is a person behind it or not, and luckily this is easy to figure out in just a few seconds.

OK. How? That would have been an interesting explanation to me.

But another issue is - AI disclosure (agent, model etc). I'm sure others tried similar approaches, but in case this is not common knowledge - I tried to see what happens if you ask agents to disclose themselves in the PR description / comments in a rule file.

It seems to work pretty well as most AI "assisted" PRs will be opened by agents using the gh cli or MCP on behalf of the user. (Of course this can be bypassed, but for someone who doesn't mind disclosing or doesn't care, this is a good step forward)

Example: https://github.com/arnica/depsguard/blob/main/AGENTS.md#ai-d...

(so far worked on PRs from both Claude Code and Codex - both got a footer disclosure of the agent name and model)

This reminds me way back when you would see "Website written in Notepad" on websites.

Review is indeed the main bottleneck now for open source, and we need to solve it. Introducing more friction is hardly helping.

But saying his opinion hasn’t changed on this:

“the main and most important reason why GenAI tools do not work for me is that they do not make me any faster.”

It’s been a year and agents and models have improved dramatically.

I can see for some things it doesn’t make sense, but not using it at all because there’s nothing it can help with?

Devs who don’t use models at all are a dying breed and I think it won’t be long before he’ll be forced to concede the point.

I wouldn’t pretend to have an answer. of course. Opens Source means, always meant, different things to different people.

I know what always counted for me:

1. Copyleft License

2. No CLA or Copyright assignment

3. Diverse group of contributors

I sympathize with Miguels point but it bothers me it clashes with point 3 in my list. If you hand select your contributors[1] you will never reach the diversity necessary to effectively make relicensing impossible. Without that Open Source matters less to me.

[1] I admit that controlled set of known contributors has other advantages too.

Let those agents bankrupt their owners in a loop of neverending improvements and changes.

The worst ones are fully autonomous AI agents looking for open source projects and adding random pull requests.

But in some cases, I find a legit bug that needs fixing. For example, I want to get a particular program working in Wine/FEX on aarch64 [1], or I find a 12 second hang in Darktable [2]. The problem is that, as a software engineer working in a totally different discipline, I have no knowledge of the low level C code to fully understand what the problem even is, or how to fix it. All I want to do is to fix the issue and help other people avoid running into the same issue. Right now, on my machine, I maintain a set of custom patches to get everything working. But I am too dumb and ignorant to figure out how to create the fix by hand, so I can't submit a pull request (or when I do, I feel really bad about it. I honestly feel like a horrible person, e.g. when a project added a "No AI" policy soon after I submitted some AI-generated PRs [3]). Going forward, I feel like this sort of scenario is going to be way more common.

[1] https://github.com/FEX-Emu/FEX/issues/5512

[2] https://github.com/darktable-org/darktable/pull/21069

[3] https://github.com/FEX-Emu/FEX/commit/8c85096f98084ca9438b16...

Probably not, but maybe free software now matters more.

I can understand wanting to minimize your interaction with LLMs, so this might not be an attractive solution. But it seems like a worthwhile feature to have on the platform level for people who would like to continue to accept pull requests without the frustration.

Are there concrete patterns that somebody could write a linter to auto evaluate for this?

a copy of the repo.

I think it does but there are weird dynamics I don’t fully understand. I’m curious about HNs thoughts.

My theories: Centralization around key projects due to AI pointing new users towards them. (At the same time this drives up the PR deluge onto these projects. Especially from newer users already heavily using llms.)

So many low effort AI-generated open source libraries that it becomes harder to tell signal from slop. More movement to the bigger projects because they are perceived as safer bets.

On the plus side it’s easier than ever to patch or fork projects. So at least this toxic gatekeeping behavior matters less than it used to.

On the other hand, there are also people who start coding with AI, and those people will love a large part of code that isn't pretty but works.

Some will say that messy code will ruin software in the long run, while others will think otherwise. This reminds me of Sturgeon's law: 90% of everything is crap. This means that for any type of thing, there are quality items and inferior ones, and quality items make up about 10%. The 10% of code created by AI will be valuable, and only 10% of human-written code was valuable. AI has just increased the amount of crap.

Whenever I think about these issues, I always think of Undertale. Undertale's code is overwhelmingly messy, yet it's a masterpiece often cited as one of the best games. I love it too. But Leaked Undertale code (its quality) is terribl

Ultimately, it seems that AI's usefulness and harmfulness are determined by the purpose for which it is used.

If someone enjoys code quality, long-term perspective, and intellectual exchange and interaction with people from these kinds of discussions, they will be hostile toward AI.

On the other hand, someone like me, who is in a community that has a hostile attitude toward on-time delivery for clients and learning (based on mockery and disregard), will be receptive to AI.

Honestly, I am a direct beneficiary of AI. I'm on the side of consuming the results managed by open-source maintainers, so I can't fully understand their position. I just think, 'That must be incredibly hard for them.'

In my case, AI writes English functions and documentation, and by using AI to refactor English function/variable names that were previously hard to use, I can now write code that's easier to read.

But since my role mainly involves assembling things using IoC on top of frameworks, I see more advantages. The downside is that my coding skill declines, I suppose. I'm a traveling contract programmer who often goes on-site to work with legacy codebases and add features to them.

Actually, my workflow hasn't changed much. It's just that the legacy codebase has become an AI-generated codebase. My workflow of debugging and tracing the flow there hasn't changed, so I'm probably in the beneficiary camp.

Conversely, people like the OP have seen a massive change in the number of PRs they need to handle, so it's understandable. The intellectual exchange with people they've always had, and the values that come from that, have been damaged.

This is a really difficult problem.

I mean, did it ever? It depends what you mean. Very few open source or free software projects are successful in any meaningful sense.

I have a Jira queue. It drives what work I do. I may have some leeway in how I do the work, and what tickets I pull, but Im absolutely at the behest of the ticketing behemoth.

Tickets have been my life since I started helpdesk. And future roles will also be ticketed. And they almost all are customer-facing or system-breakage (which impacts lots of customers).

Im not sure what IT roles im capable of doing wouldnt have tickets. So, yeah. Reverse centaur.. But not an AI driven reverse centaur, yet.