The Scenic Route

For anyone who once stayed up past midnight because a piece of code was simply too beautiful to leave alone.

Do you remember the first time a program worked?

It was probably something small, like a loop that printed numbers or a button that changed colour when you clicked it. What you felt wasn’t really about the output. You’d had an idea, written it in a language the machine understood, and the machine had listened. For a lot of us, that was the moment we fell in love.

I’ve been thinking about that feeling a lot lately. I’m not sure the next generation of builders will know it the way we did. And the machines that are changing this owe their existence to exactly that feeling.

We get there faster now

AI has made software development remarkably easy. You describe what you want, and working code appears. You describe a bug, and the fix arrives with an explanation. Features that once took a week now take an afternoon, and prototypes that took an afternoon now take a coffee break.

That’s real progress, and I won’t pretend otherwise. I use these tools every day. But lately I’ve noticed a quiet loss underneath all that speed, and I want to name it before it becomes too ordinary to notice.

I worry that we may never again see the kind of elegance that gave us React, Vue, or Angular, or paradigms like object-oriented and functional programming. The reason isn’t that we’ve run out of clever people. It’s that the pressure that produced those ideas is fading.

Poetry, written in engineering

Think about what those abstractions really were.

Object-oriented programming asked a beautifully human question: what if code were organised the way we understand the world, as things with properties and behaviours? A Car has wheels and can drive(). A Dog is an Animal and can bark(). For the first time, a program could read like a description of reality.

Functional programming went the other way. It said to forget the objects and the changing state, and treat everything as transformation. Data flows in, gets mapped, filtered and reduced, and flows out, untouched and pure. The first time you rewrote a messy twenty-line loop as a single elegant chain of functions, you felt like a mathematician who had just found a shorter proof.

React gave us one sentence that rearranged how a whole industry thought: UI is a function of state. You didn’t just learn React. You had to change your mind to learn it.

Then there were the smaller mercies. Flexbox finally ended our long, humiliating war with centering a div. Tailwind looked ugly at first, until one day it clicked and you realised it had quietly dissolved an entire category of problems.

None of these were just tools. Each was an argument about how to think, and each one was beautiful in its own way.

The beauty came from the struggle

That elegance wasn’t an accident. It came from friction.

Someone got tired enough of tangled code to invent a better way to organise it. Someone spent years wrestling with UIs that fell out of sync with their data until they saw the answer. The abstractions were beautiful because the people who made them had been deep in the mud first. Pain was the soil, and elegance grew out of it.

When a machine absorbs the friction for us, it also absorbs the reason to invent. If you never feel the ache of repeating yourself, you never dream up the abstraction that removes it.

The strange loop

Here’s a thought I can’t shake. Imagine large language models had arrived twenty years earlier, around 2006, instead of in the 2020s. Set aside the fact that the hardware and data didn’t exist yet; this is a thought experiment.

The web back then ran on jQuery spaghetti, table layouts, PHP tangled into HTML, and CSS float hacks held together with prayers. An AI trained on that world would have become perfectly fluent in it. It would have generated more of it, faster and at scale, forever. Nobody would have hit the wall of pain that led someone at Facebook to rethink the UI from first principles, because the model would have patched every mess before it became unbearable. There would have been no React, no Flexbox, no Tailwind. We would have frozen the craft at that moment in history, with a Concorde endlessly flying the same old route.

Now flip it. The reason these models can write good code at all is that elegant abstractions came first. They learned from millions of programs written in clean, consistent patterns: components with the same shape, functions named for what they do, classes that mirror the real world. Structure is what makes something learnable, for machines just as much as for children. Go one level deeper and it’s abstractions all the way down. The models themselves were built in Python, a language designed to be read by humans, using NumPy arrays and PyTorch layers that hide the GPU’s complexity behind a clean interface. The transformer is written in the language of the very craft it now automates.

That’s the recursion. The elegance produced the model, and the model may make the elegance unnecessary: a child that renders its parent obsolete. Every programmer knows that recursion without a base case never ends; it just keeps calling itself until the stack overflows. If future models learn mostly from code that earlier models wrote, where does the next genuinely new idea come from? For decades, the base case was a human being who felt the pain, stepped back, and imagined something better. The real question isn’t whether AI can write code. It’s whether we keep supplying the base case.

Concorde and the Glacier Express

There’s an image I keep returning to.

Concorde could carry you from London to New York in about three and a half hours. It was a masterpiece of engineering: sleek, supersonic, and almost impossibly fast. From the window you saw mostly deep blue sky and a thin curve of horizon, because at twice the speed of sound the world below dissolves.

The Glacier Express in Switzerland takes around eight hours to travel between Zermatt and St. Moritz, and it’s sometimes called the slowest express train in the world. Nobody boards it to save time. They board it for the viaducts suspended over gorges, the villages tucked into valleys, and the moment the train curls around a mountain and the whole landscape rearranges itself in front of you.

Both get you where you’re going, but only one lets you see where you’ve been.

AI-assisted development is our Concorde, and it is extraordinary. But when we go straight from idea to working code, we skip the valleys. We never see the moment recursion finally makes sense, the afternoon a closure clicks, or the evening you refactor something ugly into something clean and just sit there looking at it.

So what do we do?

The answer isn’t to reject the jet. Nobody is going back to hand-writing assembly on principle, and they shouldn’t.

The answer is to remember that the train still runs, and that the people on it matter more than ever. The builders who take the scenic route are the ones who feel the friction, notice what’s broken, and imagine the next abstraction. They are the base case. Maybe the next great ideas will even be designed with AI as one of their readers. They’ll still need a human who understood the old ones deeply enough to see beyond them.

So build something by hand simply to understand it. Read the source of a framework you love and admire how it was put together. Teach young people the slow way first, not out of nostalgia, but because the view is where understanding comes from. And understanding is what lets you judge whether the fast answer is actually right.

To everyone who ever fell in love with the craft: that love wasn’t inefficiency. It was the base case the machines were built on, and it still is.