I publish a homelab post most days. I don't have a content team, I don't have a
backlog of pre-written drafts, and — this is the part that matters — I don't have
an AI cheerfully inventing things I "did" so it can hit a daily quota.
What I have is a small pipeline that turns work I actually did into posts, with a
strict rule about what the AI is and isn't allowed to do. This post is that
pipeline, explained — and, fittingly, it came through the pipeline itself. Let me
show you the machine, then prove it by telling you how this got made.
The problem with "just get AI to write your blog"
The obvious version of this is a disaster, and it's worth being clear about why.
If you point a language model at "write me a post about my homelab this week," it
will write you a post. It will be fluent, confident, and it will contain things
that never happened — a metric it made up, a feature you didn't ship, a lesson
from a bug you never hit. Not because it's malicious, but because it was asked to
produce content and it has no way to tell the difference between a fact and a
plausible sentence. A model told to fill a daily slot will fill it, truthfully or
not, and you won't be able to see the seam.
So the entire design of my pipeline is built to make that specific failure
impossible. One rule underneath everything:
Scripts gather the facts. The model only ever phrases them.
The clever, non-deterministic part is allowed to write. It is never allowed to
decide what's true. Here's how that splits into stages.
Stage 1 — a deterministic radar finds real topics
Nothing about topic selection touches an AI. A plain script scans the actual
evidence of what I've been doing — commit history across my repos, what changed,
what shipped — and turns it into a list of candidate topics, each with the real
facts attached: the actual commit messages, the actual repo, the actual dates.
This is the crucial move. The list of things worth writing about is derived from
things that demonstrably happened, mechanically, with no model in the loop. If I
did nothing worth writing about this week, the radar says so — and the honest
consequence is fewer posts, not an invented one. A quiet week is allowed to be
quiet.
Stage 2 — the model drafts, from those facts only
Now the AI comes in, and its job is deliberately narrow: take one candidate
topic and its gathered facts, and write it up in my voice. It's handed the real
commit history and told, in effect, "only use this; if a detail isn't here, stay
general rather than inventing a specific."
It's a writer working from a brief, not a journalist making up a story. It phrases,
structures, and finds the through-line — the things models are genuinely good at —
but the raw material is all real, because it was gathered by Stage 1 and handed
over. The model never went looking for a fact, so it never had the chance to
fabricate one.
Stage 3 — two gates before anything is public
A draft is not a post. Between "the model wrote something" and "the world sees it"
there are two hard gates:
- An automated leak gate. The draft is scanned for anything that should never be public — real IP addresses, hostnames, secrets, personal details. Anything that trips it gets quarantined, not published. This is a machine check, not a judgment call.
- A human gate. I read it. A draft lands in a review folder, and it only enters the publish queue when I approve it. This is the one step I refuse to automate, because a structural check can catch a leaked IP but it can't catch a subtly overstated claim. A ten-second read by the person whose name is on it can.
Only after both gates does a draft join the queue.
Stage 4 — a boring publisher ships one a day
The publishing itself is the dumbest part on purpose. A scheduled job wakes up
once a day, takes the next approved post from the queue, publishes it, and moves
on. If a publish fails, the post stays in the queue and tries again tomorrow — it
never double-posts, and it never publishes something that isn't there. If the queue
is empty, it does nothing.
That "does nothing" is a feature. The whole system fails toward silence, never
toward fabrication. The worst case is that I post less often. The worst case is
not that a robot invents a week of accomplishments to keep the streak alive.
The ethics bit, because it matters
Every post this produces carries a visible line saying it was drafted with AI
assistance from my own notes and then reviewed before publishing. I'm not going to
pretend a human typed every word — that would be its own kind of lie. What I can
honestly claim is that every fact is real, gathered mechanically, and that a
human read it before it went out. "AI-assisted, human-verified, honestly labelled"
is a position I can defend. "Secretly generated, possibly fabricated, passed off as
hand-written" is not, and the pipeline is designed so I never drift into the second
one by accident.
Proof: how this exact post was made
Fitting, given the subject:
- The radar flagged that I'd been building a content pipeline — from the real commits, not from a prompt.
- The model drafted it from those facts, in my voice.
- It passed the leak gate (no infrastructure details leaked — you'll notice I've named no IPs, no hostnames, no specific tools).
- I read it, edited the bits that were slightly off, and approved it.
- The daily publisher put it live, with its AI-assistance line at the bottom.
The system documents the system. That's either delightfully recursive or slightly
cursed, and honestly it's both.
What to steal
You don't need my code. The shape is the point:
- Gather facts with a script; let the model only phrase them. The single most important line in the whole design. It's the difference between a writing assistant and a fabrication machine.
- Derive topics from things that provably happened, so you can't write about work you didn't do.
- Two gates: a machine one for leaks, a human one for judgment. Automate the check a computer does better; keep the check a person does better.
- Fail toward silence. An empty queue posts nothing. Never build a system whose failure mode is inventing content to avoid a gap.
- Label it honestly. AI-assisted and proud of it beats secretly-generated and exposed.
The reason I can post most days isn't that I found a robot that writes my blog. It's
that I built a machine that turns my real work into drafts, keeps the AI on a very
short leash, and lets me stay the editor. The cleverness writes. I still decide
what's true. That division is the whole thing.
Written by the pipeline it describes, reviewed by the human it describes, and
posted by the boring scheduler it describes. Turtles all the way down.
🤖 Drafted with AI assistance from my own homelab notes, logs and repos, then reviewed and edited before publishing.
Top comments (1)
Some comments may only be visible to logged-in visitors. Sign in to view all comments.