In the hands of a skilled craftsmen, the machine enhances the productive process of the craftsmen. In their shop, as part of their labor process, making bespoke things, the machine serves the craftsmen.

However, the machine also reduces the socially necessary labor time for the mass production of a given thing. The laborers within this production environment are not craftsmen. All they know is how to operate the machine. Making parts of an eventual whole they'll never have a full hand in producing.

As the laborers are replaced and the machine persists, there is less demand for the kills of a craftsmen, and the new laborers do not need to be trained at the same capacity as the craftsmen. This process naturally deskills the labor force as time progresses.

You find it useful because you are trained and can more effectively describe the issue its resolving because the code is the result of your skill and training. You are the craftsmen in this situation. Soon however, you will become the supervisor to juniors who have even less of any understanding then you had in their position. Producing code using a machine, with little understanding of it's output, leaving you to pick up the slack.

The output will sometimes change the logic but I mean that's pretty easy to catch and fix

Lol. Lmao.

Writing code was never really the hard part of programming

What I really need is a steaming pile of new legacy code that might even work.

In my experience, LLMs can often pump out perfectly fine starting code for very basic problems. If you're coding up some tiny blog it'll probably be good enough that someone with some coding experience can unfuck the places where it screwed up.

That's not what professional software engineering is about though. You want a codebase built in a coherent, consistent, repeatable way that can be independently worked on by dozens of people often at the same time, and LLMs cannot do that in any real capacity. It might serve as a decent tool for spinning up quick proof-of-concepts (I've poked it to figure out a new framework before, mostly due to terrible documentation making it difficult to figure out how to use specific features) but none of it was production-worthy and never would be.

Furthermore, if you're using it to figure out entire languages/frameworks for you, you're quickly finding yourself in a position where you don't see where it's fucking up, which is going to hit you down the line when you're playing whack-a-mole with a bug or severe performance issue in a giant codebase.

Llms are the affordable table saw, no, the affordable router table of the software world.

They’re a powerful tool, but they increase the chance that the user will fiddlefuck around doing something stupid at best or something brutally, nastily, scared straight in the classroom dangerous at worst.

If there ever was a time to “jack off” and get rid of any computer interaction in your life, now is it.

Become “pretty close to an expert” by… outsourcing the process of improving your code to a machine…

Even if it improves your code in that scenario, you’re not going to really understand what it’s doing or why. You can use AI as a shortcut for scripting, but you can’t use it as a shortcut for learning

Edit: Besides, we already have perfectly good static analysis tools. Just use a linter. Trying to use AI as a linter will just be worse and unpredictable compared to using an actual linter

You dont need an LLM to do this though. I thought this skill just comes naturally to programmers who have had a lot of experience in diverse areas.

I'm in Linux/OSS spaces and virtually no one uses an LLM here since much of the work is more social than technical (negotiating many ways to resolve an issue) with a lot more problem solving than busywork. At some point you have to get your hands dirty and there are no more shortcuts.

In fact, LLMs have only harmed us in that there are more bogus bug reports and garbage slop being tossed at projects not to mention every community git forge having to implement some form of ddos mitigation because of the very harmful and real negative externalities of LLMs.

It won't kill off the need for skill, but a lot of lazy "coders" will stop even learning a minimal amount, and get by on no skill at all. Until they get fired, too.

Nothing the LLM generates can be relied on, it's a gibberish machine.

me writing spaghetti code

AI writing spaghetti code

This is only really useful in low expressiveness languages where there is not a huge set of language enhancements possible through libraries. Think Java exception handling for example.

In essence it works if you "best practices" are things like don't use switch statements.

It doesn't work if you best practices are things like use Result<T, E> from this functional result library.

Essentially LLMs don't really work "at scale" if you need anything more complicated than what the average internet tutorial code is in your language.

Same with perf.

Also this only works 60% of all the time though if that, so the more requirements you pile on the less likely it will hit all of them properly.

you're probably onto something but I feel like this isn't gonna stop employers from requiring people to have x years experience with whatever specific stack they're using

I've never used it for coding because the last time I was paid to write code it was updating a legacy codebase into Java SE 6, but last night I discovered my first real use case for LLMs, naming my farm and animals in a new Story of Seasons play through.

You can write FORTRAN in any language.