> For one, there are objectively detrimental ways to organize code: tight coupling, lots of mutable shared state, etc. No matter who or what reads or writes the code, such code is more error-prone, and more brittle to handle.

Guess what, AIs don't like that as well because it makes harder for them to achieve the goal. So with minimal guidance, which at this point could probably be provided by AI as well, the output of AI agent is not that.

Yes LLMs aren't very good at architecture. I suspect because the average project online has pretty bad architecture. The training set is poisoned.

It's kind of bittersweet for me because I was dreaming of becoming a software architect when I graduated university and the role started disappearing so I never actually became one!

But the upside of this is that now LLMs suck at software architecture... Maybe companies will bring back the software architect role?

The training set has been totally poisoned from the architecture PoV. I don't think LLMs (as they are) will be able to learn software architecture now because the more time passes, the more poorly architected slop gets added online and finds its way into the training set.

Good software architecture tends to be additive, as opposed to subtractive. You start with a clean slate then build up from there.

It's almost impossible to start with a complete mess of spaghetti code and end up with a clean architecture... Spaghetti code abstractions tend to mislead you and lead you astray... It's like; understanding spaghetti code tends to soil your understanding of the problem domain. You start to think of everything in terms of terrible leaky abstraction and can't think of the problem clearly.

It's hard even for humans to look at a problem through fresh eyes; it's likely even harder for LLMs to do it. For example, if you use a word in a prompt, the LLM tends to try to incorporate that word into the solution... So if the AI sees a bunch of leaky abstractions in the code; it will tend to try to work with them as opposed to removing them and finding better abstractions. I see this all the time with hacks; if the code is full of hacks, then an LLM tends to produce hacks all the time and it's almost impossible to make it address root causes... Also hacks tend to beget more hacks.

Objectively, we are talking about systems that have gone from being cute toys to outmatching most juniors using only rigid and slow batch training cycles.

As soon as models have persistent memory for their own try/fail/succeed attempts, and can directly modify what's currently called their training data in real time, they're going to develop very, very quickly.

We may even be underestimating how quickly this will happen.

We're also underestimating how much more powerful they become if you give them analysis and documentation tasks referencing high quality software design principles before giving them code to write.

This is very much 1.0 tech. It's already scary smart compared to the median industry skill level.

The 2.0 version is going to be something else entirely.

Can't wait to see what Opus 13.0 does with the multiverse.

Wake me up at Opus 12

Just one more OPUS bro.

I also love how AI enthusiasts just ignore the issue of exhausted training data... You cant just magically create more training data. Also synthetic training data reduces the quality of models.

> Up until now, no business has been built on tools and technology that no one understands. I expect that will continue.

Big claims here.

Did brewers and bakers up to the middle ages understand fermentation and how yeasts work?

Does the corner bakery need a moat to be a business?

How many people understand the underlying operating system their code runs on? Can even read assembly or C?

Even before LLMs, there were plenty of copy-paste JS bootcamp grads that helped people build software businesses.

Most legacy apps are barely understood by anyone, and yet continue to generate value and and are (somehow) kept alive.

> no business has been built on tools and technology that no one understands

Well, there are quite a few common medications we don't really know how they work.

But I also think it can be a huge liability.

I've also noticed that going off the rails. At the start of a session, they're pretty sharp and focused, but the longer the session lasts, the more confused they get. At some point they start hallucinating bullshit that they wouldn't have earlier in the session.

It's a vital skill to recognise when that happens and start a new session.

Yeah, I might be early to this. And certainly, I still read a lot of code in my day to day right now.

But I sure write a lot less of it, and the percentage I write continues to go down with every new model release. And if I'm no longer writing it, and the person who works on it after me isn't writing it either, it changes the whole art of software engineering.

I used to spend a great deal of time with already working code that I had written thinking about how to rewrite it better, so that the person after me would have a good clean idea of what is going on.

But humans aren't working in the repos as much now. I think it's just a matter of time before the models are writing code essentially for their eyes, their affordances -- not ours.

In my experience, LLMs perform significantly better on readable maintainable code.

It's what they were trained on after-all.

However what they produce is often highly readable but not very maintainable due to the verbosity and obvious comments. This seems to pollute codebases over time and you see AI coding efficiency slowly decline.

> Poe's law is an adage of Internet culture which says that any parodic or sarcastic expression of extreme views can be mistaken for a sincere expression of those views.

The things you mentioned are important but have been on their way out for years now regardless of LLMs. Have my ambivalent upvote regardless.

[1] https://en.wikipedia.org/wiki/Poe%27s_law

as depressing as it is to say, i think it's a bit like the year is 1906 and we're complaining that these new tyres for cars they're making are bad because they're no longer backwards compatible with the horse drawn wagons we might want to attach them to in the future.

Do readability and maintainability not matter when AI "reads" and maintains the code? I'm pretty sure they do.

If that would be true, you could surely ask an LLM to write the same complexity apps in brainfuck, right?