I Stopped Recording Product Demos and Started Compiling Them

Brian Carpio•
Claude CodeAI EngineeringVideoPlaywrightDeveloper Experience

Every product demo video I have ever made had the same problem. It was a recording. A recording is a dead artifact. The UI changes, the data in it goes stale, somebody notices a customer name in the corner of frame, and the only fix is to sit down and record the whole thing again.

So I stopped recording them. The demo videos for OutcomeOps are compiled now. They live in a git repo as code, they render in headless Chromium, and when the product changes I re-run a script instead of re-shooting a screencast. The pipeline itself is open source too; the link is at the end of this post.

This is the second video pipeline I have built with Claude Code and it is the opposite of the first one. The music video pipeline is generative: LTX 2.5 and Wan 2.2 running on a local 5090, models producing the pixels, me picking takes off contact sheets. In this one, no model draws a single pixel. Every frame comes from code. The reason is simple. In a music video, imagination is the requirement. In a product demo, fidelity is, and no video model is going to render your actual chat interface correctly.

What actually mattered

  • It is open source. The whole pipeline and the scene source for every published video: github.com/bcarpio/outcomeops-video-production-pipeline.
  • One clock. Every visual is a function of time, so the export can step that clock one frame at a time: a true 60 fps, in sync, identical on every render.
  • Narration drives the timing. ElevenLabs returns the second each beat lands on, and the animation keys off those numbers. No timeline, no nudging.
  • Rebuild the UI with staged data instead of filming the real app, so no real customer, repo or ticket ever appears on screen.
  • Point the agent at the real product’s source, so it builds scenes from the actual pages and copy instead of its memory of them.
  • One good example is enough. Claude Design produced the first scene. Claude Code built every scene after that from the previous one.

One clock

Each video is a folder under demos/<name>/. Inside it is a small React application compiled in the browser by Babel. There is no build step and no bundler, because there does not need to be one.

A Stage component owns a single requestAnimationFrame clock. Every visual in the scene is a pure function of that clock. A cursor position, a typing animation, a highlight sweeping across a row, a panel sliding in: all of them take the current time and return what should be on screen at that time.

That one constraint is what makes the whole thing work. Nothing in the scene holds its own state, so the scene at 14.2 seconds looks the same every time. The export takes advantage of that: instead of recording the browser in real time, it pauses the page’s clock and steps it forward exactly one sixtieth of a second per frame, taking a screenshot of each one. The result is a true 60 frames per second, in exact sync with the narration, and identical on every run no matter how fast the machine is. The first version did record in real time, which quietly capped the output at 25 frames per second; stepping the clock fixed that. A diff in the scene file now produces a predictable diff in the output, and I can re-render all of it after a UI change without watching anything.

From Claude Design to Claude Code

I did not design that pattern myself. The first video was built in Claude Design, and Claude Design can export straight to Claude Code. What came across was not a mockup. It was a working scene on top of one reusable file, animations.jsx: the Stage, the timeline, sprites that only render inside their time window, and the easing helpers.

That handoff turned out to be the important part. Claude Code read the export, picked up the pattern, and from the second video on built each new scene from the previous one: copy the folder, keep the Stage, rewrite the scene. Eighteen demo folders now carry their own copy of that original file, and the marketing variations still say in their headers that they were extended from the original Claude Design bundle.

So I stopped spending Claude Design tokens on video. Claude Design was the right tool for establishing the visual language and the architecture once. After that, the cheapest way to make the next video was to point Claude Code at the last one. Once one good example exists in the repo, the agent follows it.

Narration drives the timing, not the other way around

The usual way to sync narration to visuals is to record the voice, drop it in a timeline, and nudge the animation around until it lines up. That is an editing job and it has to be redone every time the script changes.

Instead the script is written as plain text with beat markers in it:

[[intro]] An engineer files a ticket.
[[ticket]] The user story is three sentences.
[[generate]] OutcomeOps pulls the ADRs that apply.

