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

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

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.

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.

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!

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.

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

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

You have to consider that there is a chilling effect in the open source space because llm use has now become an ideological battle, and people have lost their collective minds over it.

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

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

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.

On your last point, I think it has a lot to do with how it's introduced in organizations. If everyone just goes hog wild with it, enamored with their newfound productivity, not only will the little gains be lost, I'd argue all the generated noise will be a net negative. And people will hate that.

That's the result of AI adoption in a company being people just getting a subscription and doing their own thing, instead of systematically introducing and finding a common ground; a trivial example of that would be open source projects increasingly adopting LLM policies to get everyone on the same page.

I find this to be an incredibly myopic viewpoint. Software engineering is not defined by a single tool or technology, but rather how we design, implement, and maintain processes of value we want to automate or scale.

LLMs will certainly be an aide, but assuming adoption of them is required across a whole _field_ ignores whole classes of problems, domains, and constraints the production of software covers.

Rather, we should be wary of allowing our skills and hard-earned knowledge to atrophy by over reliance on new technology that is far from perfect, reliable, or even universally available. These tools more than any before suffer from the junk-in-junk-out problem and I’d much rather work with someone who knows their fundamentals than someone who knows their way around a the LLM of the month.

Okay. Please generate using an AI model code for a safety-critical system which is able to be incorporated into an aircraft and that passes the coding standards and requirements in that domain and come back and tell us all about it. Surely, if AI was so good across the entire domain of software engineering, this would be trivial to do.

Edit: although you might be subject to an NDA... But this is pretty much my test for "AIs will take all the jobs": can it write truly safety-critical software yet?

I recently asked it a series of technical physics questions about a field I used to be involved in to evaluate whether it'd be useful for doing research, and literally every single answer it gave was critically wrong - even for basic questions. Its certainly true that I went "holy shit", but not in a good way

I did but it was followed by "holy shit now I gotta review this +3000 -500 LOC PR full of subtly wrong abstractions, needless diversions and incorrect assumptions".

People keep repeating your sentiment here but I simply can't follow, are we even on the same planet? Or did everyone switch to just not caring about maintainability and code quality anymore? Or are your work tasks simply so mindnumbingly, stupidly simple that even an AI can oneshot them properly?

I mean this honestly btw, not dismissively like some sister comments. The gap between the productivity increases people report on HN and what I experience myself is insane. In fact, if I factor in the procrastination I find myself doing on dotting the i's on a supposedly "one-shotted" AI implementation of a nontrivial feature, I think the AI actively slows me down.

The only way I've found that I can actually use AI productively and sustainably is in very small tight loops and, well, at that point it's not that much faster than just typing in the code (with the occasional "Cursor Tab" complete).

Am I doing something wrong?

Oh, I have those moments daily. Like, "holy shit, I can't believe it just fucked up a rote task this badly".

I have been doing this stupid shit for long enough that, frankly, I am only happy when it does exactly what I intended.

[flagged]

[flagged]

Not everyone is a web developer bub

I agree but how many developers did you know making heavy use of it? It always seemed like it was a poorly thought out experiment that gained a lot of traction and hype from the non-technical crowd. I don't say that to be elitist, I just think that non-technical users need a much more consistent and constrained product because they can't really fix and upstream things themselves (even with the use of agents). For all the hype it got, not a single person from my circle installed it to even check it out.

I do agree that the current pace of abandonware creation is wild. I think a lot of projects are generated top down from an idea, and not bottom up through usage. If you have a new experimental project, and you don't have recent commits, I assume you are not using it and thus it has no value.

I think agentic use is mostly only valuable as author extension (help you search, rubber duck, generate code but needs very heavy review). Over time with enough usage of a process I do think some of them can turn into author automation but not from simply writing down an idea. It takes lots and lots of executions, iterations, generalizations, specifications, basically lots of work to get any decently hands-off intelligent automation through agents.

Did that get bought by openai? Lost its rogue cool factor.

Maybe OpenClaw solved the problem it was designed to solve.

remember moltbook?

Adding too many tests was a real issue before LLMs. You end up in situations where you when you add a feature there's 200 (out of e.g. 10k) tests that fail and you have to figure out which of them should fail and you need to fix them and which are actual bugs.

