From zero to an AI YouTube channel in fourteen steps (HyperFrames + Shortflow)

I've launched, on average, a new AI channel every two months for eighteen months. Eight active channels to date, each one born from the same starter sequence, slightly refined each round. What follows is that path in its current state, condensed into fourteen ordered steps.

The objective isn't to give you a generic recipe. The objective is to spare you the sequencing mistakes I made launching Cocorico Histoire in November 2025, and have since avoided across the seven channels that followed. The learning curve between one channel and the next is largely a question of knowing in which order to do things.

Count around two full days of effective work between the decision to launch and the first episode shipped. Not an hour, not a week — two days, assuming you have all the technical prerequisites (Claude Code, Python, FFmpeg, HyperFrames, existing platform accounts).

Phase 1 — Definition (four steps, around four hours)

Step 1 — Pick a channel concept in one sentence

An AI channel holds if its concept fits in a sentence of fewer than fifteen words. "Why does this everyday object exist" for WhyFactory. "One French history story per episode, sixty seconds" for Cocorico. "r/nosleep posts narrated slowly" for Reddit Horror. If you can't write it as one sentence, it's not a concept, it's still an idea.

The simple test: have three close friends read your sentence. If all three reformulate it roughly the same way, the concept holds. If each understands it differently, you have precision work to finish.

Step 2 — Write the editorial document

A thousand to fifteen hundred words covering: narrator posture, the five voice mechanisms (synchronous discovery, asserted opinions, facts-as-twists, viewer anticipation, woven CTA), positive and negative examples, and red flags. This is the step everyone wants to skip; it's also the one whose absence determines whether the channel holds or not. I covered this in detail in the editorial-voice post.

Count two hours to produce a usable doc. It's less a text than a validation tool: every future writing session will see you returning to it to settle a question.

Step 3 — Build the prioritized backlog

Twenty subjects minimum, ordered by banger-factor — your intuition of which will land best first. For WhyFactory, my initial backlog contained "why the keyboard is AZERTY", "why the snooze button is nine minutes", "why Pringles have their tube", etc. Twenty entries guarantee you won't run dry on episode four.

Minimum format per entry: title, proposed hook, verified factual source (English Wikipedia is often better than the local-language version), banger-factor badge from one to three stars. Notion or a Markdown file versioned in the channel repo — doesn't matter.

Step 4 — Lock the visual identity

A signature color, a typography, a wordmark, a captions grid, and ideally a simple mark (a graphic sign that reads at thumbnail size). No need for a professional designer — a Sunday afternoon on Figma is enough for an experimental channel. The goal isn't aesthetic perfection; it's consistency over time. WhyFactory: background #0A0A0F, cyan signature #00E5FF, yellow captions #FFD60A, wordmark WHY cyan + FACTORY cream at font-weight 900.

Phase 2 — Infrastructure (five steps, around three hours)

Step 5 — Scaffold the HyperFrames project

One command:

npx hyperframes init <channel-slug>

The interactive wizard asks two questions: size (1080×1920 for Shorts), default duration (60 s). The scaffold produces a complete structure: index.html, scripts/ folder, episodes/ folder, renders/ folder. Twenty minutes to walk through the skeleton and understand where each thing lives.

Step 6 — Fork a script generator

If you start from zero, copy the Python generator from an existing channel (my eight channels share ~90% of the same code) and adapt it. If you genuinely start from zero, begin by implementing: (a) reading the config JSON, (b) the hash-cached TTS call, (c) Whisper transcription + forced-align, (d) Pexels B-roll selection, (e) the FFmpeg mix, (f) the npx hyperframes render call. A full day for a developer, two to three for a creator without technical background.

Step 7 — Configure the TTS voices

For the channel, pick one voice per tier: Kokoro for iteration, F5 local for validation, ElevenLabs for production. On ElevenLabs, run a blind A/B on three candidate voices before locking production. My pick for FR: Liam (fr-quiz-host). This decision is almost irreversible — changing voice after ten episodes forces you to rebuild the sound expectation regular viewers have already settled into. Choose carefully.

Step 8 — Connect the six social platforms

Create the channel's account on each if it doesn't already exist (YouTube, TikTok, Instagram Business/Creator, Facebook Page, Threads, LinkedIn). Consistent profile: same avatar, same name, same short bio. Then in the Shortflow dashboard, OAuth each platform. Count five to ten minutes per platform — one hour for the six.

Step 9 — Connect the Shortflow MCP server to Claude Code

One command in the channel repo's terminal:

claude mcp add shortflow https://api.shortflow.leandre.io/mcp \
  --transport http \
  --scope local \
  --header "Authorization: Bearer sk_live_your_key"

Five minutes cumulated, including the API key creation in the dashboard. By the end, Claude Code can pilot publication. This step is short enough that there's no reason to defer it — better to have it from the start so the whole episode 01 can go through the MCP sequence.

Phase 3 — First episode (five steps, around six hours)

