It could be that the engineers who are extremely productive with LLMs are landing PRs that look indistinguishable from good, hand-written PRs.

It seems likely that the gains from generating tons of code are being offset by the debt incurred to understanding what you're doing. We see lots of greenfield projects one-shotted with GPT or GLM or whatnot, but very little on the side of projects with long-term maintenance goals. This is telling, to me, that the _effective_ gains are much lower than perceived (it's lots of fun to see the thing crank out code at breakneck pace, probably contributing to this). Still quite nice, and very useful, but not a totally new paradigm.

My guess is that open source folks overindex on being anti-AI.

Eg if you check out Godot, initially they were cool with LLM code, and then had to clamp down on it because it was not leading to anything good

For instance, we had one person submit a merge request to convert the entire GIMP codebase into Python, and it was just tons of files with stubcode implementations. Another person submitted a fix for our OpenEXR plug-in to load YCbCr images, and when I reviewed it, they'd "imported" a non-existent version of the library that had an imaginary "OpenYCbCrOpenEXR ()" function. :)

Wherever these “10000x” engineering gains are… I’m wondering why they’re only for shit nobody sees or touches.

Where are all the killer new things? All we see are glorified hobby projects (guilty as charged) and an unimpressive pace of equally unimpressive feature additions to all the same old stuff.

Businesses with resources out there should tackling huge things we all want, that they never could have undertaken. But I’m not seeing it. Everything is just… more or less the same. And this tooling didn’t arrive last Wednesday.

Or did we get magical AI at a time when we’re also completely out of ideas? That seems unlikely.

This shit just isn’t adding up. We’re not seeing anything that isn’t more “here’s some more ai tools and services… they’re basically the same as the ones you saw last month.”

What for? Someone show me.

I agree they are over-hyped. Maybe the problem is that all the things LLMs are great for are essentially quality of life improvements. There are a dozen killer apps worth of functionality I get out of LLMs - near instant proofreader, one-shot code bugfixer, excellent cursory research tool, bibtext generator, etc. All of these things extend what I can do a bit but none of them instantly result in me being able to generate category killing apps. They still make stupid mistakes, they don't reduce my workload, but they reduce cognitive load on mundane tasks.

Instead, software is plodding along exactly the same as it did prior to LLM code generation, and there's no evidence of superprogrammers making superprojects in 1/10th of the time. With a 10x productivity gain, what used to take a year should take a month

But that doesn’t mean they stick.

And the core issue isn’t AI, it’s that… a successful, highly adopted project requires time for people to know it exists, adopt it, and also time by the maintainer growing community and ensuring reliability. The people factor is more important. I see tons of new projects, but I’m not going to pick a brand new project that has high odds of being abandoned. I’m going to pick the one that consistently maintains it and has some adoption already.

I have seen engineers create very successful internal projects fairly quickly. And yes, a project that would have taken a year taking a month. And offering a lot of extra bells and whistles that you just wouldn’t have time for.

But these are greenfield internal projects, and the bar is much, much lower for those.

I have seen multiple internal incidents root-caused by an agent faster than the humans responding. Just because it can go up and down rabbit holes a lot faster.

The problem is that AI solves one bottleneck, but not others. One team member produces a huge amount of new PRs. (Like 12 solid enhancements and big fixes in a couple hours.) Now I have less time because I’m reviewing that. And we’re all context switching a lot more.

On top of that, I find AI workflows continue to be deeply immature, even though certain models are very effective and very good at troubleshooting.

The story around testing is not really improving for example. AI can write tests, but are they good? I don’t think we have much actually ensuring product quality and reliability automatically. Unit tests are not enough.

Collaboration is very poor too. Coworkers agent creates PR, and now I’m reviewing it, and now he sends my comments back to his agents… really clunky workflow especially since I’m ACTUALLY just prompting his agent.

Plus, certain models (Opus) are getting much worse at writing. I will not use Opus any more because the writing style is so horrible.

