For the producer

Working with SuperStories video — for the producer

You were right: the animations are beautiful but locked, and getting them into a video kept failing. Here is how it works now. One idea holds it together:

Two layers, two places. The moving background is generated (Claude makes it). The text and the edit are yours (your own editor). You don't edit inside the generated animation — you turn it into a normal video file, and from there it's just footage you work with like any other clip.

Why this, not a template tool

Canva and CapCut hand you a template to fill in. This generates motion from the client's own brand: their colours, their pace, their caption style, so every piece is unique, not stock. And each brand we set up makes the next video faster and more on-brand. The look is generated; the craft, shaping and assembling, stays yours.

Getting set up (once)

You do this one time on your Mac. After that it's just the double-click.

1. Get the project onto your Mac. Easiest is GitHub Desktop (an app with buttons, no Terminal): download GitHub Desktop, sign in with your GitHub account, then File → Clone repository → SuperStoriesAmsterdam/proprietarysuperstories → Clone. (Prefer Terminal? gh auth login, then gh repo clone SuperStoriesAmsterdam/proprietarysuperstories.)

2. Open that folder in Claude Code.

3. Install three helpers, once. Open the render folder in Terminal and run these. They set up the pieces a render needs: play the animation in a browser, record it, and turn the recording + audio into an MP4.

Command	What it installs, in plain words
`npm install`	The code the tools use (the part that opens and records a browser).
`npx playwright install chromium`	The browser that plays and records the animation (~100 MB).
`brew install ffmpeg`	The tool that turns the recording + audio into the final MP4 file.

(If brew is unknown, install Homebrew first from brew.sh — one command from their site. Homebrew is just an installer for the Mac.)

How you run it: one double-click

In the render folder there is a file called Video tools.command. Double-click it. A small menu appears with three choices, and a file picker. No typing, no Terminal.

Choice	What it does, in plain words
Render background	Turns an animation into a normal video file (MP4). It opens a window, plays the animation, and records it. Let it finish — it takes as long as the audio. A clean video lands next to the animation.
Extract captions	Pulls the words out of the animation into a captions file (`captions.srt`) you can open and edit.
Burn captions (you rarely need this)	Makes a copy of the video with the captions stamped permanently onto it. Normally you skip this and just bring the captions file into your editor, where you can restyle and resize them. If your Mac can't do it, the menu simply tells you to use your editor.

The pieces

The animation (made in Claude Code) is the moving brand background. It's beautiful but locked — you don't go in and edit text. Treat it as a source you render, not a file you tweak.
The video file (MP4) from Render background is ordinary footage. Drop it in Descript / CapCut / Premiere and treat it like any clip.
The captions file (captions.srt) is the words, as a plain file. Edit it, or import it straight into your editor where you size and style the captions yourself.
Your editor is where you assemble the episode: background + captions + footage + timing. Instant, visual, your craft.

What changed

Before: the render gave you only the intro and music, no subtitles, titles too small. The animation is driven by the audio playing, and the old method froze that — so nothing past the intro happened. Hence all the broken files.
Now: Render background actually plays the animation and records it, on your Mac (real screen + sound). The background comes out right.
The words are no longer trapped in the code. They live in captions.srt. Edit them like a document, or hand them to your editor.

What you can test now

Double-click Video tools.command → Render background → pick podcast-ep1.html. A window plays; let it finish. You get a clean background MP4.
Open …/podcast-ep1/captions.srt, change a word. Save.
In Descript/CapCut, import that captions.srt as subtitles, and drop the MP4 on the timeline. Size the captions, place the clip, add footage.

The workflow you proposed, and what actually works

Your plan: generate the motion for the whole script, then in an editor combine Connirae's talking head with the generated graphics, intertwining the two. An editor stays in the loop, and Lindsay can do that part. That is right. It is the natural way once you accept that the talking head and the motion are two separate layers.

Two things make it work in practice, and one thing to avoid:

Generate the motion for the whole script, but render it text-free (the Render background button already does this), and keep the words in captions.srt. If the text is baked into the render, Lindsay can shift nothing when Connirae's delivery lands a beat early or late, and every fix means a new render. Text-free plus the srt keeps it all movable.
The motion is a brand-motion layer, not a scene-by-scene illustration of the script. It carries mood and the quotes, not a picture for every sentence. For some content that is exactly right; for a hard explainer it can be too thin. Good to know before you promise a client.
What does not work: delivering the whole thing as one finished, locked video. Then the talking head can no longer be woven in. Deliver the motion as a layer Connirae's face cuts in and out of, never as the final cut.

Auto-placement: the motion lands on the right moments for you

This is the step that turns "a couple of hours of weaving" into "trim and taste".

Double-click Video tools.command → Build edit for Resolve. It asks for three files: the captions.srt, the talking-head clip, and the motion bg.mp4. It writes an edit.fcpxml: a ready timeline where the talk runs as the base and the motion is already cut in over the face at every caption moment.

In DaVinci Resolve (free): File → Import → Timeline and pick the edit.fcpxml. Then File → Import → Subtitle and pick the captions.srt. The weaving is done. You only trim the cutaways, fix a beat, and style the captions.

It works in Resolve, Final Cut and Premiere, because those read FCPXML. It does not work in CapCut, Gling or Canva: they cannot import a pre-built edit.
If a cutaway sits a beat off, nudge it. The hard part, putting nine clips on nine exact moments, is already done.

Cutting the talk first (optional)

Before the weave, you may want to tighten Connirae's talk: strip the "um"s, the false starts, the long pauses. Two tools fit our one-talking-head case:

Gling auto-cuts a single talking head. It finds the silences and filler and removes them, so the raw take becomes a clean cut fast. Good as a first pass on the face.
Descript edits by transcript: you delete words in the text and the video follows. Stronger for multi-person or long-form, and for moving lines around.

Either way, export the tightened talk as one clip, then run Build edit for Resolve on that clip so the motion lands against the final talk timing.

The manual fallback (no auto-placement)

If you ever build by hand: the captions file is your cue sheet. Every line in captions.srt has a timecode, and those are the moments to cut from the face to the motion with the quote on it. Drop bg.mp4 on a layer at those points and import the srt as subtitles.

What it delivers

A clean background video you own.
Captions you fix in seconds: change one line in the captions file, restyle in your editor. Never a long re-render, never "ask Claude to build a whole new thing".
Full freedom to assemble in the tool you already know.

The one rule

In Claude Code: changing the look of the moving background.
In your own editor: text, sizes, line breaks, trims, assembly, fixing a caption. That's the captions file + your editor. We are not turning Claude into Canva or After Effects.