DEV Community: Maksims Gavrilovs

Zero to Autopilot, Part 2: One Line of Text a Published Short, in 7 Stages

Maksims Gavrilovs — Sat, 06 Jun 2026 06:17:19 +0000

Series: Zero to Autopilot — Building a Self-Improving AI Media Channel. Part 2 of 7. Part 1 covered the landscape and my $10 wake-up call. This one is the architecture: how a single line of text becomes an uploaded Short without me ever opening a video editor.

Data status (Part 2): real-now. Code, file layout, and measured costs straight from the repo. No audience metrics — those are sandbagged to Part 7.

⭐ The whole thing is open source: github.com/dasein108/slope-studio. Clone along — there's a zero-API-key smoke test at the bottom.

The mental model: a video is a Makefile

Most "AI video generator" tools are a single monolith — one giant button, one black box, and when scene 14 comes out cursed you get to regenerate all 14. I've shipped enough software to know that's the wrong shape.

So I stole the model from build systems: a video is a directed pipeline of stages, each stage is a pure function from files to files, and the whole thing is idempotent. Re-run a stage, it skips work that's already done. Blow away one artifact, only that stage (and its dependents) rebuild. It's make with a YouTube upload at the end.

Here's the pipeline, top to bottom:

 idea ──► [1 script] ──► 01_script.json        (timed scenes + narration)
            │
            ├──► [2 visuals] ──► 02_visuals/scene_NN.png
            │
            ├──► [2.5 narrate] ─► 05_voice/scenes/*.mp3 + timing.json + captions.srt
            │
            ├──► [3 clips] ────► 03_clips/scene_NN.mp4   (animate the stills)
            │
            ├──► [4 stitch] ───► 04_stitched.mp4         (transitions, no audio)
            │
            ├──► [5 voice] ────► 05_voice/final.mp4      (TTS + music muxed)
            │
            ├──► [6 save] ─────► 06_final.mp4            (platform master)
            │
            └──► [7 publish] ──► YouTube

Every arrow writes a file. Every file lives under one run directory. Which brings us to the most important design decision in the whole project.

Everything is a file under `runs/<id>/`

No database. No hidden state. One run = one directory, and the directory is the state:

runs/lobachevsky/
├── project.json          # the manifest: provider + cost + done-flag per stage
├── 01_script.json        # scenes, narration, title, hashtags
├── 02_visuals/scene_01..15.png
├── 03_clips/scene_NN.mp4
├── 04_stitched.mp4
├── 05_voice/
│   ├── scenes/*.mp3       # per-scene TTS
│   ├── timing.json        # per-scene durations (drives clip lengths)
│   ├── captions.srt
│   └── final.mp4
├── 06_final.mp4          # the master you upload
├── 06_final.json         # SEO title/description/tags
└── 07_publish.json       # the YouTube video id, once live

This sounds almost too simple, but it buys you everything:

Debuggability — something looks off? Open the PNG. Read the JSON. No "inspect the pipeline state" tooling needed; ls and an image viewer are the debugger.
Resumability — kill the process at scene 9, restart, it picks up at scene 9.
Idempotency — stages check for their own output and skip it. Re-running visuals won't re-bill you for 15 images you already have (--force when you actually want to regenerate).
Version control of *artifacts* — every authored video in the repo is a folder you can diff, copy, or hand-edit.

Canonical paths live in exactly one place (studio/paths.py), so no stage ever hardcodes a filename:

def scene_image(d: Path, sid: int) -> Path:
    return visuals_dir(d) / f"scene_{sid:02d}.png"

def master(d: Path) -> Path:
    return d / "06_final.mp4"

Each stage is a CLI subcommand (and they chain)

The pipeline is a Typer app. Every stage is its own subcommand, so you can run the whole thing or surgically poke one stage:

# the whole pipeline, one idea in, one Short out:
studio run "lobachevsky geometry explained in a fun way" --duration 150

# or drive it stage by stage and inspect between steps:
RID=$(studio init "lobachevsky..." --duration 150)
studio script  $RID     # → 01_script.json   (read it! confirm the narration is real)
studio visuals $RID     # → 02_visuals/*.png
studio status  $RID     # render the manifest: what's done, what it cost

The stage order is one list, and run just walks it:

STAGE_ORDER = ["script", "visuals", "narrate", "clips", "stitch", "audio", "voice", "save"]

Adding a stage = write a pure function in stages/, add a subcommand, drop its name in that list. Adding a provider (a new image model, a new TTS) doesn't touch the pipeline at all — more on that next.

The provider contract: every model reports its own cost

Here's the design choice I'm proudest of, because it's what makes the whole rest of the series possible. Every media-producing provider — every LLM, image model, video model, TTS — returns the same dataclass:

@dataclass
class GenResult:
    path: Path | None = None
    cost_usd: float = 0.0     # the REAL cost, computed by the provider
    latency_s: float = 0.0
    provider: str = ""
    note: str = ""

That cost_usd is not an estimate I jotted in a spreadsheet. The Nano Banana provider returns $0.039. The kling provider computes seconds × $0.07. The Ken-Burns animator returns $0.00. So when a stage runs, the manifest records measured cost, not guessed:

class StageRecord(BaseModel):
    done: bool = False
    provider: str = ""
    cost_usd: float = 0.0

class Manifest(BaseModel):
    # ...
    def total_cost_usd(self) -> float:
        return round(sum(s.cost_usd for s in self.stages.values()), 4)

This is the foundation. You can't optimize what you don't measure, and you definitely can't put a budget-aware bandit (Part 6) on top of costs you're guessing at. Every dollar in this series is a real dollar the system reported on itself.

Watching it actually run

Here's the real log from the Lobachevsky run — note each stage announcing its provider and cost as it goes:

» visuals
visuals 15 images via fal-nanobanana  $0.585
» clips
clips 15 clips via fal-i2v  $0.75
» stitch
stitch 15 clips
» voice
voice captions=burn via edge  $0.0
» save
save runs/lobachevsky/06_final.mp4
done lobachevsky  total $1.335

Fifteen stills, fifteen animated clips, narration, captions, muxed and mastered — $1.34, fully automated, from one line of text. (That run used a bit of paid AI video; the all-Ken-Burns version of the same Short is $0.585, and the cheap-tier playbook from Part 1 gets a similar video to six cents. The cost knobs are Part 4.) Here's a frame from the finished thing:

And the data shape underneath each scene — the script stage emits timed scenes the rest of the pipeline consumes:

// 01_script.json (one scene)
{
  "id": 1,
  "start_s": 0, "end_s": 8,
  "narration": "What if everything you were taught about parallel lines was secretly a lie?",
  "visual_prompt": "railroad tracks vanishing toward a glowing question mark, retro poster",
  "on_screen_text": "...a lie?",
  "motion_hint": "slow push-in toward the vanishing point"
}

narration drives the TTS (and therefore the clip length — audio leads, video follows, so nothing ever desyncs). visual_prompt drives the image model. motion_hint drives the free animator. One JSON object, three downstream stages.

Try it yourself (zero API keys, zero dollars)

The repo ships an offline mode so you can watch the whole pipeline run without a single key or cent. Stub providers stand in for the paid ones; everything else is real ffmpeg:

git clone https://github.com/dasein108/slope-studio
cd slope-studio
uv venv && source .venv/bin/activate
uv pip install -e ".[fal]"

# free, offline, end-to-end smoke test:
studio run "how black holes bend time" --duration 12 \
  --script-provider stub --image-provider stub \
  --video-provider kenburns --voice-provider edge

You'll get a real runs/<id>/ folder with a stitched, narrated 06_final.mp4 — built entirely from free local tooling. (Heads up: stub is a wiring generator — it emits placeholder text so you can test the plumbing. Swap in a real LLM key before you spend money on visuals, or you'll lovingly render meaningless filler. Ask me how I know.)

What I'd tell another AI engineer

Takeaway: Resist the monolith. Model your AI pipeline as stages of pure file-to-file functions over a single run directory, make each one an independently runnable command, and give every provider a uniform result type that reports its own cost. You get free debuggability (ls is your inspector), free resumability, free idempotency, and — crucially — a measured cost ledger that everything smarter you build later (budgets, auto-strategies, bandits) gets to stand on. Boring architecture is a feature.

Next — Part 3: Free Motion. The fun part. AI video is $0.07/second; I'm going to take a single still image and give it real motion — drift, parallax with subject inpainting, kinetic type, atmospheric rain and embers — for $0.00, with a deep dive into the ffmpeg filtergraphs and the indie-game-dev tricks behind them. (Spoiler: it's all already running in the live effects gallery.)

▶ Live effects gallery: dasein108.github.io/slope-studio
⭐ Star the repo to follow along: github.com/dasein108/slope-studio
🔔 Subscribe to the channel to watch the experiment grow from zero: the Lobachevsky Short

Zero to Autopilot, Part 1: I Built an AI That Runs a YouTube Channel (the landscape, and my $10 wake-up call)

Maksims Gavrilovs — Fri, 05 Jun 2026 14:59:45 +0000

Series: Zero to Autopilot — Building a Self-Improving AI Media Channel. Part 1 of 7. I'm an AI engineer and this is the full build log of an autonomous AI short-video channel — one that writes, renders, publishes, and decides what to make next, then grades its own homework. No face, no film crew, no me clicking "upload" at midnight.

Data status (Part 1): real-now. Everything below is code, costs, and public facts I can verify today. The juicy audience metrics from my own channel are sandbagged until Part 7, so they have time to become real instead of noise.

The two-billion-view problem

Late 2025, a channel called Bandar Apna Dost crossed ~2 billion views and an estimated $4.25M/year (~₹38 crore). Its content? Short AI clips of a monkey and a Hulk-ish dude. No dialogue. No plot. No discernible reason to exist. (techlusive, Business Standard)

Cue every dev's reaction: "...I have a GPU and zero shame, how hard can this be?"

Pretty hard, actually — because here's the part the get-rich-quick threads leave out. A few months later YouTube's "AI slop" crackdown nuked an estimated 4.7 billion views across 16 channels, ~35M subs, and nearly $10M in revenue. Among the bodies: Three Minute Wisdom, a ~1.7M-sub / ~2B-view faceless AI channel, most of its catalog vaporized. (OutlierKit, Miraflow)

So the lay of the land in mid-2026:

Faceless AI video is a real, monetizable category. Billions of views, real revenue, nobody's face required.
It's also a ban speedrun if you ship slop. The platforms are now actively rm -rf-ing low-effort content at scale.

I looked at that and saw a clean engineering problem with two non-negotiable constraints: don't make slop, and don't go broke making it. This series is me brute-forcing both.

Why "faceless" is catnip for an engineer

Faceless means narration + visuals do all the work. No on-camera talent, no lighting rig, no "can you do Tuesday?" Every input is a file that an LLM or a model can spit out. Which means the whole thing is programmable — and anything programmable can be measured, costed, and (eventually) left to run while you sleep.

The winning recipe is boringly well-documented: pick a niche, nail a 2-second hook, stay on-brand, keep people watching to the end, and build a deep library so the algorithm has something to binge-feed. Notice what's not on that list: a human, per video. That's a system, not a craft.

The channels getting deleted skipped the system and cranked the volume knob to 11. The survivors — and the non-AI GOATs like Kurzgesagt and CrashCourse — win on structure, pacing, and actually having a point. My bet: an engineer can clear that quality bar and the volume bar if each video is cheap enough to run hundreds of experiments, with a learning loop deciding which ones to rerun.

Exhibit A: my first video quietly ate $10

Here's video #1, live on the channel — Lobachevsky, the guy who broke geometry:

🎬 The heretic who broke geometry → youtube.com/shorts/gaR76MiAK0U

I did the rookie thing: reached for AI image-to-video on every single scene, because that's what the shiny demos show. It looked great. Then I checked the bill.

Ten dollars. One Short.

The villain is one line of arithmetic — hosted AI video is priced per second, not per clip:

# studio/providers/video.py — real per-second prices (verified on fal.ai, June 2026)
FAL_MODELS = {
    "kling":    {"per_s": 0.07},   # 150s Short ≈ $10.50   <-- oof
    "ltx":      {"per_s": 0.04},   # cheapest hosted i2v
    "seedance": {"per_s": 0.30},   # 150s ≈ $45 (lol no)
    "hailuo":   {"per_s": 0.045},
    "wan":      {"per_s": 0.16},
}

150 seconds × $0.07 = $10.50, no matter how you slice the clips. Now do the napkin math on a content strategy: at ~$10/video, a hundred experiments is a thousand bucks, and you cannot run a "post a lot and learn" loop you can't afford to repeat. The economics were quietly DOA.

Plot twist: I'd solved this before, in a past life

Before AI ate my career, I shipped indie games. And indie game dev is a master class in faking expensive things for free, because you've got a $0 art budget and a build due Saturday. You don't buy motion — you engineer the feeling of motion: parallax scrolling layers, drifting backgrounds, snappy cuts, a little camera push. Cheap tricks, real game-feel.

Same energy, new domain. Why pay $10.50 for AI video when I can take one still image and add:

drift / Ken-Burns — slow pan + zoom, the still breathes;
parallax — split the frame into depth planes and slide them at different speeds (the background literally drifts behind a static subject);
cuts & transitions — rhythm beats AI motion for retention anyway.

All in ffmpeg. All free. That's the entire Part 3 of this series, and it's where most of the $10 goes to die. Spoiler: it does not look like slop —

(These stills don't move on the page — but every free effect is playing live in the effects gallery. Drift, parallax, rain, embers, glitch, all $0. Part 3 dissects how.)

Exhibit B: the six-cent video

Killing AI video was step one. Step two was realizing Nano Banana isn't always the move. For a goofy "why do cats have fur" Short, I didn't need photoreal noir — I needed clean flat cartoon. Enter Flux Schnell at $0.003 per megapixel, roughly half a cent an image:

Here's that one, live:

🎬 Why do cats have fur? → youtube.com/shorts/FWtEJjeK_vI

And the receipts, straight from its manifest:

Stage	Provider	Cost
Script	local LLM	$0.00
Visuals (10 images)	`fal-flux-schnell`	$0.054
Motion (all scenes)	Ken-Burns (ffmpeg)	$0.00
Voice	`edge-tts` (neural)	$0.00
Sound FX + music	`fal-elevenlabs-sfx` + local bed	$0.0076
Save + Publish	ffmpeg / YouTube API	$0.00
TOTAL		≈ $0.06

From $10.50 → six cents. Same pipeline, different knobs. That's a ~175× cost cut, and it's the difference between "fun demo" and "I can run hundreds of these and let a bandit pick the winners." (Full cost teardown: Part 4.)

That $0.0076 line is quietly important, too: it's an AI sound layer — generated SFX plus a music bed ducked under the narration — and atmosphere is a big reason cheap doesn't read as slop. The how is in Part 3.

The gap I'm actually building into

After mapping the field, two things were suspiciously absent from every faceless-AI playbook:

Cost honesty. Everyone screenshots the $4M. Nobody publishes a per-second price table or admits their first video cost $10. So they never explain how to afford video #100.
Autonomy. "Just post consistently for 6 months" — cool, that's a full-time job done by hand. Nobody treats what to make next as a decision a system can learn: explore vs. exploit, a memory of what won, a verdict on every bet.

That's the thesis. Over the next six parts I'll build a channel that:

turns a one-line idea into a finished, well-directed vertical Short (Part 2),
moves nearly all motion off paid AI video onto free custom effects (Part 3),
drives cost per video from ~$10 toward pennies (Part 4),
remembers what worked via a per-channel journal + self-reflection (Part 5),
decides what to make next with a Thompson-sampling bandit over a falsifiable hypothesis (Part 6),
and runs itself on a schedule, grading each post 48–72h later (Part 7).

The learning loop is already showing its teeth. A batch of near-identical clips dumped in the same minute cannibalized itself (3–6 views each — brutal). Meanwhile one video — a real mathematician framed as a heretic, with a "this breaks reality" hook in the first two seconds — hit roughly 50× the channel's other Shorts. The rest of this series is the machine I'm building so that's a repeatable pattern, not a lucky roll.

It's all open source — and it's a live experiment

The whole studio is on GitHub — slope-studio (one letter from "slop", which, given the genre, is either a typo or a mission statement). Every line of code in this series lives there: the 7-stage pipeline, the free ffmpeg effects, the cost model, the bandit. Part 2 is the guided tour, with a one-command smoke test you can run with zero API keys.

And this isn't a retrospective with the numbers airbrushed in — it's a live experiment you can watch compound or faceplant in public. Every Short the system ships asks viewers to subscribe, because the whole point is watching an autonomous channel grow from zero. Consider it subscribing to the test harness.

What I'd tell another AI engineer

Takeaway: Treat content as a pipeline, not a craft. The instant every input — script, image, motion, voice, sound — is a function call with a measured cost, three superpowers unlock: you can drive unit cost toward zero, run hundreds of cheap experiments, and bolt a learning loop on top that decides which experiments to repeat. The folks making millions optimized the system and the volume. The folks getting deleted only had volume. The alpha is the system.

Next — Part 2: Idea → Published in 7 Stages. The actual architecture: every stage as an independent CLI subcommand, the runs/<id>/ artifact flow, a manifest that records measured cost per stage, and how a single line of text becomes an uploaded Short without me touching a video editor.

▶ Live effects gallery: dasein108.github.io/slope-studio
⭐ Star the repo: github.com/dasein108/slope-studio
🔔 Subscribe (watch the experiment from zero): the Lobachevsky Short

Sources: techlusive · Business Standard · OutlierKit (AI-slop crackdown) · Miraflow (faceless explosion 2026). View/revenue figures are third-party estimates.

DEV Community: Maksims Gavrilovs

Zero to Autopilot, Part 2: One Line of Text a Published Short, in 7 Stages

The mental model: a video is a Makefile

Everything is a file under runs/<id>/

Each stage is a CLI subcommand (and they chain)

The provider contract: every model reports its own cost

Watching it actually run

Try it yourself (zero API keys, zero dollars)

What I'd tell another AI engineer

Zero to Autopilot, Part 1: I Built an AI That Runs a YouTube Channel (the landscape, and my $10 wake-up call)

The two-billion-view problem

Why "faceless" is catnip for an engineer

Exhibit A: my first video quietly ate $10

Plot twist: I'd solved this before, in a past life

Exhibit B: the six-cent video

The gap I'm actually building into

It's all open source — and it's a live experiment

What I'd tell another AI engineer

Everything is a file under `runs/<id>/`