> "Then three months later, you realize nobody actually understands what you’ve built."

gratz, gang, you turned everything into Perl.

well

*(dusts off `perldoc`)*

I'll be ready

This, to me, is the most insidious effect of AI.

Whether it's as complex as code or as simple as fact-checking a search result. People lose confidence in their judgment, and therefore their agency is eroded.

This is kind of the obvious conclusion. I didn't need to use AI to know this would be the outcome. This is why I only use it for small code snippets if at all. This is why I've taught my kids not to rely on AI to do their homework.

It may seem like the easy way but it will absolutely come back to haunt you later. If you don't do the work you don't learn anything or develop any skills.

Auditing the code it produces is basically the only effective way to use coding LLMs at this point.

You're basically playing the role of senior dev code reviewing and editing a junior dev's code, except in this case the junior dev randomly writes an amalgamation of mostly valid, extremely wonky, and/or complete bullshit code. It has no concept of best practices, or fitness for purpose, or anything you'd expect a junior dev to learn as they gain experience.

Now given the above, you might ask yourself: "Self, what if I myself don't have the skills or experience of a senior dev?" This is where vibe coding gets sketchy or downright dangerous: if you don't notice the problems in generated code, you're doomed to fail sooner or later. If you're lucky, you end up having to do a big refactoring when you realize the code is brittle. If you're unlucky, your backend is compromised and your CTO is having to decide whether to pay off the ransomware demands or just take a chance on restoring the latest backup.

If you're just trying to slap together a quick and dirty proof of concept or bang out a one-shot script to accomplish a task, it's fairly useful. If you're trying to implement anything moderately complex or that you intend to support for months/years, you're better off just writing it yourself as you'll end up with something stylistically cohesive and more easily maintainable.

Trained dev with a decade of professional experience, humans routinely fail to get me workable specs without hours of back and forth discussion. I'd say a solid 25% of my work week is spent understanding what the stakeholders are asking for and how to contort the requirements to fit into the system.

If these humans can't be explict enough with me, a living thinking human that understands my architecture better than any LLM, what chance does an LLM have at interpreting them?

Even more efficient: humans do the specs and the implementation. AI has nothing to contribute to specs, and is worse at implementation than an experienced human. The process you describe, with current AIs, offers no advantages.

AI can write boilerplate code and implement simple small-scale features when given very clear and specific requests, sometimes. It's basically an assistant to type out stuff you know exactly how to do and review. It can also make suggestions, which are sometimes informative and often wrong.

If the AI were a member of my team it would be that dodgy developer whose work you never trust without everyone else spending a lot of time holding their hand, to the point where you wish you had just done it yourself.

It's more like the ancient phenomenon of spaghetti code. You can throw enough code at something until it works, but the moment you need to make a non-trivial change, you're doomed. You might as well throw away the entire code base and start over.

And if you want an exact parallel, I've said this from the beginning, but LLM coding at this point is the same as offshore coding was 20 years ago. You make a request, get a product that seems to work, but maintaining it, even by the same people who created it in the first place, is almost impossible.

The thing about this perspective is that I think its actually overly positive about LLMs, as it frames them as just the latest in a long line of automations.

Not all automations are created equal. For example, compare using a typewriter to using a text editor. Besides a few details about the ink ribbon and movement mechanisms you really haven't lost much in the transition. This is despite the fact that the text editor can be highly automated with scripts and hot keys, allowing you to manipulate even thousands of pages of text at once in certain ways. Using a text editor certainly won't make you forget how to write like using ChatGPT will.

I think the difference lies in the relationship between the person and the machine. To paraphrase Cathode Ray Dude, people who are good at using computers deduce the internal state of the machine, mirror (a subset of) that state as a mental model, and use that to plan out their actions to get the desired result. People that aren't good at using computers generally don't do this, and might not even know how you would start trying to.

