Whatible Studio

What it is

Whatible Studio is a private factory for YouTube videos. You give it a topic; it writes the episode, narrates it, times a set of hand-drawn frames to the narration, assembles a 16:9 video and a captioned 9:16 short, builds thumbnails, and hands you the title options, description and tags ready to paste. A small local control panel runs the whole thing and tracks the state of every episode across every channel.

It currently drives three channels and around forty episodes. One of them, Meeply Moply, actually works — views, subscribers, likes, comments. Getting there cost me three abandoned engines, one dead channel and about four months, which is most of what this case study is about.

The problem

I wanted to publish two to four videos a week. The blocker was never the idea — ideas are cheap and I can generate them faster than I can use them. The blocker was that editing one video took me between two and six hours in DaVinci Resolve, and almost all of it was the same mechanical act: watch the narration, find the moment an image should appear, drag it there, trim, repeat. Half a day of dragging rectangles on a timeline for one upload.

That's not the work I wanted to be doing. I wanted the loop to be have an idea → see the result, not have an idea → spend the evening scrubbing an audio waveform.

Three engines I threw away

First: photoreal, which quietly refuses to hold a story

My first instinct was to avoid the obvious. Doodle-style channels already exist, so I went the other way — photorealistic frames, generated with a Magnific subscription, one image at a time.

The images were genuinely good. The problem showed up only when you put them in sequence: continuity is impossible. The chair changes shape between shots. The face drifts. The room re-decorates itself while the narrator is mid-sentence. Every frame is beautiful and none of them belong to the same story. There's no prompt discipline that fixes this reliably — you're fighting the medium.

Second: pencil sketch, which solved the style and lost on speed

Next attempt: different theme, different look. Hand-drawn pencil, generated with Flux 1.1 through a Leonardo AI subscription. A medieval series — an executioner, an inquisitor, a condemned witch, a samurai. Four finished episodes, around four hundred and fifty frames.

And visually it worked. Pencil on paper holds together in a way photoreal doesn't; the style stays put from frame to frame, which was exactly the thing the previous attempt couldn't do:

What killed it was throughput. The subscription didn't cover what I needed, so I moved generation onto my own laptop — Flux through ComfyUI. The images came out right. They just came out slowly: slowly enough that two to four episodes a week was arithmetic that never closed. I dropped the direction entirely.

That's the failure worth remembering, and it's the one that decided the current stack: the creative problem was solved and the project still died, because the machine couldn't keep pace with the schedule. It's also why the working engine pays for a hosted image model instead of running one at home.

Worth noting what this engine already did: it built me a ready-made DaVinci timeline. Each generation got better and better at handing me the edit — and I was still the one performing it.

Third: a real engine that automated everything except the slow part

So I built an actual pipeline (an engine I called Antennika, then a rebuild for a channel called Packet Zero). It was not a toy: Claude Code wrote the script, edge-tts did the narration with Microsoft's free voices, Remotion rendered animated scenes in React, and Python handled the rest of the plumbing.

Everything moving in the video below — every window, every line of text, every transition — was drawn by code. I didn't touch an editor for any of it:

Later episodes added Rough.js on top of Remotion — a library that renders shapes with a sketchy, hand-drawn stroke. Re-seed it every frame and the lines wobble slightly, so a diagram made of rectangles suddenly feels drawn by a person rather than plotted by a machine:

And yet its own README gives away the flaw, which I didn't see at the time:

"Claude Code generates the script, the voiceover, animated scenes (Remotion) and an edit sheet. Final montage — by hand in DaVinci Resolve."

I had automated the script, the voice, and the visuals — everything except the exact thing that was eating my evenings. The engine handed me a pile of assets and an instruction sheet, and I still sat down to assemble it manually.

And a channel nobody wanted

Packet Zero was a security channel with, I still think, a decent premise: explain how the tools actually think, without teaching anyone to attack anything. Metasploit as a cabinet of ready-made keys for locks that are already known to be weak — not a genius, a clerk; the fix is simply to update. Burp Suite as a table placed between your browser and the site. A VPN as a transfer of trust, not an invisibility cloak. Eleven episodes, plus a second series on how people actually get compromised — phishing, public Wi-Fi, juice jacking.

I uploaded them. After a month: two views.

That number is the most useful thing the project produced. It turns out almost nobody wants to understand how Metasploit reasons; the audience that searches for it wants to know which fields to fill in. I could have kept polishing an engine for an audience that wasn't there. Instead I closed the channel — with zero feedback there is nothing to iterate against — and started over on a different disk.

