[arkwin]

I can see the point you are trying to make, and I'll make a counterpoint to that. When you play the "didn't earn" card, you are really getting nowhere. It's a bad argument.

It's putting up the gate, "I feel you didn't work hard enough for X result, but I did, so I must be better"

I drive a manual car. Should I hate every automatic car driver?

I have a master's degree in cybersecurity; should I shit on everyone who doesn't when they try to mention anything involving cybersecurity? I mean, I have a piece of paper that says I've earned it?

On some level, yes. I would listen to the advice of a doctor over a random person on the internet.

On another level, it's like saying, " Oh, you didn't have a blacksmith handcraft that knife for you, and you bought some machine-made knife? We should ban machine-made knives; the person making a knife using a machine didn't 'earn it '."

Perhaps you shouldn't create code; after all, you probably didn't develop a compiler. Or the computer chip running it... Or the OS.. Did you really earn the right to develop something?

[agentultra]

It’s a big tent and anyone is welcome in. I learned to code on my own thanks to the efforts of people to write manuals, articles, text files on BBSs and NNTP. That’s just one way.

But try the other shoe on and walk a mile. You like writing code and solving problems yourself. Everyone in the world is telling you you’re irrelevant and should start using the machine or get left behind. The future is here and you’re not a part of it unless you give up and join us. Constantly.

It was hard before LLMs to convince software developers, let alone managers and product people and everyone else, to take quality seriously. Now it’s orders of magnitude harder. Because anything you say is met with someone who doesn’t care and thinks it’s all irrelevant. The machine will get better. It will solve all of these problems. Give up.

Fortunately that hasn’t deterred craftspeople in other trades who made knives, custom cabinetry, boats, houses and the like. Sure automation and progress has made a lot of knives available. Maybe more than we need. And most of them are disposable crap. But there are still knife makers.

All this talk of being reasonable is hard to take seriously when neither side will consider the other.

It’s also possible that even after considering all of the technical features and capabilities that LLMs bring to software development that some folks don’t find the cost of using them to be worth it. So they can say, “Sure, I will use such tools when and if I deem it appropriate.” Which may be never.

But we’re in a world right now where you can be coerced into feeling like there’s no choice but to accept those trade offs and just use the LLM.

I think it’s interesting and good that there exist places for people who share similar goals. There are few places for people who want to just do programming to chill out and not be surrounded by LLM generated code.

Also the scraping situation is totally getting out of hand. Having to keep up services is not easy or fun work. It’s just toil created at the expense of many for the benefit of few.

[MSFT_Edging]

It's less about "earning" and more the attitude and approach to the work. 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. I know I used "earn" a lot in the last reply, but that was a shorthand for something more complex. A combination of appreciation, discipline, and a common work style.

The LLM stuff is being gatekept because the people inside the gate care, and the people bringing the LLM code don't.

I drive a manual car too, and I get upset when someone who doesn't care about where they're putting their car, let alone the transmission, endangers me on the road. They're apathetic.

I work with people who have fully adopted claude in their work flows. 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. Its exhausting to deal with yet they love to say "I did this". I respect someone who tells me "I slopped this out" more, as they respect me enough to set expectations.

I think if you're trying to build a community of people who care, you must defend against those who are apathetic, or else they'll bring the whole community down.

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. To carefully screen those people brings us back to the original complaint, LLMs turn programmers into paperwork drones. Attempting to screen these types of users takes away even more time from the purpose of the community.

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

[arkwin]

Hey, thanks for taking the time to reply. And you bring up some good points. I'll be the first person to tell someone I used Claude on this. Hell I make sure it says co-authored by claude on my github projects specifically because I'm not trying to hide the fact that I'm using LLMs.

I think you are correct, is not not really an LLM problem as much as its a person problem.

But there doesn't seem to be a good way to fix this. If anything LLMs just expose someone's integrity? I don't know, its a hard answer. Some people use LLMs just because they are translating languages.

How do you prove "work" or "knowledge?"

[krinchan]

The shift here is that up until now output (code, in this case) required a degree of competence. As such, we socialized that being able to put out the code showed a degree of competence. The act of putting together a PR with working tests showed you had a level of knowledge past "I want X to do Y."

Now, you have a lot of people taught that output (a working PR) is competence. They walk around thinking they are competent because they can produce output.

When faced with criticism on working code, they collapse and flail immediately because to admit they can't explain or defend the code is to admit they are not competent. From there you've hit pretty much all of the problems that the rest of the Internet suffers from: cognitive dissonance, digging in because being wrong threatens your constructed identity, constructing echo chambers of AI Influencers peddling the latest prompt, and so on.

[saltcured]

Hiring a great F1 driver does not make a racing team owner a great driver.

Some of the people shoveling LLM slop seem to miss that point.

[chapel]

Someone using an LLM to code isn't calling themselves a great coder just because the LLM is writing good code. Being a software engineer/developer (whatever you want to call it) is not defined solely on your ability to write code.

To go back to your point, before the F1 driver (LLM) was hired the owner was the driver, mechanic, and everything else. Now that they have a driver they can focus on all the other roles and just ensure the driver is not crashing.