Hacker News Reader

@antirez is a very prominent open source contributor that gets lot of shit done with LLMs. Mitchel Hashimoto is also open about using LLMs to speed up his work. There are some caveats attached: neither of them is doing crazy loops or graphs producing thousands of lines of code, they are both amazing software engineers and they know what they are doing.

Yes. Feels like the better you are at your craft the better the tools work.

AI is a power tool/factory with no safety features. Expertise is required to get anything useful from them.

Yep, much like having access to a circular saw won't make me a carpenter, having access to an LLM won't make the average person a software engineer.

you're moving the goal post as language models and agents aren't marketed as something like circular saw but a team of carpenters that you just tell what you want and they do it for you.

I never claimed to agree with the marketing.

> Why do only the poor quality LLM code generation users make PRs to open source projects, and never the engineers that know how to really use it correctly?

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

If so, where are all the new features in the open-source projects I use? Why hasn't GIMP replicated Photoshop? Why hasn't CUDA been fully reverse-engineered as an open source toolchain? These are unreasonable expectations, but only in response to unreasonable claims of productivity. What before took ten years should now only take one, right?

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.

> Why hasn't GIMP replicated Photoshop?

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

They don't though, very few people were anti AI in the early days. Open source projects were largely initially very interested in LLM usage, and generally had a pro AI contribution policy. This changed when it did not help their lives

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

Scaling AI use in highly-collaborative environments, which open source projects are, is very challenging. I totally understand the apprehensiveness around it.

How is it challenging for open source projects? You just write a PR, and try to get it to meet the maintainer's quality bar. That's exactly how all code is written in any environment - you do code review and refine a PR until its good enough to be merged

With AI and how a lot of people use it, the quantity of written PRs goes up, but the quality goes down, and the maintainers of the project, who are often volunteers, now have to deal with this in addition to the standard work they've been doing before.

This doesn't seem to match the claims of 10x productivity that are being levied though. In fact it seems like the overall productivity is lower

Just my experience, but the relatively few fully AI-generated merge requests we've received that were "big features" were all really bad.

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. :)

Yeah, why hasn't AMD added every single CUDA feature lol

Why are Amazon and Walmarts mobile apps still janky crap that costs them money? Why does Meta still have four redundant, broken sign-up flows before you can give them money to advertise?

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

Those websites are janky despite having all the (non AI) solutions available already. They suck for reasons independent of the quality of LLMs. I have not worked inside a megacorp but my understanding is they suck because of what are essentially political roadblocks within the organisation.

Ok, let’s assume that’s the case and we’d never see those improve under any circumstances.

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.

>Where are all the killer new things?

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.

If that were true, we'd expect to see massively accelerated velocity of open source projects by these engineers. They should be creating new open source projects at a truly astounding rate, with new tooling springing up every day that dwarfs the existing open source space as their productivity completely eclipses traditional development

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

I think what you're missing is that there are new open source projects being created at a very fast rate.

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.

Github's Octoverse report kind of gives you that evidence, no? Pull requests landed in 2025 were up 30% over 2024. This year it's going to be much higher.

That's the point. Huge increases in pull requests. Virtually no increase in features or reliability.

LLM code is obvious to spot. If an LLM designed a screwdriver set it would make a screwdriver for each head instead of making a replaceable head.

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

> LLM code is obvious to spot. If an LLM designed a screwdriver set it would make a screwdriver for each head instead of making a replaceable head.

Commercial and industrial electricians are LLMs now?

So... basically an autocomplete to help you type faster and spot check if you did something unusual in the parts you wrote by hand?

I'm coming to the conclusion that the right way to use LLMs for code generation is asking it to solve specific problems, giving it existing code and asking it how it would propose changing something or other, or if it has an alternative to an existing logic flow that's problematic and asking it what it thinks the problem is and how it would suggest it be written.

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.

> I strongly suspect that what we're seeing is that much of the tech code-writing economy had already become completely performative prior to AI turning up. It no longer matters in the current age if your code is good, or works, because your job is to give the illusion of product development while the stock market price gets pumped, until you all cash out your share value, get bought, or hop jobs in 2 years.

I think this is probably the answer. Working as a professional software engineer actually has very little to do with writing good code and maybe never has. The job is to “ship products”, and as long as you keep up a sufficiently convincing illusion of progress toward that end the bills get paid and nobody really cares about the impact on end users.

Nah this take is wrong. I used Claude code with my custom skill and I wrote a more performant scheduler than the default Linux one in Rust.

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

Sure, it just seems a little odd that no LLMgineer ever contributes their incredible more performant scheduler back though right? After all if you can do it with claude, anyone can, all it'd take is to ask claude to rewrite it. Linux accepts LLM generated PRs, all the code has to do is meet the review bar and one of the most critical pieces of software engineering on the planet gets better for everyone

Why does it seem odd when people who do attempt to contribute back are attacked?

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.

You'd think one 10x engineer or one core developer already part of the project would have completely eclipsed all the other engineers, and worked around the difficulties there

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

I can't point you at any because I don't want to send a mob their way.

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.

People are attacked for low quality. There are counter examples but it is definitely striking how infrequently you see a PR which doesn’t stand out for being turgid or flawed, and whose author clearly expects a cookie for their “contribution” of a couple minutes of prompting.

