Learning to Learn, Again

“I really like what you made. Can you give me one day when you can walk me through it?”

When the Teams message came through from a colleague, I chuckled. Not because the question was strange, but because I’m still not entirely over the fact that I made the thing at all.

Over one weekend, I replatformed my personal website off a WordPress setup I’d been dragging around for more than a decade. Somewhere in the middle of that, I also vibe-coded my first functioning web application.

Neither of those things would be especially remarkable for an actual developer. For me, they felt mildly unhinged.

The website migration had been a long time coming. My old site worked, technically, but it leaned on the usual WordPress pile-on: a premium theme, too many plugins, and years of trying to design around the fact that I wasn’t really a coder. I’ve spent more hours than I care to admit trying to squeeze performance out of WordPress with tools like WP Rocket and Perfmatters, forever optimising bloat I didn’t fully understand and couldn’t really control. If you’ve ever lost half a day trying to shave milliseconds off a page load, you know exactly the kind of bullshit I mean.

The new version is built on React and Next.js. It’s simpler, lighter, and no longer held together by a stack of things I installed years ago and quietly prayed I wouldn’t break.

That felt good. Really good.

But it wasn’t the most surprising part of the weekend.

I could imagine a version of my life where I eventually replatformed my website. It would have taken much longer, involved much more frustration, and probably ended with me buried in documentation, swearing at my screen, wondering why I’d done this to myself. But I could at least see the path.

What I couldn’t imagine — not even a little — was ideating and building a functioning web application of my own.

That still feels slightly ridiculous to write.

Or, more accurately: no fucking way.

The app began in Claude Chat. I fed it Ramon Eijkemans’ Utility-writing: add structure to language; not the other way around, and asked it to help me build a tool based on his five-point usefulness check. Somewhere in that back-and-forth, Lexi was born: a machine-citability audit tool for informational web content.

I say “was born” as if it arrived cleanly. It absolutely did not. It took an entire weekend, multiple iterations, a few pivots, a move into an IDE, several exhausted Claude Pro session limits, and another hundred dollars in usage fees. The first MVP was terrible. Some versions lasted minutes before I abandoned them. At one point I was basically paying to discover fresh and innovative ways to break my own idea.

And yet, by the end of the weekend, there it was: a working thing that had not existed before.

That was the part I kept returning to. Not that it was elegant. Not that it was finished. Just that I had moved from “I have an idea” to “this exists in the world” without first becoming fluent in every system involved.

I think that’s what startled me most. I had always assumed learning worked in a more orderly sequence: first vocabulary, then understanding, then maybe — if you’d done your homework properly — the right to make something of your own.

This experience felt backwards.

I started, instead, with taste.

When I first learned photography, I did what most people do at the beginning: I copied. I copied framing, lighting, composition, editing styles. I found work I admired and tried, usually badly at first, to recreate some version of what I was seeing. None of it was original. But it taught me something important: you often know what you like long before you know how to make it.

Apparently, in 2026, I still learn the same way.

For years, I’ve used Tony McCreath’s Structured Data Viewer to visualise schema markup. I knew, instinctively, that it was close to how I wanted ContentGraph to look. But I had no idea how to describe that in terms a machine could use. I tried screenshots. I tried my own words. I kept circling the thing I meant without being able to name it, which is its own special kind of hell.

It wasn’t until I dumped the page source of Classy Schema into Claude that I learned the phrase I’d been reaching for: an interactive D3 force-directed graph.

A sentence I did not expect to type in this lifetime, let alone understand.

There was another layer to this, too. ContentGraph wasn’t some random second project I pulled out of thin air. It grew out of a sentence Jarno van Driel said to me more than a year ago that lodged itself in my brain and refused to leave.

I’d been wrestling with schema markup and what I wanted it to do for SEO when he said, very calmly, “Now you know how to structure information across pages.”

At the time, I nodded along in the way you do when you know something is smart but haven’t fully caught up to it yet.

It only clicked later, when I realised schema markup itself wasn’t actually going to do the thing I wanted it to do. That was the unlock. The value wasn’t in the markup alone. It was in the mental model underneath it.

Suddenly, Jarno’s words made sense. And once they did, ContentGraph was born.

What stayed with me about that moment was how familiar it felt. Jarno had already given me the words a year earlier. I just wasn’t ready to use them yet. In one case, I had the instinct before the vocabulary. In the other, I had the vocabulary before the understanding. Either way, the learning was delayed, messy, and only really became clear through making.

Copying came first. Vocabulary came later. Understanding followed after that.

The early versions of Lexi were stitched together from patterns that already existed elsewhere. The code was shaped by examples, conventions, and structures I borrowed before I fully understood them. Visually, I took cues from tools and interfaces I liked. None of that felt especially pure or original.

But then again, neither did my first attempts at wedding photography.

What was mine, from the beginning, was the impulse behind it: the curiosity, the itch, the reason for making the thing in the first place. That part felt unmistakably mine, even when the rest was held together with duct tape, borrowed patterns, and sheer bloody-mindedness.

I suspect that’s where many people get stuck, especially with tools like this. It’s not that they don’t have ideas. It’s that the blank prompt box has a way of making an idea feel suddenly flimsy. You sit there with access to an almost ridiculous amount of capability and still find yourself hesitating over the first sentence, like an idiot, as though the machine is somehow going to judge you for not knowing the right words.

I understand that feeling.

As a late millennial, working with LLMs still feels a little strange to me. Not in the grand philosophical sense. In the practical sense. The whole thing often feels like standing in front of an unfamiliar instrument and realising that, somehow, noise is now a valid part of learning to play.

You start clumsily. You ask the wrong questions. You get halfway to something useful and then break it. You bump into words you’ve never used before. You begin by copying. You repeat yourself. You iterate. Sometimes you stumble into understanding almost by accident. Sometimes you make an absolute mess. Sometimes the mess is the point.

And then, at some point, you notice that what once felt alien now feels available.

That is what this weekend gave me. Not mastery. Not technical fluency. Not some overnight identity shift where I now wander around pretending to be an engineer.

Something quieter than that.

A new way into learning.

Or maybe not entirely new. Maybe a very old way — imitation, repetition, experimentation — made newly practical by tools that can meet you halfway.

What surprised me wasn’t that AI helped me build something. It was that it gave me a way to learn that felt familiar. I started the way I have always started when I care about something: by following what I admired, by trying to copy what I could not yet explain, by making a mess, by staying with it long enough for the language to catch up.

I’m learning to learn again.

And that may be the most unexpected fucking thing I built all weekend.

Already have an Anthropic API key? That’s all you need to try Lexi or ContentGraph for yourself.

Read Lexi’s documentation · Read ContentGraph’s documentation