Still Human Here

I am starting a blog again. I have tried this many times over the years and it never stuck, so the real question is not how I will do it but why I am bothering at all. The answer has everything to do with what is happening to the internet right now, so let me start there.

## Why blog in the 2026 AI era

Let me start with an analogy from the show Pluribus [ref:pluribus].

[video:https://www.youtube.com/watch?v=a6lzvWby9UE|Pluribus Trailer]

In Pluribus, an alien signal turns almost all of humanity into a single shared mind. A handful of people stay immune, and the collective spends the whole show trying to pull them in. The way I read it, the collective does not really want their bodies. It wants what is inside them: their memories, their craft, everything they have learned and made. Without that input, it has nothing new.

That is exactly what large language models (#LLM) looked like to me.

We train LLMs on human history. On what we made before, what we figured out before, what we wrote down. At its core this is a producer and consumer problem [ref:producer-consumer]. If you have ever written concurrent code, you know that problem by name. One side makes items, the other side uses them, and the whole thing stalls the moment the producer goes quiet. We have been producing since the invention of writing. The models are now consuming all of it at once. Some researchers argue we are already near the ceiling, that the supply of high-quality human text is close to exhausted. They call it peak data [ref:peak-data], by analogy with peak oil.

But there is a second half to this, and it worried me more. Since the AI wave hit, the internet has started to feel dead. That is the dead internet theory [ref:dead-internet] more and more of what you read was written by a bot, not a person. It used to be a conspiracy theory. Now it reads like a traffic report.

Put the two halves together and you get a real chicken and egg problem. The models need fresh human writing to learn from, but the flood of model output is pushing human writing out of the very spaces it gets collected from. If we stop producing, the models run out of anything new. And if the empty space fills with bot text instead, the models start training on their own reflection.

What happens next already has a name. Researchers call it model collapse [ref:model-collapse]. When you train a model mostly on the output of other models, errors pile up across generations. The model first forgets the rare and unusual cases, the tails of the distribution, and then it slowly converges on a bland average of itself. The usual comparison is a photocopy of a photocopy. Each pass looks fine on its own, but after enough rounds the detail is gone. Some people call the inbred version of this Habsburg AI [ref:habsburg-ai].

An older analogy fits even better. Steel forged before the first nuclear tests is called low-background steel [ref:low-background-steel]. It is prized for sensitive instruments because everything made after 1945 carries a faint trace of radioactive contamination. People have started saying the same about text: anything written by a human before 2022 is the low-background steel of the internet, and it is not being made anymore. Unless, of course, we keep making it.

So that chicken and egg problem is not just a cute phrase. The models need real human input to stay sharp. If we all go quiet and let the bots fill the space, there is less and less that is real to learn from, and the whole loop slowly eats itself.

That is my reason. I want to keep producing. I want to write down what I learn, in my own words, as a real person. Not to feed the machine, and not to fight it either, but to keep adding something real to the pile.

And it works in the other direction too. The people who push their heads past the dead surface, the ones still curious enough to look for something real, need something to find on the other side. This is the quiet promise of the small web [ref:small-web] and the indieweb personal sites, written by actual people, linked to each other instead of ranked by an algorithm. If everyone goes quiet, the traveler in the engraving below pushes through the edge of the sky and finds nothing but more of the machine. I would rather be part of what is actually back there.

![Flammarion Engraving](/images/flammarion.webp)

My last reason has nothing to do with AI at all. Writing is how I think. Explaining something forces me to find the holes in my own understanding, the same way teaching does. Even if no model ever scrapes this and no human ever reads it, the act of writing it down would still pay for itself.

So the why is settled. But a reason has never been my problem. I have had reasons since 2005, and a trail of dead blogs to show for them. Before I promise that this time is different, let me show you the bodies.

## My Journey

Every attempt followed the same pattern: instead of writing, I built the thing I would write on. First came [[hblog]], then its rewrite [[hblog-django]], and each time the story was identical. The platform was always one refactor away from perfect, the tooling kept handing me a more interesting problem than the writing, and the drafts folder stayed empty. Twenty years of that taught me the lesson the hard way: the bottleneck was never the tool, it was my attention. Which brings me to the third name in the lineage, and the reason it might finally break the pattern.

## Meet the hblog-ng

[[hblog-ng]] is built around one design goal: get the system out of the way of the writing.

It is a knowledge-graph blog, or what some people call a digital garden [ref:digital-garden]. It takes an #obsidian vault of #markdown notes and turns it into a statically generated site. The notes link to each other, so the links between ideas become the structure of the site instead of a flat list of posts by date. Notes are allowed to be unfinished and to grow over time, which removes the other classic excuse: waiting for a thought to be "done" before publishing it.

Under the hood it leans on a few tools that usually do not sit together: #latex for clean math and typesetting, #nextjs for the static build and the rendered site, and #mermaid for diagrams. The diagrams are written as plain text right inside the notes, so a drawing like the pipeline below lives next to the words that describe it and gets versioned with everything else.

The point of this setup is to remove the excuse. Writing happens in plain notes, in a tool I already live in, and the site builds itself from those notes. There is nothing left to tinker with between me and the publish button, which, if the past twenty years taught me anything, is the only architecture decision that ever mattered.