Automating My YouTube Debut

7 min read
aiclaude-codeyoutubeworkflowindie-hackingtypescript

Most people start a YouTube channel by buying a microphone. I started by writing a CLI tool.

That probably says everything you need to know about me. But in case it doesn't — let me explain why building the production pipeline first is the most rational thing I've done in months.

The Pattern

Six months ago, I stopped opening Canva. I wrote about it — I built an Instagram content pipeline that turns Claude conversations into carousel PNGs. HTML templates, Playwright screenshots, Figma MCP for polish. The whole thing lives in the terminal. I haven't missed Canva once.

That pipeline changed something deeper than my Instagram workflow. It proved a thesis: content creation doesn't have to be a separate discipline from development. Same tools. Same flow state. Same git repo.

So when I decided to start a YouTube channel, the question wasn't "which camera should I buy?" It was "how do I keep video production inside my development environment?"

The answer is a 25-file TypeScript CLI called yt.

What the Tool Does

Seven commands. One pipeline.

yt new "claude-code-workflow"     # Scaffold video project
yt script --topic "..."           # Generate PT-BR script structure
yt thumb --title "..." --template code-focused  # HTML → 2560×1440 PNG
yt meta --title "..."             # Title, description, tags, chapters
yt status                         # Pipeline dashboard
yt auth                           # YouTube OAuth2 (one-time)
yt upload --schedule "..."        # Ship it

Each video is a folder. videos/2026-03-01-my-video/ contains script.md, metadata.json, thumbnail.html, thumbnail.png, and assets/. Everything is a file. Everything is version-controlled. Nothing lives in a web app I don't control.

Thumbnails Are HTML

Same philosophy as the Instagram pipeline. Each thumbnail is an HTML file — 2560×1440 pixels, rendered by Playwright into a PNG. Five templates so far:

  • default — title + subtitle, gradient accent bar
  • text-heavy — giant bold text filling the frame
  • code-focused — split layout with a terminal window
  • talking-head — text with a face overlay area
  • before-after — split screen comparison

The templates use {{variable}} placeholders. No template engine dependency — just string replacement with brand colors and fonts baked in. When I run yt thumb, the rendered HTML gets saved alongside the PNG. If I want to tweak something, I edit HTML. Not a Photoshop file. Not a Canva project. HTML.

yt thumb --title "Meu Workflow com Claude Code" \
         --subtitle "Do zero ao deploy" \
         --template code-focused \
         --code "yt new && yt thumb && yt upload"

That command produces a thumbnail with my title on the left, a terminal window with the code snippet on the right, a yellow divider, and the Helsky Labs badge. Ten seconds from idea to PNG.

Scripts Are Structured, Not Generated

I made a deliberate choice here. The yt script command doesn't write your script. It scaffolds the structure.

## Gancho (0:00–0:30)
> O que vai prender a atenção nos primeiros 5 segundos?

## Contexto (0:30–2:00)
> Qual problema estamos resolvendo?

## Conteúdo Principal (2:00–8:00)
> O meat do vídeo. Demos, código, explicações.

## Resultado (8:00–9:30)
> Mostre o antes/depois. Números concretos.

## CTA (9:30–10:00)
> Inscreva-se, comente, próximo vídeo.

The actual writing happens in a Claude Code conversation. I describe what the video is about, and we work through the script together — same way I plan Instagram carousels. Claude is the editorial partner, not the ghostwriter.

Could I add an --ai flag that auto-generates a full script? Sure. I probably will eventually. But the first version is intentionally manual. I want to find my voice before I automate it.

Metadata Is Boring but Important

YouTube SEO is a genre of content I never wanted to learn. So I made the tool handle it.

yt meta reads the script (if it exists), extracts the title, generates a PT-BR description with timestamps, adds default tags, and structures everything into a metadata.json that the upload command consumes.

{
  "title": "Meu Workflow Completo com Claude Code",
  "tags": ["programação", "dev brasileiro", "claude code", "ia para devs"],
  "chapters": [
    { "time": "0:00", "title": "Intro" },
    { "time": "0:30", "title": "Contexto" },
    { "time": "2:00", "title": "Conteúdo Principal" }
  ],
  "privacy": "unlisted"
}

The default privacy is unlisted. Because I'm not shipping a video publicly until I've watched it twice and hated it the normal amount.

The Upload Loop

The full workflow:

yt new "my-video"          # 1. Scaffold
# Edit script.md            # 2. Write (in Claude Code)
yt thumb --title "..."     # 3. Thumbnail
yt meta                    # 4. Metadata
# Record & edit             # 5. The hard part (OBS, not this tool)
yt upload                  # 6. Ship

Step 5 is the only one that doesn't happen in the terminal. Everything else is a command. The gap between "I have an idea" and "I have a video-ready project folder with thumbnail, script, and metadata" is about five minutes.

The gap between that and an actual published video is, obviously, much larger. Recording and editing are still manual. That's fine. Those are the parts that need to be human — the voice, the delivery, the personality. The tool handles the logistics.

Why Build the Pipeline First

Here's the honest answer: because I know myself.

If unfinished side projects were a currency, I would be wealthy. I've started and abandoned more creative ventures than I care to count. The pattern is always the same — the exciting part (the idea, the first burst of creation) happens fast, and then the boring operational stuff kills the momentum. Uploading. Thumbnails. SEO. Scheduling. The friction of opening five different tools just to publish one thing.

The Instagram pipeline solved this for Instagram. I post consistently now. Not because I suddenly became disciplined — but because the friction disappeared. When posting is one command, you just... do it.

I'm building the YouTube pipeline first because I want the same dynamic. By the time I record my first video, the entire publish workflow should feel effortless. No "which thumbnail tool should I use?" No "what tags are good for YouTube?" No "how do I upload via API?" Those decisions are already made. The tool already works.

All I need to do is press record.

The Channel

It's going to be PT-BR. Portuguese only. Brazilian developers interested in AI workflows, indie hacking, and the intersection of neurodivergence and AI tools.

There's no shortage of English-language dev content on YouTube. There's a real gap for high-quality, opinionated, technically-deep PT-BR content for developers who are actually shipping products with AI — not just talking about it.

That's the plan. A YouTube channel built the way I build everything else: tools first, infrastructure first, then content that flows through the pipeline like code flows through CI/CD.

Whether anyone watches is a separate problem.

The Real Lesson

This is the same thesis from the Instagram post, extended:

Your development environment is your content studio. Your terminal is your publishing platform. The skills you use to build software — automation, templating, version control, API integration — are the same skills that make content creation sustainable.

The barrier between "developer" and "content creator" is operational, not creative. Remove the operational friction, and the creative work becomes the only thing left to do.

That's the whole idea. A CLI tool that makes YouTube feel like git push.

Now I just need to actually record something.