Automating a content pipeline: forecast data in, finished weather reels out
Most “content pipelines” are a person doing the same dozen steps every day — pull the data, write the script, record the voiceover, build the graphics, edit, caption, export, upload. It’s the kind of work that’s too fiddly to feel creative and too repetitive to stay interesting.
So I did what you do with any repetitive process: I turned it into a pipeline. This one takes raw weather-forecast data and produces a finished, ready-to-post vertical reel — script, narration, visuals, captions, and the final cut — with no manual steps in the middle. A human only shows up at the end to watch it and click approve.
Here’s one it made:
Forecast numbers went in one end; that came out the other. Nobody wrote the script, recorded the voice, or rendered a single frame by hand.
The pipeline, at a glance
You don’t need the internals to get the shape of it. Forecast data comes in, an LLM reads it and writes a plan, generation stages turn that plan into the pieces of a reel, those pieces get composed into the final video, a human reviews it, and it publishes:
That’s the entire thing. No step is clever on its own — the value is in chaining them so the output of one is the input of the next, and never having to touch the middle.
The plan is a file
The first real step doesn’t generate anything — it decides what the reel should be. An LLM reads the raw forecast for the day — the numbers, the trends, what actually matters — and writes the plan: a small JSON document that lays out the reel scene by scene, in order, with what each beat covers and what the presenter says. Something like:
{
"reel": "wednesday-forecast",
"scenes": [
{ "type": "intro", "vo": "Good morning — here's Wednesday's outlook.", "seconds": 5 },
{ "type": "map", "layer": "temperature", "vo": "A mild start, warming through the afternoon.", "seconds": 12 },
{ "type": "map", "layer": "clouds_rain", "vo": "Showers push in from the west after midday.", "seconds": 12 },
{ "type": "outro", "vo": "Full details on the site. Have a good one.", "seconds": 6 }
]
}Everything downstream is just executing that plan: the generation stage produces the narration and the visuals for each scene, and the compose stage stitches them together in order. The plan is the contract — it’s what makes the middle of the pipeline mechanical, and it’s also the easiest place for a human to make a “small change” without touching a single frame: edit a line in the JSON, re-run.
It all runs locally
Every automated stage runs on my own hardware. No cloud APIs, no per-render bill, no data leaving the box — the analysis, the generation, the rendering, and the final encode all happen on the same machines that run the rest of my cluster. That’s a deliberate constraint: it pins the marginal cost of a reel near zero, so the pipeline can produce as many as I want without a meter running in the background.
The human is the editor, not the producer
The one manual step is the one worth keeping. Before anything publishes, a person watches the finished reel and does one of two things: approve it, or ask for a small change — a wording tweak, a different framing — which sends it back to re-render just that part.
That’s the whole idea of the design. Automation does the repetitive 95% — the parts that are identical every single day. The human keeps the 5% that actually needs judgment: taste, tone, and the final call on whether it’s good enough to go out. Nobody is stuck doing production work, and nothing publishes that a person didn’t sign off on.
Why build it this way
A pipeline like this changes the economics of content. Making one reel by hand and making fifty cost almost the same human time, because the human time is fixed at “watch and approve.” The repetitive work scales with the machine; the judgment stays with the person.
And it isn’t really about weather. Any process where the steps are stable and the volume is high is a candidate: name the blocks, make each one hand off cleanly, automate the boring middle, and leave a human at the gate. The weather reel is just a nice example — because the output is something you can actually watch.
What this means for what you see online
It’s worth sitting with what this actually is. The presenter in that reel is not a person. The voice isn’t a recording. The script wasn’t written by a journalist — an LLM decided what to say from a table of numbers. A machine read a forecast, planned a segment, and produced something that looks exactly like a normal weather bulletin — in minutes, for almost nothing, on a computer in a spare room.
Now multiply that by everyone. The same tools are cheap, local, and improving fast. So a growing share of what shows up in a feed — explainers, news readouts, “person on the street” clips, weather, sports recaps — will be made this way, whether or not anyone says so. And it won’t stay on the fringes: official and mainstream outlets have every incentive to adopt it too, because it turns “produce a segment” into “approve a segment.” Some already run AI anchors and AI-written copy. More will, quietly, because the economics are impossible to ignore.
I don’t think that’s automatically bad — this pipeline exists because the work it replaces is genuinely tedious, and its output is honest forecast data presented clearly. But it moves the important question. It used to be “is this well-produced?” Increasingly it’s “who stood behind this, and what did they actually check?” When anyone can generate a convincing anchor for free, polish stops being a signal of trust — polish is now free. What carries trust is the human at the gate: someone whose name is on it, who watched it, and who is accountable for what it says.
That’s the real reason the approve step here isn’t optional — and why I’d argue it shouldn’t be optional anywhere. The machine can make the reel. It can’t be responsible for it. Keep a person there, not because they’re faster, but because responsibility is the one thing you can’t automate.