The constant change means approaches that worked well a couple months ago don’t work well today. And there are no real experts, because no one’s been doing this for long. And half the posts and learning out there are outdated, or straight up blogspam.

This makes it hard for people to learn and get better, despite the fact that models like Sol 5.6 are effective troubleshooters, and write decent code.

LLMs are superhuman at short term coding such as debugging and writing tests though and you're missing out by not using them there.

Commercial and industrial electricians are LLMs now?

Perhaps the biggest issue hasn't been the speed of development all along but people working on wrong things, hence why progress isn't as evident. LLM helping to build something that isn't needed faster isn't going to productivity more visible.

I wrote a game I left in a folder from 11 years ago in 2 months, front and back plus all the tooling, plus features I never would have attempted before. I recreated open-sourced projects from github, written in a language I wasn't familiar with, so I could better work with the application and include it in my backend codebase.

I rewrote my mail server in less than 2 days, which took me over 2 weeks to configure and setup the last time.

My life is easier, because the demands are the same but I have more free time. I research more, I learn more, and I try more things. Just like any software project, some are abandoned (even with LLMs) when running into unforeseen issues or mismatches with theoretical plans. Most importantly, I can make things that I think are exciting, with very little effort. The first 35 years of development, I struggled to be good enough to tackle sourcing various projects without becoming frustrated and mostly knowing myself well enough to avoid trying at all.

Now I can see myself writing passion projects until I'm dead.

So 0<whatever<1

Weeks for each feature in a greenfield project... Yeah, LLMs make unworking code way faster than that.

According to this list of top Github repos by stars[1], of the top 10, nine of them are informational and one is OpenClaw, which certainly has plenty of AI generated code.

The next 10 include react which has a CLAUDE.md and a .claude, and lots of landed PRs that look like AI. And linux, which, we all read Linus' stance. He sees the value. And superpowers, ECC, and hermes-agent. All of which are AI stuff.

I think it would be reasonable to ask which major open source projects aren't using AI assistance?

> Major open source projects are by and large starting to ban LLMs now, because the contributions made by LLM users have been universally terrible and unhelpful.

That is not why. Or at least not the majority of it. The biggest part is that maintainers just can't keep up. They don't have time to do in depth reviews for the number of PRs coming in to find out if it: works, does what it says it does, meets a need, has docs, is well written, meets criteria, etc. That does not mean all those PRs are trash. Some might be trash, some might be gold. Just like human generated ones.

What it comes down to is vibes. Anti-AI folk don't like AI for reasons (that are valid) and they don't want to find any value in it. So they don't. But lots of people are. Lots of really cool, interesting, clever, new software is being written and getting used and building communities but people see CLAUDE.md and go "slop, no thanks" and won't even give it a try.

[1]: https://github.com/EvanLi/Github-Ranking/blob/master/Top100/...

Where are all the vast quantity of LLM commits for these open source projects, if these engineers are truly 10xing their productivity with LLM code generation? Because I regularly browse the source of many of these, and can find almost no evidence that LLM code generation is anywhere near the level of productivity being claimed for:

1. ImGui

2. SFML

3. SDL

4. GLFW

5. OpenSSL

6. Linux

7. GCC

8. Clang/LLVM

9. Libc++/libstdc++/msstl

10. Rust

11. Godot

12. Nlohmann

13. Boost

14. Python

15. GNU tools

Etc etc. There are even more major projects, but these are just the critical ones I can think of off the top of my head. If you go for a browse though eg Godot, you might think that LLMs don't exist. In fact if you go for a browse through any of these, you might think that LLMs are borderline never used for code generation in the open source world. This is a diverse collection of random projects, and yet for some reason none of these have experienced a 10x increase in productivity in any form from any contributors from LLM code generation

>That is not why. Or at least not the majority of it

Its not the quantity, if maintainers were receiving incredibly high quality PRs that could just be merged, they'd be very happy. Godot is an example of a project that was initially pro LLM, and then had to about face because the PRs were just absolutely crap

>Some might be trash, some might be gold

Is there any evidence that any of these PRs have ever been gold?

