Skip to main content
skill CX Codex

demo-video · microsoft — Claude Code skill: assemble MP4 from frames and narration

Assembles demo videos from ordered frames or clips, WAV narration, and transitions via FFmpeg. Built for first-pass prototype walkthroughs and tutorials.

MIT ★ 1,627 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add microsoft/hve-core --skill demo-video -a claude-code
Open on GitHub

What demo-video does

The skill reads a segments.yml manifest that describes each segment — a still image (frame) or motion clip (clip), the path to the visual source, and the path to the narration WAV file — then renders the final MP4. By default, segments are joined with hard cuts; if the manifest includes a transition block with type: crossfade and duration, the skill adds synchronized video and audio fades at segment boundaries. Resolution is set in resolution (defaults to 1280x720), frame rate in fps (defaults to 24). Segment duration is inferred from narration length or overridden with the duration field.

Run the skill using the scripts/assemble-video.sh or scripts/Invoke-AssembleVideo.ps1 wrapper with --manifest and --output arguments. FFmpeg and ffprobe must be on your PATH or the assembly step will not start. Temporary files are cleaned up after rendering; the final MP4 is written atomically so a failed FFmpeg run leaves any existing file unchanged.

For production-quality narration, the skill recommends Azure AI Speech neural voices via the tts-voiceover skill (such as en-US-Andrew:DragonHDLatestNeural). Synthetic narration requires disclosure to viewers.

What it helps with

  • assemble a demo video from prototype frames and matching narration files
  • stitch multiple clips with separate narration for each segment
  • add crossfade transitions between scenes and narration tracks
  • normalize resolution and fps across segments before final render
  • write the output MP4 atomically so a failed FFmpeg run leaves the old file intact

Example prompts for the agent

  • Assemble video from examples/segments.yml into output/demo.mp4 at 1920x1080 resolution, 30 fps
  • Run scripts/assemble-video.sh --manifest walkthrough.yml --output result.mp4
  • Add crossfade transitions with 0.8-second duration to the manifest and rebuild the video

How to install demo-video

1Skills CLI (Vercel)

npx skills add microsoft/hve-core --skill demo-video -a claude-code

2Manually: put the files in place

~/.claude/skills/demo-video/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/demo-video/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about demo-video

How to install demo-video in Claude Code?

Run npx skills add microsoft/hve-core --skill demo-video -a claude-code, then open ~/.claude/skills/demo-video/SKILL.md.

What does demo-video do?

It assembles an MP4 from ordered frames or clips, WAV narration files, and optional crossfade transitions using FFmpeg. The manifest describes segments, resolution, and fps; the skill normalizes each segment and stitches the final video.

What does demo-video require to run?

FFmpeg and ffprobe must be on your PATH. Without them, the skill will not start. For narration, use WAV files; the skill recommends generating them via tts-voiceover with Azure AI Speech neural voices.

Source text

SKILL.md · MIT
---
name: demo-video
description: 'Assemble ordered frames or clips with narration and optional synchronized scene transitions into an MP4 via FFmpeg'
license: MIT
compatibility: 'Requires FFmpeg on PATH'
metadata:
  authors: "microsoft/hve-core"
  spec_version: "1.0"
  last_updated: "2026-10-03"
---

# Demo Video Assembly Skill

This skill assembles a narrated demo video from ordered visual segments and matching narration audio. It is designed for first-pass walkthrough videos that combine captured prototype frames or clips with per-segment voiceover WAV files.

## Overview

The workflow takes a manifest that describes each segment, resolves the visual
source, and uses FFmpeg to render each segment into a normalized video clip
before assembling the final MP4. It supports hard cuts by default or optional
synchronized video and audio fades. The narration track is muxed from WAV files
so the output can be reviewed without a separate video-editing tool.

## Manifest Schema

Use a `segments.yml` manifest with optional top-level output settings and an ordered list of segments. Each entry describes a visual source and the narration audio to combine for that portion of the video. All paths resolve relative to the manifest file.

