I use Claude to write articles about using Claude. Claude converts those articles to HTML, deploys them, and announces them on X. The articles are about the pipeline. The pipeline publishes the articles. I am the human in a content loop whose content is the content loop.

Let me show you how deep it goes, because the post you’re reading right now is the evidence.

It started as a one-line idea in a backlog file. I tightened it in a chat window. A scheduled task picked it up, copy-edited it, wrapped it in the site’s HTML template, updated the index, the sitemap, and the RSS feed, and ran a brand validator to make sure the model didn’t improvise the nav again. Then a sync script — one the model wrote — pushed it to S3 and invalidated the CDN. Then another script posted a five-tweet thread with auto-injected hashtags and a little engagement-bait reply. Then a browser the model drove pasted the whole thing into Medium. Then it wrote a row into a Notion database that the model built about an hour before I asked for this post.

I touched a keyboard maybe twice.

Here’s the part that should bother me more than it does. Every single layer of that pipeline is a thing I would tell a junior engineer to never fully hand off. Don’t auto-deploy without a human gate. Don’t auto-publish to a public feed. Don’t let a script post to your social accounts unattended. Don’t trust a generated brand template. And here I am, having built all of it, watching it run at 8:08 every weekday morning while I drink coffee and feel productive.

The automation works. That’s not the scary part. The scary part is how it fails.

This week the X crosspost reached for the “latest” article and grabbed the wrong one. The script picks the newest post by file modification time, and I’d edited an older post after writing the new one — so by mtime, the old one looked newest. The pipeline didn’t crash. It didn’t throw. It cheerfully prepared a thread for an article I’d published last week, with the right hashtags and a confident little hook, and was one keystroke from announcing it to the world.

The failure mode nobody warns you about: Not the loud crash that pages you at 3am. The quiet, plausible wrong answer. The automation that does exactly what you told it, beautifully, pointed at the wrong thing.

A crash you’d catch. A confident mistake walks right past you, because it looks like success.

So I caught it, pointed the script at the right article by hand, and made a note to fix the sort later. Which is the actual rhythm of this whole operation: the machine moves the bytes, and I stand at the end of the conveyor belt checking that it grabbed the right box. The pipeline is fast. It is not wise. It cannot tell whether the post is any good, whether the joke lands, or whether it just queued up last Tuesday’s article with this Tuesday’s confidence.

The actual job: That gap — between moving the bytes and knowing if they’re the right bytes — is the entire job. The model can write the post, format it, ship it, and announce it. It cannot decide that the post is worth shipping.

People keep saying AI will automate the work. What it actually automates is the mechanical part of the work, which was never the hard part. The hard part was always judgment, and judgment is the one thing I can’t put on a cron schedule. That decision is the 2% I keep, and that 2% turns out to be the whole reason anyone needs me here at all.

I’m aware of how this looks. I built a machine that writes about the machine, and now I’ve used the machine to write about building the machine that writes about the machine. If you’re waiting for me to express concern about the recursion, I regret to inform you the recursion is load-bearing. The blog is the marketing for the consultancy. The consultancy is about helping people build automations like this one. The blog about the automations is itself one of the automations. If this ever collapses into a singularity, I want it on the record that it was my fault and the commit history will prove it.

But it won’t collapse, because there’s a human standing in the loop, and the loop knows it. The whole thing only works because someone who can read the output is watching it go by — catching the wrong-article tweet, noticing when the fonts drift, deciding the joke needs one more pass. Take the human out and you don’t get a singularity. You get a very efficient machine confidently publishing the wrong thing, forever, with great formatting.

Anyway. This post will deploy itself in the morning. I’ll be watching.

Go check your mtime sorts. The machine is only as honest as the timestamp you let it trust.

— linuxlsr