Opus 5.5 turns a single prompt into finished explainer videos by writing them as code

Two projects that surfaced the same day show Anthropic's Claude Opus 5.5 producing finished explainer videos end to end, and neither relies on a video generation model. In both, the model authors the video as code, and a deterministic renderer turns that code into an MP4.

A launch film from one prompt

LaunchVideo, a site that reached Hacker News's front page, makes a narrow offer: paste a URL or describe a product, and Opus 5.5 drafts the film while a serverless agent renders it. Every example on the page is a single unedited run, with nothing but a prompt or URL supplied and an MP4 returned. According to the site, a typical job takes about four minutes and roughly 100,000 tokens, split into about 90k input and 15k output, with most of the output being the film's HTML.

The pipeline is deliberately small: one TypeScript agent deployed on OpenComputer and three tools. One fetches a product page and returns its text, headings, most-used hex colors and Google Fonts; one loads the film and reports JavaScript errors and the visible text at sample timestamps; one renders and uploads the result. Each job runs in a fresh microVM, Amazon Linux 2023 on arm64 with 4 vCPU and 8 GB of RAM, which installs Playwright's headless Chromium and a static ffmpeg on first use and is thrown away afterward.

The rendering is the notable part. The page's clocks, from requestAnimationFrame and timers to Date and CSS animations, are replaced with a virtual clock so that every frame becomes a deterministic seek, captured at 1920x1080 and 30fps and piped as JPEGs into libx264. The site credits the idea to Deedy's post on Opus 5.5 and instructional video: written code plays back the same way on every run.

A video about how it was made

A walkthrough published the same day on dev.to, titled "This video is about how this video was made," goes deeper. Working in Claude Code, Opus 5.5 built a 107.5-second, 3,224-frame film from an open-source starting point, JohnHeibel/PDoomVideo, and the post publishes the real artifacts: the script, the storyboard, the briefs given to subagents, and the grade a reviewer assigned an earlier draft.

Its foundation is a single constraint: what a frame shows depends only on the time it represents. There is no Math.random(), no wall clock and no state carried between frames; randomness comes from a seeded hash borrowed from GLSL. That buys parallel, resumable rendering, since frames can be produced out of order across several browser workers and any single frame can be regenerated on demand, which is how the finished video can display itself at frame 1,365 while frame 2,000-something was still being rendered.

Timing is character-precise. A 15-line script marks cue words in braces; each line goes to ElevenLabs' with-timestamps endpoint, which returns start and end times for every character, and a Python tool converts those into word timings and stitches the clips together. Music from Suno is aligned through a hidden subtitle stream in the export, Whisper large-v3-turbo word timings, sequence matching against the actual lyrics, and a comb search over the audio's onset envelope to locate the beat grid.

Subagents, a critic and a blind spot

Before any chapter code existed, the model wrote a storyboard file and an animation guide defining the contract for builders, then handed three chapters to three subagents running in parallel, each verifying its own work with contact sheets. A separate reviewer agent graded the first draft, giving one frame 4/10 for promising a review it could not yet show, and catching a HUD that read 76.033 seconds against a 76.008-second target.

Partway through, the model could no longer see images at all, with screenshots rejected by the API, so it verified frames two other ways: small scripts reporting each frame's mean color, bright-pixel share and content bounding box, and sighted reviewer subagents that described and scored frames. Final rendering used four headless Chrome workers pulling frame indices from a shared queue, with ffmpeg assembling JPEGs and narration; an ffmpeg -shortest flag that hung indefinitely on a subtitle input had to be replaced with an explicit duration. The closing shot is a genuine recursive loop, with the renderer drawing its own output canvas back into a player shown on screen.

Why it matters

The leap here is agentic rather than cinematographic. One frontier model planned a multi-minute artifact, delegated chapters to subagents, acted on a critic's feedback, diagnosed its own lost vision and substituted numeric checks, then shipped reproducible output. Determinism is what makes that loop practical: because films are code, drafts can be compared, any frame can be re-rendered, and a fix does not reshuffle everything around it. It also sketches an alternative to video models for explainer content, with text, precise timing and motion graphics written as an auditable program rather than sampled pixels, at a running cost the launchvideo.io site puts near 100k tokens and four minutes per film.