This is it

Have you tried writing Rust? I often hear this from people who haven’t tried it. I’ve found absolutely no issues over python and everything works 100x better

I think the only use cases are when it wraps low level C++ libs like ML libraries, and yes those are extremely difficult to reproduce

I loved from writing all my code with LLMs from Python to Rust. I’ve seen absolutely no difference, most of the time I couldn’t even tell you which it’s writing in.

My programs are faster and more reliable than they’ve ever been.

Why? Go has a GC, is basically incompatible with C and very limited overall

'incompatible with C' isn't a serious problem nowadays and won't be a problem at all in a couple years.

Go's limited syntax is actually a feature here,because it stops the LLM from trying to be too clever

LLMs use `any` types, `recover`, `init`, and other weird warts of golang

rust is a better language in every way for LLMs: more precise typing, better compiler errors, fewer performance footguns, no race conditions, clear interface definitions and implementations

golang is easier for humans to quickly get productive, but the language is lacking in helpful features for an LLM

CGO exists.

This is it, people are acting like bad code wasn’t written before. My wife and I were full on laughing about it in bed the other night of all the absolutely horrible code we’ve seen written and how people actually think LLMs are worse than that.

The quality gates are up to you, and if you are smart you will make a lot of them and review them closely

There are also just problems where the code is the hard part…

What problems are they? I can't really think of any problems where writing the code was the hard part.

There's plenty of times where I don't know what code to write because I've never used a library before. But it's just a page of documentation away. It's not hard, it's just slow and tedious.

Can you not review it?

I think this misses the scale of the problem. Review never fixed tech debt, nor did it fix relevant/bloated test suites. It didn't solve complexity, or eliminate footguns. Very few people (I would argue almost noone) had developed theories for what all of these even were, or how to spot them in code.

Reviewers aren't perfect, far from it. And we just gave them ~20x more code to review. Incentives mean that taking 20x longer to review is unacceptable. So where do we go from here?

Review always misses something.

Agreed. Reviewing code takes so much longer and is far more exhausting than writing it, and you still don’t understand the logic as well or intuitively as you would if you write it.

Code reviews should be done by someone other than the author though, so the only thing that changes with ai generated code in that respect is the amount of it

That doesn’t conflict with my statement.

Before: One person writes the code (and likely understands it thoroughly), another person reviews the code to spot obvious mistakes or shortcomings. Now: AI writes the code, a person reviews it to spot obvious mistakes or shortcomings.

In the before case, you have a person who has a deeper understanding of the code and in the AI case, you don’t, instead you have even more code to review.

When a competent programmer is writing the code, the human written code tends to be higher quality too. So it’s not just about review quantity but the quality of code being reviewed. Some people claim the AI writes great code, but that just hasn’t been my experience yet (at least with the models I’ve tried, including Opus). They still make ridiculously bad decisions regularly.

This is the simplest and almost certainly correct answer.

I’ve seen this at a number of public companies, and is a reason I hate working for them. These decisions are always unbelievably short sighted and ruin companies in the long term.