There are two incentives for contributing to open source. The first is to make the app better (add a feature, improve the code, fix a bug, etc.) It's possible that LLMs don't meet the bar but if a human has put the effort in it's not always obvious that it's AI. More likely LLM code is accepted when it's good and rejected when it's bad. The system works.

However, the second incentive is that open source contributions are seen as a 'ahortcut' to making a name for yourself. Being a contributor on a big project goes on resumes and GitHub profiles. Often people who use AI for that don't review the code or even check it does what they say it does. That slop needs to be banned. The downside is losing the good contributions, but it's still a net win.

It's not just productivity, it's life changing.

AI lowers the bar to making submissions which permits flawed subissions to be thoughtlessly submitted by people who don't really understand what they are doing, technically or culturally.

It does, however, enable people who put in the effort to work on something significant. Those people are fewer in number, but exist. They do get to see the animosity that unwitting novices receive.

I don't think it would be surprising for those people to opt out of engaging with a toxic environment.

Or, failing that, you'd think any of these engineers - given the truly vast amount of programming power now available at their fingertips with their 10x productivity - would have simply replaced these projects. It'd only take a few 10xers who wanted to show that everyone else was wrong. That's how open source often works, someone just gets a been in their bonnet and then we get linux

Instead: I can't find any of it. There's no evidence of this productivity boost in the wild. There aren't new high quality 10x open source projects springing up that are replacing everything. There aren't high quality LLM contributions, feature development isn't going faster. There's almost no evidence of high quality AI code generation at all in the open source space, existing projects or otherwise

Where's all the code? I want the receipts if people are claiming a 10x productivity. Because at the moment, the much more likely explanation seems to be that its simply not true

For any instances where people have made things and revealed them to the world have been declared to have been grossly flawed by being held to a standard of scrutiny that no person usually gets.

It seems everyone is Cardinal Richelieu now.

You might have something there.

It probably holds true for a lot of things. Either that or most gutairs sold are defective.

What's the point of writing great software if nobody else is going to use it, and how do we even confirm there are these alleged secret geniuses hiding away somewhere? Surely their work would leak out by some nth-order effect.

I made a claim that absence of evidence is not evidence of absence.

That is not a claim of existence.

  Assisted-by: Codex:gpt-5.5
  Assisted-by: Claude:claude-opus-4.8

  repo:torvalds/linux assisted-by (claude OR codex)

... but if you clone the git repo you can get an exact count of 824 commits (not sure why the search over-counted).

Here's a good candidate for a material performance improvement:

https://github.com/torvalds/linux/commit/e1bf79628453e6afac8...

  Single-stream throughput (MB/s):
                        Before    After    Change
  seq-write/dontcache      298      897    +201%
  rand-write/dontcache     131      236     +80%

Because if it was true then open source projects such as GIMP could basically be as feature heavy as Photoshop overnight.

LLMs amplify existing expertise. Give them to experts and you can get fantastic results. Give them to amateurs and you might get the occasional impressive demo, but you're not going to get anything that a responsible software team would commit to maintaining in the long term.

I suspect the ban of AI in established projects to be a very complex decision. Even if core developers would like to use AI, they don't want to review all of the AI-generated code from the larger community. So the only consistent way to preserve sanity is to declare that nobody would use it. Good luck enforcing it though!

Nothing's stopping core developers from adopting LLM generated code for themselves, while banning it for external contributors

And if they're doing that, why would they tell you, or anyone?

And if they're doing that responsibly - collaborating with AI, and reviewing the code - they don't even have an ethical reason to tell about AI involvement, any more than telling about the StackOverflow answers or blog posts they read before coming up with some implementation.

Then all it'd take is one of these engineers blowing the lid on their whole secret LLM contribution strategy to absolutely break the industry wide open to the benefits of these massive productivity increases, and finally prove all the doubters wrong. They sure are good at keeping secrets that would directly benefit them to expose