```yaml
output: ./output/demo.mp4   # optional; destination path for the assembled MP4
resolution: 1280x720        # optional; default 1280x720
fps: 24                     # optional; default 24
transition:                 # optional; omit for hard cuts
  type: crossfade
  duration: 0.5
  fade_in: true
  fade_out: true
segments:
  - type: frame
    visual: ./frames/intro.png
    narration: ./audio/intro.wav
    duration: 4.5
  - type: clip
    clip: ./clips/interaction.mp4
    narration: ./audio/interaction.wav
```

### Top-level fields

* `output` sets the destination path for the assembled MP4, resolved relative to the manifest; the `--output` or `-OutputPath` argument overrides it when supplied
* `resolution` controls the output width and height in `WIDTHxHEIGHT` form (default `1280x720`); the `--resolution` or `-Resolution` argument overrides it
* `fps` sets the frame rate applied when rendering each segment (default `24`); the `--fps` or `-Fps` argument overrides it
* `transition` enables synchronized scene and narration fades; omit it or set it
  to `none` to retain hard cuts

### Transition fields

* `type` accepts `crossfade` or `fade`, which both select FFmpeg's fade
  cross-transition
* `duration` sets every opening, scene, audio, and closing fade in seconds
  (default `0.5`)
* `fade_in` controls the opening video and audio fade (default `true`)
* `fade_out` controls the closing video and audio fade (default `true`)

The assembler adds silent handles around speech and holds the matching endpoint
pictures. Crossfades overlap those handles, not adjacent spoken instructions;
do not pre-pad narration to compensate. The normalized segments must exceed
twice the transition duration. Output duration is the sum of unpadded narration
durations plus one transition duration per scene boundary and per enabled
opening/closing fade. With transitions disabled, no handles are added.

### Segment fields

* `type` identifies whether the segment is a still image (`frame`) or a motion clip (`clip`)
* `visual` points to an image file for a frame segment
* `clip` points to a motion clip file for a clip segment
* `narration` points to the WAV file generated from narration text (the script also accepts `narration_wav` as an alias)
* `duration` is optional and overrides the inferred duration when you want a fixed segment length

## Quick Start

Use the bash or PowerShell wrappers to invoke the assembler from the skill directory.

```bash
scripts/assemble-video.sh --manifest examples/segments.yml --output ./output/demo.mp4
```

```powershell
scripts/Invoke-AssembleVideo.ps1 -ManifestPath examples/segments.yml -OutputPath ./output/demo.mp4
```

## Parameters Reference

The assembly step accepts the following high-level controls:

* `--manifest` or `-ManifestPath` selects the YAML manifest to process
* `--output` or `-OutputPath` sets the destination MP4 path
* `--fps` or `-Fps` controls the output frame rate for rendered segments
* `--resolution` or `-Resolution` controls the output width and height in the form `WIDTHxHEIGHT`
* `--timeout` or `-TimeoutSeconds` sets the maximum seconds for each ffprobe or ffmpeg invocation (1-86400, default 600); a timed-out step stops the run with an error that names the step
* `duration` per segment lets you override the inferred length when narration timing is known in advance

## Failure Behavior

The assembled MP4 is written to a temporary file next to the destination and
moved into place only after FFmpeg succeeds. A failed, timed-out, interrupted,
or invalid transition run leaves no partial MP4 at the output path and keeps any
existing file there unchanged. A successful run replaces an existing file at
the output path. Temporary segment files are always removed.

## Narration Quality

Narration quality is the single biggest driver of how polished the final video feels. Generate narration with neural voices from **Azure AI Speech (part of Azure AI Foundry)** through the `tts-voiceover` skill, for example `en-US-Andrew:DragonHDLatestNeural` or `en-US-Jenny:DragonHDLatestNeural`. These produce natural, presentation-grade narration.

This skill assembles video locally with FFmpeg and does not generate video with an AI model. When the narration is synthetic, tell viewers that the voice is AI-generated. HVE demo-material CI publishes silent videos; internal silent timing tracks are removed during finalization.

