[hombre_fatal]

> The flippant nature of people expecting the same respect for some piece of work that was churned out by a machine, as someone who understands every part.

> with people who have fully adopted claude in their work flows. They don't care about the code they push.

This just isn't true and it's the cynnical self-limiting assumption the belies rules like the TFA. It's like when HN was full of people claiming that you weren't a real engineer and didn't care about code if you used Javascript.

I've vibe-coded some pretty cool things that I use daily, and I've put some serious work into vibe-coding them. Months of work, infinite polish, infinite revisions, without writing a single line of code. It feels like the right level to be at with 20 years of software experience.

LLM use has merely freed up the chore work so that I can focus on more important directional concerns, polish the testing system to completely derisk it, and then do it in parallel with everything else I'm working on.

I'm starting to see the "LLM users don't care" assumption as a somewhat understandable defensive posture that mostly comes from resistance to the world changing and watching the value of our expertise go to zero. Something I still grapple with every week btw. Maybe if you accepted the idea that veteran software engineers can completely replace the code writing experience with AI while delivering good software, it involves swallowing a pill you're not ready to swallow?

Codeberg's new rule about LLMs is about as enforceable as a rule against bad code quality and that is the more interesting discussion.

[arkwin]

Thank you; that is probably a better way to put into words what I am feeling.

I've never called myself a developer. But I've been playing with Linux and looking at code for the better part of 20 years.

I've done a lot of larger solution development. "Glue code," etc.

I think I use LLMs quite well. I mean, on some level, I understand software architecture and system architecture.

I've (before LLMs) had a master's degree, CISSP, Sec+, CEH. I am a pretty "qualified" person for whatever that means.

AI has made the chore work easy. It also allows me to think deeper about something than just bashing my head against code. Instead of spending time writing code, I'm researching technologies and thinking strategically about what something should look like years from now.

I've spent weeks and months, even on pet projects with LLMs. Things I use daily too.

But somehow "LLM coders don't care" is just annoying.

[hombre_fatal]

And I'd just grant the fact that LLM enables more low quality, low effort spam. Just like how opening up the internet to more people instead of just the research/academic nerds led to the same thing.

But the problem is a low quality spam problem, not a "people use LLMs at all" nor a "people don't care about the code like real artisanal engineers" problem. Neither of which are something you can police btw since they can't be proven.

How do you build a platform that is resistant to spam and low quality submissions? If you want an honor system, why not set the self-policing bar at low quality content instead of what you feel is a proxy for it?

[alwaysbeconsing]

> I've put some serious work into vibe-coding them. Months of work, infinite polish, infinite revisions, without writing a single line of code.

Not being pedantic, but this is not "vibe-coding", as other commenter and blog post means it at least. Parent emphasize lack of work, polish, revisions:

> They don't care about the code they push. They generate, prune, generate, prune in 10kloc increments. They're apathetic to others who might need to use this code and expect some kind of consistent architecture/interface.

> This isn't to say all LLM users don't care about their work, but that there are far more people who are happy to push slop and take credit than the reverse.

[hombre_fatal]

No, the TFA policy is specifically against LLM usage, not low quality code.

What you quoted is just how people paint LLM-heavy users just like how people used to paint JavaScript users as incompetent.

That there are people using LLMs to write 100% of their robust, derisked code disarms their argument or commits them to a sillier one like TFA's "we ban LLMs because you might get it to build a CI pipeline before you have users".