Selection bias? OSS has a thing proprietary projects don't - an endless cohort of opportunists trying to wedge in a "contribution" for personal gain, be it a Hacktober t-shirt or resume boost or an occasional vulnerability (with the resume boosting being by far most likely). The good LLM-based contributions, you probably won't recognize as AI-assisted unless the author explicitly decided to label them, and if they're really good and use LLMs responsibly, they probably don't even have any ethical obligation to label LLM involvement, much less any benefit.

OSS involvement in general stopped being an indicator of skill once Github activity became a factor for job applications.

Edit:

There's also a second factor: many people (myself included) use LLMs to code one-off personal tools with no intent of them having more than one user, ever. Get an itch, have an LLM scratch it for you, carry on with your life. You'll see little trace of it, because it's hard to distinguish a single-user program that's good enough for specific purpose from a pile of autogenerated slop that probably doesn't work, and neither of these will show up as PRs to big OSS repos anyway.

Instead, if you check out something like ImGui, we can see that its largely just Omar as usual with a bunch of PRs. Nothing much seems to have changed, feature development carries on at the same pace as it did previously. This is replicated across nearly every single major long term open source project I can find

The only reason developers now feel the need to hide their LLM usage is because the LLM contributions have all been shockingly bad, so you're reversing cause and effect. If LLM contributions had been incredible, they wouldn't be frowned upon socially now. Surely someone would blow the lid on this huge covert conspiracy about how incredible their contributions to.. SFML have been?

This effect also wouldn't prevent LLMgineers from creating their own open source projects that should be absolutely outstripping the existing open source space. After all how old is ImGui? With a 10x productivity gain, it should take a year of development to easily match its features if those gains are truly real now

>if they're really good and use LLMs responsibly, they probably don't even have any ethical obligation to label LLM involvement

The copyright issues means that non disclosure is inherently unethical

You're dismissing scale of things. OSS communities were having high-profile discussions about gatekeeping and discrimination way before LLMs were a thing, because already at that point the amount of human generated slop was becoming untenable. And yet, no one argued that this must be evidence that all human contributions are bad and humanity is a bubble waiting to pop.

> ImGui

Weird choice of an example. ImGui is common infrastructure. Who in their right mind would want to mess with that? Especially when building something to solve some end-user problem (whether N=1 or N=1 billion), ImGui is a component you include, not one you rewrite.

There's hardly any reason anyone has to contribute to that project, with or without LLMs.

Bun did a nearly 100% hands off keyboard rewrite. And people largely ridiculed the effort with mud slinging and goal post moving.

There are plenty of measurable examples of the productivity boost when there is a well defined oracle, such as rewrites and (kind of)formally verified specifications.

I've got an agent harness that I built that decompiles games. Don't want to dox myself on this account, so this is all I'll say about it.

I may have been able to decompile 1 game a year into readable source. Now I can offload nearly all of that process to an Nvidia 5090 and the extremely cheap deepseek v4 flash.

With dedicated focus and a lot of personal time, or employer time, I may have been able to reconstruct a good amount of react linting rules to biome. But instead, by focusing on a harness that can prove parity, I can get all of the rules ported while I sleep or solve other institutional problems.

Once you can prove the outcome, however hard or soft you need based on the domain, the output gains are literally undeniable.

Imo the vaporware is all of these "one-shot" projects that people love to show off. Once the market corrects and the hypecycle dies down theres going to be a lot of interesting engineering in this space. Right now there's a bit of a Cambrian explosion of ideas, and for better or worst that space fills up with the over the enthusiastic and chareltons.

Fragmented thoughts I'm typing while walking, the point is murky

I'm coming from the perspective of infra management so that's my bias, and a very complex code base may make my perspective off mark.

But nowhere does it seem it to be a good idea for the whole thing to be LLM generated. It seems to view a big holistic problem in steps in isolation, causing it to add complexity on top of complexity as it's going through it's later stages. For example it'll create infrastructure designs that add layers of unnecessary and redundant tooling and business logic, when a human would have re evaluated step 1's path when it realized step 3 was doing the same thing again in a more complex way.