From article to podcast without a microphone

We wanted to know one thing: can an article become a conversation without a human sitting down at a microphone?

It can. But the interesting part isn't the audio — it's what has to be in place before the audio, and what we learned about our own system along the way.

The chain has five links, and only one of them is a person

1. The text is written and lives in the CMS. Not in code, not in a document on somebody's laptop. Every article is a real document with fields you can search and edit without a deploy. That sounds like a detail. It's the precondition for everything else: if the machine can't find the text, it can't use it.

2. Publishing fires a signal. The moment a page goes live, the CMS sends word onward — signed, so the receiver can tell it came from us. We deliberately made it a per-site opt-in: broberg.ai has it switched on, other sites don't inherit it.

3. The page lands in our knowledge base. Twenty seconds later the finished page is fetched — not the raw text, but the page as a reader sees it — stripped down and uploaded to Trail, our shared memory. The delay isn't sloppiness: an article import publishes in bursts, and the page has to be fetched after the content has finished being written. A system that fetches too early stores something half-made.

4. The podcast engine writes a script. It reads the article and turns it into a conversation between two hosts. Here sits the most important design decision: the script is a document, not an intermediate value. A script that goes straight into the studio is an episode nobody has read. As a document it can be opened, corrected and approved — and it doubles as the subtitles, it's searchable, and it can be read by someone who doesn't want to listen.

5. Then it becomes audio. Two voices, one track, one file.

The one human link

Step four ends in an approval, and it isn't a courtesy. Recording is the only action in the entire system that spends real money every time it runs — roughly five kroner per episode. So the gate sits on the server, not in the browser: a checkbox in an interface is an agreement, a gate in the code is a rule. Try to record a script nobody approved, and you get a refusal and an explanation.

For the same reason an editor can write and approve scripts but cannot press record. That's a separate permission. Someone allowed to fix a sentence isn't automatically someone allowed to spend the company's money.

And if you edit the text afterwards, the approval withdraws itself. Not as something to remember — that's what makes it a gate rather than an intention.

The hosts live in the CMS, not in the code

Aidan explains. Airina asks on the listener's behalf. How they do it — how cheerful, how interrupting, whether they're allowed to laugh — sits as ordinary text in the CMS. We can change the tone of the whole series by editing three fields, without shipping code.

That turned out to be more than a convenience. The first version of the podcast was correct and a little dull. We rewrote the three fields, asked that the hosts be allowed to laugh where there was something to laugh at, and got a conversation where they interrupt each other. Same article, same voices, same price. Only the tone was new.

What the chain found out about us

Here's the honest part.

The first time the whole flow was run end to end — article to published episode — it surfaced five bugs that 1,625 automated tests had never seen. Every test was green the whole way.

Two are worth knowing, because they share a shape:

• The audio provider wasn't wired up at all. Recording could never have worked — not even with a valid key. It would have been discovered the day somebody pressed the button.
• The file's address pointed at nothing. The audio was made, paid for, written to disk, and the price recorded. Everything looked finished. And the one field a listener actually needs returned a 404.

It's the same failure shape both times, and it's the one we watch for hardest in everything we build: the green direction is the silent direction. A system that's missing something and a system that's fine look identical from the outside. That's why we run the chain end to end instead of settling for testing the parts. The parts were fine. The chain wasn't.

What it costs

A five-and-a-half-minute episode costs about five kroner in audio — roughly one krone per minute. The script costs fractions of an øre. The price can be read before you press, not after, and the system also stores what it actually cost, so the question can be answered a month later.

There's a pre-flight checklist: is there a script, are both voices chosen, do they answer at the provider, and has the text been approved. One item is worth highlighting, because it says something about how we build: if nobody has looked the voices up yet, that item counts as not OK. A check that quietly passes because nobody asked is worse than no check — it looks green.

So what is this, really?

It's an experiment, and we say so out loud. The podcast exists to show what AI and automation are good for when you hold them to real requirements: genuine content, traceability back to the source, a price you can see in advance, and a human who says yes before the money is spent.

But the content isn't an exercise. It's our own products, our own customers and our own opinions. The hosts are AI agents, and they don't make things up to make it sound good.

Episode one is about what you've just read.