Are you alleging that there are far more things that takes no effort than things that takes quite a lot of effort,

You might have something there.

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

Non-falsifiable statements aren't going to work here anymore.

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.

What statement did I make that was unfalsifiable?

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

That is not a claim of existence.

If you want to see contributions to Linus that used AI you can search for commits with tags that look like this in their commit message:

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

This search on GitHub seems to find about 2,000 of those:

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

https://github.com/search?q=repo%3Atorvalds%2Flinux+assisted...

... 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%

I would submit it but the pr was too long to fit on GitHub

… doesn’t Linux work through email, not GitHub?

It's a reference to Fermat's note.

Here are a few examples you might find credible:

- pola-rs/polars: https://github.com/pola-rs/polars/pull/26823 - ~2.68x median speedup of primitive-to-boolean casting credited to Claude Opus 4.6

- pydantic/monty: https://github.com/pydantic/monty/pull/643 - ~53x speedup (488ms down to 9.2ms) of bytes substring search generated with Claude Code

- numpy/numpy: https://github.com/numpy/numpy/pull/31573 - ~21x speedup of Python datetime → datetime64 conversion, with Claude Code used for profiling and implementing the performance improvements

- apache/datafusion: https://github.com/apache/datafusion/pull/21182 - up to 49x speedup of LIMIT queries by eliminating unnecessary sorts and pushing limits into file scans, generated with Claude Code

- apache/datafusion: https://github.com/apache/datafusion/pull/21651 - ~4.39x speedup of ClickBench Q6 by resolving MIN/MAX directly from Parquet metadata instead of scanning columns, generated with Claude Code

- pola-rs/polars: https://github.com/pola-rs/polars/pull/27958 - ~3.2x speedup of Int8 Series sum, developed with assistance from Claude Fable and Claude Opus 4.8

- numpy/numpy: https://github.com/numpy/numpy/pull/31274 - up to ~1.44x speedup of common small NumPy reductions, with the fast path written by Claude Code and manually refined

That's a fair use case for them though. LLMs are superhuman at short term performance engineering/debugging/testing. But even that comes with the caveat that these commits come from talented coders using LLMs as a grad student. I think that OP is against the claim that "agent in a loop beats a talented human at long term coding tasks".

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

I, too, will reject the idea that "agent in a loop beats a talented human at long term coding tasks".

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'm choosing to interpret this as very dry sarcasm.

With the "It's not X, it's Y" at the end I sure hope that it's the case.

You can tell that a human wrote it because X is a noun and Y is an adjective

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.

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.

We have a greenfield project at our company, yes proprietary, now taking us months where previously it'd have taken weeks for even a single feature. We definitely see the (whatever)x performance boost with our own eyes.

Its always been possible to trade long term productivity for short term gains with technical debt. This is why the bar I'm interested in is long term projects, which have proven to have long term success, instead of a small disposable project where the code quality doesn't matter

Difference is whether it's a false dichotomy now, because models like Fable can write better code than most devs I know.

Then why isn't it showing up in open source at all? The people who file PRs are just regular average devs, but the quality of LLM PRs seems to be universally crap in comparison

It is: https://news.ycombinator.com/item?id=49237476

> now taking us months where it'd have taken weeks...

So 0<whatever<1

Nah, the GP's claim is weeks for each feature, versus a few months in total. On a greenfield project.

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

Feature vs full project timeline

Or maybe open-source development is just poorly compatible with AI workflow? Today, projects may need a community, an issue tracker, but pull requests are becoming less important.

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!

Why would the PR format be bad for LLMs? Its just code review + merging in branches, which is what every company should be doing anyway

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

> 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.

If they were sneaking LLM generated code into these projects, we'd expect to see their feature development 10x even if they covertly aren't telling anyone. Which open source codebases have seen a truly massive 10x increase in delivered feature velocity since AI turned up? Where are all the new contributors who contribute features at 10x the rate of the existing meatcoding developers?

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

LLMs work well for boring stuff that other people have already done a hundred times. Where the LLMs fail is solving difficult problems that aren't explored as well. The people seeing the 10x speed up are likely just doing CRUD apps or other software that have already been well documented by Stack Overflow or cloned a million times on Github. In my own use, it completely breaks down when for solving actually difficult things.

> I regularly see people claim that they are now 10x more productive with LLM code generation, and I just wonder where all the code is.

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.

There's no reason that some people wouldn't be using their new found 10x superpowers on open source projects though

I use my powers to finish my own projects (until the next creative barrier) while my professional workload has been reduced to 20% effort with 0 stress.

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.

I find it game changing for experimental work and prototyping. As a research scientist this is a major bottleneck and clean code is often not the right optimization target.

> I think its fascinating just how much of a gap there is between what's being claimed, and the verifiable observable data of the open source world.

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/...

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

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?

> Why do only the poor quality LLM code generation users make PRs to open source projects, and never the engineers that know how to really use it correctly?

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.

The the idea that engineers are covertly sneaking huge quantities of LLM generated code into these projects doesn't pass the smell test, as there's lots of evidence that this isn't true. It'd be incredibly obvious if new contributors were turning up en masse and contributing absolutely incredible amounts of high quality code, because everyone would be crowing about it

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

> 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

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.