1. Some huge % of those possible programs are obviously not the one you want (most don't even compile).

2. Remaining programs might look similar to the one you want, but are buggy enough to be completely unusable, unreadable to the point of intractability, and so on.

3. Remaining programs look substantially correct but upon using for > a few mins you note major bugs that make it still not correct enough.

4. Remaining programs look substantially correct and seem to generally do your will but contain a long-tail showstopper subtle bug that corrupts saved data, or makes all the output subtly incorrect, etc.

5. Remaining programs might be useful, even if they're mildly annoying.

6. This process can probably continue for several thousand iterations until you finally find "it." The program you wanted. Or... one of them. There's probably still 10k+ candidate programs left at this stage.

Our job has always been to get to 5 and aspire to 6. Indeed most of software development is just doing 5->6 in a loop.

I think LLMs help us get to somewhere between 3 and 5 faster than we used to. And a big problem with them is that programs in 3 vs 5 all already look substantially correct and there's no way to know if you're getting 3 or 5.

Generally, the above is not how it _felt_ to write software pre-LLMs, it was just a cute way to imagine what you're doing. Now it's weirdly apropos.

Slop has always been cheap. Now it's even cheaper. But software that actually fucking works AND does what you want is still expensive as hell.

Lots of modern (...3+) python code uses type hints and a type checker. It can be as strict as you'd like it to be, which is exactly how I like it. It's what pulled me away from ruby.

Meanwhile, static languages are too often a giant pain in the ass, and in return for writing a lot of annoying code, you get in return guarantees that only really apply within your process's memory. And in a microservices world... you're actually realistically using the protobuf type system. Which generates just fine for python. And then "internally" you can use python's type checking where it helps, and if it doesn't help, then for that bit of the code, simply don't use it (and write "true" python).

I also find that a HUGE problem in the world is that programmers just. can't. help. themselves. They LOVE to over-define. LOVE IT. It's a siren's song!! Static type systems are a trap for the part of our brain that loves to architect. One of my favorite things about python is that it helps programmers _let go_. Not everything needs to be an interface. It's python. Everything is already an interface. Now just write the code without all the distracting 20 layers of indirection. And if we ever need one more, it's python - it's practically already there. Just make a new type, put @property on some methods, and you're good.

Obviously there are times I'd not use python. I could foresee myself writing Rust if I had to do code where correctness was of utmost importance (like, crypto, or embedded software for a medical device where someone's ventilator is hooked up to it, or similar). But if nobody's going to die (so... medical and cryptography...) then I'm using python almost no matter what I'm doing. And I'll use numpy or write a C module if I actually end up needing true CPU-bound performance for something.

No. The very fact they are trying to "warn" us means it's all marketing.

This has been corroborated for me on the engineering front that I can't find a single IC I respect who actually thought there was any evidence AI was going to live up to the hype. I saw a lot of people I always thought were idiots/sycophants/brown nosers go insane with AI. Never saw anyone id trust to help me cross a street blindfolded say more that "I may be wrong, but I'm not seeing any evidence yet".

And the outbox pattern isn't bs - it DOES help a lot in practice. But exactly how much it _guarantees_ something happens is of course still quite limited. And yes as you note it's an At-least-once strategy.

This made everyone scream and lose their minds saying that code is finished, people think they don't need a technical cofounder anymore, think they don't need engineers anymore, etc. Then they're, at varying speeds, finding out they're wrong.

It seems oddly circular to me that the _exact hubris_ non-engineers have long accused engineers of - and we have indeed been too often guilty of - they themselves turn out to be JUST as guilty of! Just like engineers thought all sales did was bother people, and all marketing did was send emails, and all support did was tell people to turn it off and on again, and all product did was copy google... they all apparently thought all engineers did was tik-tak-click-clack type code all day and when it compiled it was done. Not knowing how much higher-order... well, engineering, there is to it.

Where are all the CTOs during all of this? I thought someone was supposed to be sticking up for their org? Sales, marketing, etc all seem to have entrenched C-suite people keeping their fiefdoms resistant to erosion by outsourcing, downsizing, etc. But all our CTOs seems to have collectively thrown us to the wolves.

I would rather we not have technology than have people starving en masse. Literally our best hope is that the rich bastards are lying that they'll be able to do it to scam other rich bastards.

When I was in high school we were able to have an app that made it look like you were drinking beer. And the internet produced rainbow unicorn attack and nyan cat.

I was very optimistic about nyan cat. I'm very unoptimistic about nobody being able to afford computers for the next 5+ years.

Also since this thread is about general malaise - I am finding myself rather missing GW Bush's jovial brand of imperialism and cronyism. Strange fate.

My oldest starting preschool was one of the worst times in my life. We were sick from august to december, then january to may. Dreadful.

It got better. My youngest is 3 now and is ahead of where my oldest was due to having 2 older siblings importing illnesses for several years, and this year we finally were mostly not sick all school year. Which is to say, we were probably closer to the 15 days "materially sick" mark. I say materially sick to mean, definitely sick, though perhaps not taken out of school (due to not technically being outside of the health exclusion policy, and sometimes I only realize they were "materially" sick after they got home instead of just "passably sick given kids will basically have a lingering cough from august to may).