Step 10 — Write the episode 01 script

The pilot. Pick the highest banger-factor subject in the backlog. Write the script by hand, segment by segment, reading aloud after every rewrite. Four to five hundred spoken words for sixty seconds. Two cascading twists in the first eight seconds. Refer mandatorily to the editorial doc at every doubt.

Count two hours to produce an acceptable locked script. I've often done it in an hour under pressure; the result always shows.

Step 11 — Render the voice through three tiers

Run the full pipeline: Kokoro to verify the rhythm holds, F5 local for prosody, ElevenLabs for production. At this stage, you'll likely discover two or three things to adjust in the script — a word that pronounces poorly, a comma that creates too long a caesura, a proper noun the voice cuts in two. Fix them, re-render only the offending segment (the hash cache preserves the rest).

Count one hour of full cycle on a sixty-second script.

Step 12 — Validate the montage and render the MP4

Launch npx hyperframes preview to open the studio in the browser. Verify captions are synced, B-roll cuts cleanly, the vignette is legible. One or two minor corrections are normal on a first episode — a B-roll that doesn't fit, a transition effect mis-calibrated.

Once validated, npx hyperframes render. Three to five minutes of compute. The final MP4 lands in renders/.

Step 13 — Publish via Claude Code and MCP

Open Claude Code in the project's terminal and run the five-prompt MCP sequence described in the Shortflow + Claude tutorial. The six platforms receive the publication, scheduled with strategic time staggering to avoid cannibalization.

At this stage, your first episode is staged on six platforms, ready to fire at the times you picked. Twenty minutes total, the bulk being the per-platform caption writing (see the cross-publication playbook).

Step 14 — Lock the publication calendar for the next episodes

Before episode 01 actually ships, set the cadence for the next six. If your target rhythm is three episodes per week, schedule episodes 02 to 07 in the backlog, with their subjects and publication dates. This preventive discipline avoids the classic trap: ship episode 01, wait for the reaction, lose two weeks debating what comes next.

My personal protocol: cadence is locked before episode 01 publishes. Episode 01's numbers may eventually shift the cadence at episode 08 or 09, never at the first seven. This discipline kills the costliest procrastination — the one where you wait for feedback before continuing to produce.

The recap table

| # | Step | Phase | Duration | |---|---|---|---| | 1 | Concept in one sentence | Definition | 30 min | | 2 | Editorial document | Definition | 2 h | | 3 | Prioritized backlog | Definition | 1 h | | 4 | Visual identity | Definition | 30 min | | 5 | HyperFrames scaffolding | Infrastructure | 30 min | | 6 | Python generator | Infrastructure | 1-2 h | | 7 | TTS configuration | Infrastructure | 30 min | | 8 | Social accounts + OAuth | Infrastructure | 1 h | | 9 | Shortflow MCP on Claude Code | Infrastructure | 5 min | | 10 | Episode 01 script | First episode | 2 h | | 11 | Three-tier voice | First episode | 1 h | | 12 | Montage and render | First episode | 1 h | | 13 | MCP publication | First episode | 20 min | | 14 | Next-episode calendar | First episode | 30 min | | Total | | | ~13 h |

Thirteen effective hours, spread across two days to preserve the quality of every decision. Running the sequence in one day is possible but discouraged — the second half's fatigue contaminates the pilot episode's quality, and that one carries a disproportionate weight on the channel's future trajectory.

The sequencing mistake I see most often

Creators who botch their launch almost always make the same mistake: they start at step 5 (HyperFrames scaffolding or equivalent technical setup), because it's comfortable and tangible. They defer steps 1 through 4 (definition), because they're uncomfortable and abstract.

The result is predictable. At step 10, they discover they haven't calibrated the editorial voice, they haven't locked the visual identity, and their backlog fits in three lines. They produce an episode 01 that's technically acceptable, editorially mediocre. And the channel dies between episode 04 and episode 08, because the definition phase was never done and doubt sets in.

The order of steps isn't negotiable. Definition first, infrastructure second, first episode last. Inverting that sequence is building a house starting with the curtains.

If you're launching your first channel

One last observation that summarizes the rest. The opportunity cost of a channel that dies before episode 10 is very high — you invested thirteen hours in it, you set up six social accounts you'll abandon, you built a technical pipeline that won't run again. The opportunity cost of a channel that holds but starts slowly is very low — you have the tools in place, the backlog is prioritized, production inertia does its work.

This asymmetry should govern every sequencing decision. Don't rush the definition. Don't skip the editorial step. Don't start the code before you have the doc. Thirteen hours well spent in the right order are infinitely more valuable than twenty hours spent in the wrong one.

That's, I think, the one thing that distinguishes an AI channel that holds for two years from a channel that dies at episode 7.

---

For the publication infrastructure layer — the one that makes the six platforms addressable from a single MCP call — that's exactly what Shortflow does. Creating an account opens a seven-day free trial with MCP enabled by default. Plug it in before step 14; you'll save an hour on the path.