[flagged]

> some people are just not very into building step by step like "okay first let's check the JSON shape the endpoint returns", "okay now let's make a simple form", etc

That's accurate. There are a lot of people (some of them quite senior and/or skilled) who operate in the way you described.

The build and test steps allow the agent to self correct. Why would I want to waste my time trying out a half-finished or outright broken feature if the AI didn't even run a type checker on it to see if it even compiled?

> just pointing an agent swarm at 50 Github tickets and saying "go get 'em boys"

I still don‘t know if this is real. If it works like that, where are the companies that only kept every tenth, 10x‘d AI enhanced dev? They should have significantly higher margins. The companies that keep all devs and 10x‘d them, finally bringing that backlog to 0 should have exploding revenue and profit.

Where does AI create value? I can‘t see it.

I use it every day, but nothing got faster.

> The product is being launched before the value is clear.

May I fix that for you?

The product is being launched before the value is there.

> True software factories now exist

That statement somehow amazes me. Obviously, LLMs need plenty of steering, but I don't get how a company can be built on that.

I suspect the issue there was Claude, especially Opus 5, which just hates the idea that it could ever be wrong about anything.

> I'm so sick of having AI chase a bug and having to lead it by the hand like a toddler to try and help me solve bugs.

This hasn't been my experience at all. I can give it a vague description of the problem and have it find it pretty easily without any more input from me.

I do think there's a pretty big variation in tools and setups and what output people are getting. I'm now just using OpenAI Codex in VS Code and it churns through problems like they're nothing.

Sometimes I have to get it to not over-engineer a solution; not because it's necessarily wrong but because I don't need that much correctness.

The discontent is real. The deficiencies these people mention are real. And it's not actually getting better. Sure, web devs and CRUD app devs may be screwed over a bit harder now, but when it gets into really deep complex stuff, the usability of the output goes way, way down. This cliff is real. I assure you. And it's not getting better.

Why is that strange? To me, it’s evidence of growing dissatisfaction with the direction of the field and frustration with being made to deal with the consequences of others bad work

I agree, the fact that with an open model I can be modifying go and react code that I'd never consider touching as a human who values their eyesight and come up with real patches, fixes and extensions of almost any project on github is truely fascinating and, addictive.

I can absolutely see where this technology works; but like EVERYTHING THAT THESE VC FUNDED FASCISTS IGNORE, just because it works in the lab does not mean it works in real life. I can see exactly where this technology fails: it lets you spool out so much thread into the abyss that you're just going to keep refactoring everything, all the time and when it blows a hole in your project, whelllp! you wanted to refactor that too. Imagine having 100 side projects grossly built and still, you just want to move on.

Fiishing projects are still going to need work and the explosion of "this is _my_ engineering harness" is everyone twiddling their thumbs cause real projects of significant value are still about scope and "total addressable market" and not "I made an AI to diddle children, so you dont have to" crowd.

I think it's true. Writing code is the most fun part of my job, but it's also the least time consuming. For any given feature, everything around the code takes 10x as much time. Getting the requirements, writing the spec, refining the spec, doing the QA work, delivery. The actual "coding" part in the middle is quick, fun, and creative. Since it's quick I get to sit and think about abstractions and performance, which is great.

But, it could be even quicker if I just give up and willingly write shitty code that works. I don't do that, but I could, and I doubt anyone outside of close developers on my team would ever notice.

A great article yesterday about this very concept: https://news.ycombinator.com/item?id=49222189

The hard part was the rote memorization of leetcode challenges and then learning to pattern match to the particular problem in a 5 minute technical interview.

The second part was that the test was being administered by a gatekeeper who was hired before those practices were put in place.

The 3rd was what? Amazon or Netflix burning your ass out because they are anti-human companies?

I don't think you really deserved downvotes. Some people are more geared toward evangelizing technology (or evangelizing anything really), and some are not. I'm pretty much in the 'not' camp.

I'll share my experiences and how I do things, but I'm not about to engage in arguments about it. If you don't want to use it, then don't. What I do I care?