On the future of coding

2025 felt like a long year. Like, a really long year. One reason was the truly awesome developments in what people call AI. I can't and don't want to review how this space evolved. Instead, I want to focus on two question that accompanied this development: How do LLMs change the way I code, and how will my profession look in the future?

At least one thing seems clear: I will still have a job, in 2026 and beyond. Autonomous agentic coding is not there yet and I don't think this will change in the near to mid-term future. The machines still need us.

But for what?

I've used LLM assisted coding intensively, both for small personal projects and professionally in a medium-scale software system. I've used them to analyze, plan, implement, review, and refactor. I occasionally used them to write Linear issues, too, but eventually pivoted back to hand-crafting tickets myself.

From that experience, the underlying issue is this: LLMs don't understand the code they produce.

It sure looks like they do and their presentation often left me confident that a solution is solid, when in reality, most of it is superficial.

Generated code tends to rot fast.

LLMs don't have the kind of understanding you get from working with the code:

How to build a thing so that it remains open to future changes? Where to add this new thing so that it causes minimal friction? When to add code and when to reuse what's already there? What can be stripped away to reveal common structure?

In hindsight, this is not at all surprising. LLMs don't model understanding. They model probabilities of token sequences. They choose words that are likely to come next given what was already written. This works exceptionally well with programming languages because these languages are highly structured.

The code generally looks reasonable, because it is, at least syntactically. The semantics, though...

I think it's best to interpret LLMs as huge databases with a flexible query language. This interpretation is baked deep into their architecture. The core building block — Multi-Head Attention — even names its inputs $Q$, $K$ and $V$ for Query, Key and Value. It soft-selects the values where there queries and keys look similar:¹

$$ \text{Attention}(Q, K, V) = \text{softmax}\left( \frac{Q K^\top}{s} \right) V. $$

But databases don't know anything. They store and retrieve facts. LLMs can retrieve facts that were not explicitly stored, but retrieving is not the same as understanding.

For me, it boils down to this: The machines still need us to think. They need us to understand requirements and to guide them to the goal. They can give suggestions and show options, but ultimately it's up to us to decide.

We will still need to understand. We will still need to research. We will still need to plan. We will still need to specify. We will still need to review.

And yes, we will still need to code.

Only the focus will shift away from doing and more towards thinking. Our job will become more like that of other engineers.

I think that's a good thing.