The bill

Each of those engines cost roughly two weeks to build. The one that finally worked took two weeks to reach a usable MVP, and another four to five weeks to become the thing I actually run. Add it together and it's somewhere between three and four months of building tools before a single video landed on a channel anyone watched.

I'm writing that number down because "I built an AI pipeline" tends to sound like a weekend project. Three attempts, four months, and the first two produced nothing but a better understanding of the problem.

What actually worked

Two changes, made at the same time, and I can't fully separate their effects.

Flat doodles instead of photoreal. Simple line art on white stays consistent from frame to frame, and a fixed character sheet pins the recurring "you" avatar in place. The style I originally avoided as too obvious turned out to be the one that solves the actual engineering problem: continuity. Choosing the crowded lane for a technical reason, not an aesthetic one.

Paying for the parts that carry the video. Free TTS is fine until you listen to fifteen minutes of it. Here is the same pipeline, same doodles, same edit — with the free voice the first engine shipped with, and with the paid one the working channel uses:

Nothing else I changed moved the needle as much as paying for the voice and the images. Everything a viewer judges in the first five seconds sits in those two layers.

The real bottleneck was timing, not assembly

This is the part I'd want another builder to take away, because I had it backwards for months.

Stitching images into a video is trivial. A short Python script does it: here are the frames, here is the audio, encode. That was never the hard problem. The hard problem is making each image appear at the moment the narration is talking about it — and hold there, and cut on the right beat, across fifteen minutes and dozens of frames, without a human sitting in the timeline deciding every cut.

That took weeks. I won't detail the mechanism — it's the one part of this I'd rather not hand over — but here is what it looks like from the outside. One button. The frames drop into their beats, the per-scene counters fill up, and the strip along the bottom goes from red to green as every slot finds its image:

What used to be an evening in DaVinci. Expand it — the detail is in the counters on the left and the strip along the bottom.

That green bar is the whole project. Everything else — the writing, the voice, the images — was solvable with off-the-shelf pieces. This part wasn't, and it's the reason the engine exists at all.

The loop, start to finish

Working on an episode looks like this. You pick a channel and a series, and ask for ideas — or type your own premise in plain language:

It comes back with a batch of premises, each already shaped to the channel's format — a rule people believe, and the truth underneath it:

Pick one, and Claude Code writes the episode against that channel's blueprint:

From there: narration, then the frames, then the button in the clip above, then a 16:9 video, a captioned vertical short, thumbnails, and an info file with three title options, a description and a tag list. What's left for me per video is generating the voice and the images, dropping them into their folders, and pasting the prepared metadata into YouTube. A few minutes of clicking instead of half a day.

How far it is from running itself

Honestly: one step, and it isn't a technical mystery.

The two remaining manual acts — voice and images — are manual only because I'm using ElevenLabs and image generation through their normal interfaces, by hand. Both are available as APIs. Wire those in, add a small "regenerate this frame" control for the images that come out wrong, put the model behind the script generation on an API key too, and then set a scheduler to run the steps in order two or three times a day. At that point nobody needs to press anything.

I haven't done it yet, and I'm being deliberate about saying that plainly: this is a semi-automatic system that could become autonomous, not an autonomous system. The distance between those two things is where most AI-automation claims quietly live.

The result

Here's an episode from Meeply Moply — one of the early ones, made by this pipeline, live on YouTube with its real numbers attached. Modest ones. But views, likes, and an actual comment from an actual person, which is precisely what the previous channel never produced.

Lessons

Automate the part that hurts, not the part that's fun to automate. My first engine automated writing, narration and rendering — the interesting problems — and left the boring six-hour montage to me. It was a well-built machine pointed at the wrong bottleneck. Measure where your evenings actually go before you decide what to build.

Zero feedback is data. Two views in a month isn't a signal to work harder on the engine; it's a signal that the audience doesn't exist. I'm glad I closed Packet Zero early instead of spending another two months making a better machine for nobody.

A solved creative problem can still lose to throughput. The pencil engine looked right and held continuity — and died anyway, because generating those frames locally was too slow to sustain a publishing schedule. Style, quality and speed are separate constraints, and the schedule is the one that quietly decides whether a project survives.

The obvious style was obvious for a reason. I picked photoreal to be different and paid for it in continuity. Doodles weren't the boring choice — they were the choice that made a consistent story physically possible.

Pay for the layer the audience actually perceives. Everything else I could build myself for free. The voice and the images were the two things a viewer judges in the first five seconds, and they were the two things worth spending money on.