Personally, I find it faster if I use LLMs for the use cases I've found them to work well.

One example is just laborious typing-heavy stuff. Like I recently needed a table converted to an enumeration. 5 years ago I'd have spent half a day to figure out a way to sed/awk/perl that transformation. Now I can entertain an AI for half an hour or so to either do the transformation (which is easy to verify) or to setup a transformation script.

Or I enjoy that I can give an LLM a problem and 2-3 solution approaches I'd see, and get back 4-5 examples on how that code would look like in those solution approaches, and some more. Again, this would take me 1-2 days and I might not see some of the more creative approaches. Those approaches might also be entire nonsense, mind you.

But generating large amounts of code just won't be a good, time-efficient idea long-term if you have to support and change it. A lot of our code base is rather simple python, but it carries a lot of reasoning and thought behind it. Writing that code is not a bottleneck at all.

All that effort and the writing of very specific prompts in very specific ways in order to create a determenistic output just feels like a bad version of a programming language.

If we're not telling the computer exactly what do then we're leaving the LLM to make (wrong) assumptions.

If we are telling the computer exactly what to do via natural language then it is as complicated as normal programming if not more complicated.

As least that's how I feel about it

Still relevant . . . https://www.commitstrip.com/en/2016/08/25/a-very-comprehensi...

Have you ever used a WYSIWG editor?

One of the most frustrating (but common) things is you do v1. It looks good enough.

Then you go to tweak it a little (say move one box 10-15 pixels over, or change some text sizing or whatever), and it loses its mind.

So then you spend the next several days trying every possible combination of random things to get it to actually move the way you want. It ends up breaking a bunch of other things in the process.

Eventually, you get it right, and then never ever want to touch it ever again.

These are all just stopgaps, this tech is still in its infancy. If it keeps improving, it will reach a point where it can implement complex things from simple prompts, the way that talented programmers can.

I’m not a fan of a lot of this AI stuff, but there is no reason to expect it won’t get to that level.

Talented programmers often don't get things right though. They can make the wrong assumptions about what a product person wants or what a client wants.

And that normally stems from lack of information or communication problems.

> there is no reason to expect it won’t get to that level.

that's not an argument. that's just magical thinking

It’s magical thinking to think it won’t! We already have one example of it being possible (in humans). Unless you think humans have a “soul” or some other intangible element, then there’s no reason they can’t be emulated.

lots and lots of things are theoretically possible

Yes, it often is much faster, and significantly so.

There are also times where it isn't.

Developing the judgment for when it is and isn't faster, when it's likely to do a good job vs isn't likely, is pretty important. But also, how good of a job it does is often a skill issue, too. IMO the most important and overlooked skill is the having the foresight and the patience to give it the context it needs to do a good job.

> There are also times where it isn't.

Should this have the "Significantly so" qualifier as well?

I'm not sure. I think it's asymmetric: high upside potential, but low downside.

Because when the AI isn't cutting it, you always have the option to pull the plug and just do it manually. So the downside is bounded. In that way it's similar the Mitch Hedberg joke: "I like an escalator, because an escalator can never break. It can only become stairs."

The absolute worse-case scenario is situations where you think the AI is going to figure it out, so keep prompting it, far past the time when you should've changed your approach or gfiven up and done it manually.

Ha, great answer! Of course there are a lot of nuances to that but I don't want to get into beating dead horses.

This is so far from an absolute worst-case scenario.

You could have a codebase subtly broken on so many levels that you cannot fix it without starting from scratch - losing months.

You could slowly lose your ability to think and judge.

The thing is it's not actually that much effort. A day of work to watch some videos and set things up then the only issue is its another thing to remember. But we developers remember thousands of arcane incantations. This isnt any harder than any of the other ones and when applied correctly writes code very very quickly.