That script goes to ElevenLabs’ with-timestamps endpoint once. What comes back is the audio plus the exact second each beat lands on. The synth script writes those timings into a small file the scene loads:

window.BEATS = {
  intro: 0.0,
  ticket: 3.4,
  generate: 8.1,
};

Every animation timing in the scene is derived from BEATS, so the animation is synced to the word rather than eyeballed against a waveform. Change a sentence in the script, re-synthesize, re-render. The new timings flow straight into the scene. No timeline, no scrubbing, nothing copied by hand.

Then export_demo.py steps the scene frame by frame in headless Chromium, and ffmpeg encodes the frames together with the narration into the final MP4, along with the thumbnail, the YouTube metadata and an index card.

Three ways to make it look like the product

There are three approaches in the pipeline and they are good at different things.

Film the real thing. A YAML scene definition drives Playwright through the actual site or application, clicking, scrolling and typing on the live UI. This is pixel perfect by definition and UI changes flow through on the next render. The limits are real though: you can only show what the product does right now, with whatever data is actually in it, and you get no animated emphasis. When the product screen itself is the story, this is the right tool.

Rebuild the UI as scene components. For most of the demos, the interface is reconstructed as pure visual components driven by props and time. The chat demo has a chat_ui.jsx that rebuilds the sidebar, the workspace chips, the streaming answer and the tool call rows, and a scene.jsx that owns the timing map and the scripted conversation. The look lives in one file and the choreography in the other.

This is more work up front and it buys two things that matter. You can stage the data perfectly, which means a demo never contains a real customer name, a real repository or a real ticket. And you can hold on a detail, highlight a row, or slow down for a beat, because you control every frame.

A compiled demo, re-rendered with the frame-stepped exporter at a true 60 fps. The dashboards are rebuilt scene components with staged data, timed to the narration’s beats. Nothing in it was screen recorded. The original on YouTube came from the first, real-time exporter.

Point the agent at the real source. This is a Claude Code technique rather than a video technique, and it is what keeps the first two approaches honest.

The product lives in its own repository, outcome-ops-ai-assist, which I open sourced this week. It is checked out next to the demos repo on the same machine, so Claude Code can read its source directly. The CLAUDE.md in the demos repo catalogs it: where the UI source lives, the routes worth filming, which page component renders each one, and what on that page makes good scene material. It tells the agent how to pick selectors that survive a redesign, starting with data-test attributes and falling back to the titles on every nav icon. It even records product decisions the agent would otherwise get wrong, like which icon the budgets page uses and which one I rejected.

So when the agent writes a scene, it is not working from its memory of what OutcomeOps looks like. It can read the actual page component, reuse the product’s exact copy, and script against selectors that exist.

What it costs and what it buys

The economics are not the interesting part. A few dollars of ElevenLabs, a Claude Code subscription that pays for a lot of other work, and however long the headless render takes.

What it buys is that video stopped being a thing I dread. There are around forty assets in the current library: role targeted shorts, keyword anchored explainers, a comparison cut, two pattern series, and the demo sources with the calls to action stitched on separately so a recut does not require a re-record. When the UI changes, the affected scenes get re-rendered. When a script line is wrong, I fix the line and re-synthesize. Nobody opens an editor.

The general version of this: anything you produce repeatedly and have to redo when the underlying system changes is a candidate for being compiled instead of made. Video felt like it was outside that category. It is not.

The pipeline is open source under Apache 2.0, the same license as OutcomeOps: github.com/bcarpio/outcomeops-video-production-pipeline. It includes the Stage and animation helpers, the export and synthesis scripts, the CLAUDE.md that catalogs the product repo, and the scene source behind the published OutcomeOps videos, so you can see exactly how each one was built. To make your own, copy the starter scene and follow the build-your-own guide in the README.


Brian Carpio has spent 28 years in technology and 14 building enterprise cloud infrastructure on AWS, and ships AI in production daily. He writes about context engineering, governance, and the operating models that make AI-assisted development hold up at scale.