For years 'user friendly' software design has catered to that second group, as they are both the largest contingent of users and the ones that needed the most help. To do this software vendors have generally done two things: try to move the necessary mental processes from the user's brain into the computer and hide the computer's internal state (so that its not implied that the user has to understand it, so that a user that doesn't know what they're doing won't do something they'll regret, etc). Unfortunately this drives that first group of people up the wall. Not only does hiding the internal state of the computer make it harder to deduce, every "smart" feature they add to try to move this mental process into the computer itself only makes the internal state more complex and harder to model.

Many people assume that if this is the way you think about software you are just an elistist gatekeeper, and you only want your group to be able to use computers. Or you might even be accused of ableism. But the real reason is what I described above, even if its not usually articulated in that way.

Now, I am of the opinion that the 'mirroring the internal state' method of thinking is the superior way to interact with machines, and the approach to user friendliness I described has actually done a lot of harm to our relationship with computers at a societal level. (This is an opinion I suspect many people here would agree with.) And yet that does not mean that I think computers should be difficult to use. Quite the opposite, I think that modern computers are too complicated, and that in an ideal world their internal states and abstractions would be much simpler and more elegant, but no less powerful. (Elaborating on that would make this comment even longer though.) Nor do I think that computers shouldn't be accessible to people with different levels of ability. But just as a random person in a store shouldn't grab a wheelchair user's chair handles and start pushing them around, neither should Windows (for example) start changing your settings on updates without asking.

Anyway, all of this is to say that I think LLMs are basically the ultimate in that approach to 'user friendliness'. They try to move more of your thought process into the machine than ever before, their internal state is more complex than ever before, and it is also more opaque than ever before. They also reflect certain values endemic to the corporate system that produced them: that the appearance of activity is more important than the correctness or efficacy of that activity. (That is, again, a whole other comment though.) The result is that they are extremely mind numbing, in the literal sense of the phrase.

Once you automate something, the corresponding skill set and experience atrophy. It's a problem that predates LLMs by quite a bit. If the only experience gained is with the automated system, the skills are never acquired.

Well, to be fair, different skills are acquired. You've learned how to create automated systems, that's definitely a skill. In one of my IT jobs there were a lot of people who did things manually, updated computers, installed software one machine at a time. But when someone figures out how to automate that, push the update to all machines in the room simultaneously, that's valuable and not everyone in that department knew how to do it.

So yeah, I guess my point is, you can forget how to do things the old way, but that's not always bad. Like, so you don't really know how to use a scythe, that's fine if you have a tractor, and trust me, you aren't missing much.

You can vibe write and vibe edit a movie now too. They also turn out shit.

The issue is that llm isnt a person with skills and knowledge. Its a complex guessing box that gets thing kinda right, but not actually right, and it absolutely cant tell whats right or not. It has no actual skills or experience or humainty that a director can expect a writer or editor to have.

Wrong, it's just outsourcing.

You're making a false-equivalence. A director is actively doing their job; they're a puppeteer and the rest is their puppet. The puppeteer is not outsourcing his job to a puppet.

And I'm pretty sure you don't know what architects do.

If I hire a coder to write an app for me, whether it's a clanker or a living being, I'm outsourcing the work; I'm a manager.

It's like tasking an artist to write a poem for you about love and flowers, and being proud about that poem.

Once Boston Dynamic style dogs and Androids can operate over a number of days independently, I'd say all bets are off that we would be kept around as pets.

I'm fairly certain your Musks and Altmans would be content with a much smaller human population existing to only maintain their little bubble and damn everything else.

Edit: I’m an idiot.

Same here. Nobody knows what the eff they are doing. Especially the people in charge. Much of life is us believing confident people who talk a good game but dont know wtf they are doing and really shouldnt be allowed to make even basic decisions outside a very narrow range of competence.

We have an illusion of broad meritocracy and accountability in life but its mostly just not there.

Ive worked with a fractional CISO. He was scattered, but was insanly useful about setting roadmaps, writting procedure/docs, working audits and correcting us moving in bad cybersecurity directions.

Fractional is way better than none.