See the `tts-voiceover` skill for the neural voice catalog, `--voice` and `--rate` controls, and Azure authentication (Microsoft Entra ID recommended, or a key).

## Reuse Bridge

This skill is intentionally designed to fit into the existing media workflow:

* `tts-voiceover` provides the narration WAV files that this skill muxes into the final output; prefer its Azure AI Speech neural voices for production-quality narration
* `vscode-playwright` provides the frame-capture source for prototype walkthroughs and screen-based demos

## Prerequisites

FFmpeg and ffprobe must be available on your PATH.

### Linux

```bash
sudo apt update && sudo apt install ffmpeg
```

### macOS

```bash
brew install ffmpeg
```

### Windows

```powershell
winget install FFmpeg.FFmpeg
```

© microsoft · MIT · microsoft/hve-core

Similar skills

All skills for Automation and no-code: n8n, Zapier, Make →

demo-video by other authors comes first.

demo-video Alireza Rezvani demo-video turns screenshots and scene descriptions into product walkthroughs, animated demos, or GIFs directly in Claude Code. CX Codex +1 708installs vox-video-director modelstudioai vox-video-director is a Claude Code skill that turns a single topic into a finished Vox-style video with collage animation, narration, music and captions. CX Codex +1 161installs video-edit calesthio Local video editing via ready-made instructions for the ffmpeg CLI tool. It helps slice footage, adapt aspect ratios for social networks, and compress tracks. CX Codex +1 1,600installs review-video ShuaiMXu review-video is a Claude Code skill that inspects and repairs product or promotional videos using original assets, before/after evidence, and timeline reviews. Runs during video audits and defect fixes. CX Codex +1 ★ 529repo stars video-pipeline notivn video-pipeline is a Claude Code skill that guides video production from a request to an MP4 using HyperFrames and Remotion. It activates when starting a video or building a render queue. CX Codex +1 ★ 147repo stars hyperframes-sales-demo-builder OneWave-AI hyperframes-sales-demo-builder — a skill for Claude Code, Codex, Cursor and other platforms that builds a prospect-specific demo video in HyperFrames. CX Codex +1 157installs ui-demo affaan-m ui-demo records demo videos of a web app with Playwright: visible cursor, steady pacing, a story-shaped flow. Handy for onboarding clips and stakeholder walkthroughs. CX Codex +1 6,600installs

From the same set148

The whole set →
data-catalog Build a Markdown data catalog with declared entities and relationships. Use the skill to inventory engagement data or prepare a catalog for ERD rendering. CX Codex +1 ★ 1,627repo stars Supply Chain Skill Assessor Supply Chain Skill Assessor runs a supply-chain review against the supply-chain-security skill and returns a findings table: what passes, what is partial, where the gap sits. Handy before a release or a CI review. CX Codex +1 ★ 1,627repo stars privacy-standards privacy-standards is a Claude Code skill that provides privacy engineering references for data-flow analysis, DPIA thresholds, and open compliance standards. CX Codex +1 ★ 1,627repo stars copilot-tracking This rule organizes working files for RPI, HVE Builder, and related workflows under .copilot-tracking/. It sets paths and formatting conventions for research, plans, changes, and reviews. CX Codex +1 ★ 1,627repo stars dt-methods dt-methods is a Claude Code skill that gives the dt-coach agent a knowledge base of nine Design Thinking methods and nine industry contexts. CX Codex +1 ★ 1,627repo stars rpi-challenger The rpi-challenger skill questions a confirmed task, decision, plan, or artifact to bring assumptions to the surface. It asks you to confirm the scope before the questioning starts. CX Codex +1 ★ 1,627repo stars python-foundational python-foundational — a checklist skill covering Python style, idioms, typing and error handling that Claude Code applies automatically to diffs touching .py files. CX Codex +1 ★ 1,627repo stars ml-experimentation ml-experimentation is a Claude Code skill that applies Microsoft CSE practices to ML experiment tracking, reproducibility, and production readiness checks. CX Codex +1 ★ 1,627repo stars

Project sponsors

Companies that keep this analytics open