Go advances one blub ragequit at a time.

It's as if the only way you could think was by writing down a word, erasing all the thoughts from your head, then reading the word you just wrote down and deciding on the next word, etc.

Reasoning purely in latent space means that the model would still produce an output equivalent to tokens but unconstrained e.g. the output could be raw and opaque vectors. A significant downside is that you lose the ability to inspect the reasoning trace. It would also make the reasoning trace potentially larger which has operational issues.

In any case, the effects of extreme heat on the body are the easiest part of climate change to mitigate with current technology. The hard part is the famine.

I do agree that it's a problem but the root cause is the fundamental limitations of current gen LLMs, it's not an alignment problem.

We should prepare for a future without Firefox, because one day it won't be there anymore.

My point is that when MV3 was announced there was an assumption that maintaining a Chromium fork to continue supporting MV2 would be too much work and too expensive. But now with LLMs that's no longer a safe assumption. The non-Chrome chromium based browsers can fork chromium and add back MV2. No need for any expiration date.

The argument against was always that it's "too hard to keep a fork in sync". Now it's easier.

The very exponential that you are relying on to give you runaway improvement is also giving exponentially increasing data to your competitors. All else being equal your competitors stay a step behind but you never develop a monopoly either. That's the best case for Anthropic/OpenAI. In reality, training data is just one variable, exponentials don't last forever, and your competitors will get better at capturing a bigger slice of training data.

It only justifies their long term valuations if they can leverage that temporary monopoly for technological superiority (they can't) or lasting market share (they can't).

Chinese models prove there's no technical advantage, and the software side is heavily commoditized so there's not much advantages to market share either.

If I care about performance, use Rust.

If I care about iteration speed, use TypeScript.

If I want a script or numerical code, use Python.

LLMs are better with Rust because the more expressive type system provides stronger guardrails especially when writing multithreaded code. Go is almost the worst conceivable design of a programming language for LLMs: powerful but weak guardrails. Only C and C++ would be worse.

LLMs don't struggle with the low-level lifetimes like humans do. They struggle with the high-level view because of limited context windows. That's why you want a powerful type system to enforce those global constraints. Go ain't it.

With writing it's just more obvious. LLMs don't write with personality. They don't create new and exciting worlds on their own. Everything they output feels derivative.

In mathematics you see the same effect. They are very good at finding results that humans missed, taking advantage of their broad knowledge and tireless work ethic.

But just as they have been unable to create new literary worlds, they also have so far been unable to create new mathematics.

I believe this lack of creativity is intrinsic to how these models are architected and trained. We want models that produce these in-distribution outputs because those types of models are more economically valuable. Nobody wants a coding agent with spontaneity, we want models that predictably and obediently solve problems - and that's what we got.

Solving RH likely requires AI that is substantially more creative. But we haven't even solved the creativity problem for writing let alone mathematics. I believe that transformers are a trillion dollar local optimum that we will find it very hard to escape.

Let's wait for the models to produce a good novel first.

If a study found people who swim regularly are are less likely to get heart disease, that wouldn't be very surprising because know a lot about why people get heart disease. Therefore it would be valid to insist on more rigour for accepting (swimming => less heart disease) because the only use of that information is for health advice.

However even weak statistical correlations can be a valid lead for further research into Alzheimer's disease if they suggest where to look. You don't need to prove that signposts are correct in order to use them.

The other day I caught Claude including a rm -rf equivalent (fs.rmdir({ recursive: true, force: true })) in my code, to clean up temporary directories. It was fine, but that kind of code is only one misconfigured environment variable away from blasting away your $HOME.

When you use canvas you're giving up on not just accessibility but also optimizations that the browser does for you transparently when you use the native render tree. There's no guarantee that your app will be faster in canvas, it could easily be slower. Do you really think you can beat the browser's C++ by writing code in a language that doesn't even have a native integer type? Perhaps you can, but your base assumption should be that you can't.