demo-producer — Claude Code skill: what it does, how to install
demo-producer — a skill for Claude Code automates showcase video creation for skills, CLIs, and code. Handles everything from terminal recording via VHS to video composition in Remotion.
MIT 196 installs ★ 305 updated 2026-11-14
npx skills add yonatangross/orchestkit --skill demo-producer -a claude-codeWhat demo-producer does
This skill constructs scripts, storyboards, and terminal captures for marketing videos and tutorials. It analyzes input files, generates interaction tapes for VHS, and renders compositions using Remotion. The workflow supports horizontal, vertical, and square output formats alongside multiple visual styles, ranging from quick clips to code-drawn animations.
The environment must have VHS 0.11.0 or higher and Remotion 4.0.448 or newer. The --live preview flag relies on Tailscale CLI to expose temporary public URLs via Tailscale Funnel. Finished video files undergo validation with ffprobe to ensure correct resolution and non-zero duration.
What it helps with
- generate scripts and storyboards for technical demos
- record terminal interactions using VHS tape scripts
- render multi-format demo videos via Remotion
- publish temporary interactive previews using Tailscale Funnel
Example prompts for the agent
- Create a showcase video for the commit skill in horizontal format
- Record a terminal walkthrough for the ork plugin
- Produce a vertical tutorial for building a REST API
How to install demo-producer
1Skills CLI (Vercel)
npx skills add yonatangross/orchestkit --skill demo-producer -a claude-code2Manually: put the files in place
~/.claude/skills/demo-producer/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/demo-producer/
1Skills CLI (Vercel)
npx skills add yonatangross/orchestkit --skill demo-producer -a codex2Manually: put the files in place
.agents/skills/demo-producer/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add yonatangross/orchestkit --skill demo-producer -a cursor2Manually: put the files in place
.cursor/skills/demo-producer/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install yonatangross/orchestkit src/skills/demo-producer2Manually: put the files in place
.github/skills/demo-producer/SKILL.md1Skills CLI (Vercel)
npx skills add yonatangross/orchestkit --skill demo-producer -a gemini-cli2Platform CLI
gemini skills install https://github.com/yonatangross/orchestkit --path src/skills/demo-producerManually: put the files in place
.devin/skills/demo-producer/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add yonatangross/orchestkit --skill demo-producer -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about demo-producer
How to install demo-producer in Claude Code?
Run npx skills add yonatangross/orchestkit --skill demo-producer -a claude-code in your terminal.
What does demo-producer do?
It turns CLI tools, skills, or tutorials into polished videos using scripted terminal recordings and programmatic rendering.
What is required to run demo-producer?
You need VHS version 0.11.0 or higher and Remotion 4.0.448+. Using the --live flag also requires an installed Tailscale CLI.
Source text
SKILL.md · MIT
---
name: demo-producer
license: MIT
compatibility: "Claude Code 2.1.277+."
description: "Demo videos for skills, plugins, CLIs and code walkthroughs: scripts, storyboards, VHS terminal recordings, Remotion. Use when producing a showcase or marketing video."
argument-hint: "[topic-or-feature]"
user-invocable: false
allowed-tools: "AskUserQuestion Bash Read Write Edit Grep Glob Agent TaskCreate TaskUpdate PushNotification"
context: inherit
targets:
- tool: "vhs"
version: ">=0.11.0"
- library: "remotion"
version: ">=4.0.448"
effort: low
model: haiku
metadata:
category: document-asset-creation
version: "1.1.0"
author: "OrchestKit"
complexity: "low"
tags: "demo, video, marketing, vhs, remotion, terminal, showcase, tutorial"
---
# Demo Producer
Universal demo video creation for any content type.
> **Tool versions (2026-Q2):** VHS >= 0.11, Remotion >= 4.0.448. VHS 0.11 added:
>
> - **`Wait` keyword** — supersedes `Sleep N` with a condition-based wait (`Wait "prompt>"` blocks until the given string appears). Use `Wait` over `Sleep` for any prompt that can appear at variable times.
> - **`ScrollUp N` / `ScrollDown N`** — explicit scroll steps inside a recorded session; useful for demonstrating TUI apps and long `less`-style output.
>
> Keep existing `Sleep N` only for fixed visual pacing where no event is available.
## Quick Start
```bash
demo-producer # Interactive mode - asks what to create
demo-producer skill explore # Create demo for a skill
demo-producer plugin ork # Create demo for a plugin
demo-producer tutorial "Building a REST API" # Custom tutorial
demo-producer --live 4 # Live preview via dev --live (4-hour public funnel)
```
## --live mode (M127 #1565)
`--live N` is a thin wrapper around `dev --live N`: it boots the dev stack
behind `portless --funnel` (publicly exposed via Tailscale Funnel), records an
expiry of `N` hours into `.claude/state/live-demos.jsonl`, and prints a public
URL plus `<iframe>` snippet for embedding in customer emails or docs pages.
```bash
demo-producer --live 4
# Internally runs:
dev --live 4
# → public URL: https://app.your-tailnet.ts.net
# iframe: <iframe src="..." />
# expires: 2026-05-03T20:00Z
```
`doctor` warns about live demos older than 24 hours so they don't sprawl.
Tear down with `dev stop`. Tailscale CLI must be installed (only required
behind `--live` — not for static demo recording modes).
## CRITICAL: Task Management is MANDATORY (CC 2.1.16)
**BEFORE doing ANYTHING else, create tasks to track progress:**
```python
# 1. Create main task IMMEDIATELY
TaskCreate(
subject="Demo Producer: {topic}",
description="Creating polished demo video for content showcase",
activeForm="Producing demo for {topic}"
)
# 2. Create subtasks for each production phase
TaskCreate(subject="Content analysis", activeForm="Analyzing content for demo")
TaskCreate(subject="Script & storyboard", activeForm="Generating script and storyboard")
TaskCreate(subject="Record & compose", activeForm="Recording terminal and composing video")
TaskCreate(subject="Final output", activeForm="Rendering final video outputs")
# 3. Set dependencies for sequential phases
TaskUpdate(taskId="3", addBlockedBy=["2"])
TaskUpdate(taskId="4", addBlockedBy=["3"])
TaskUpdate(taskId="5", addBlockedBy=["4"])
# 4. Update status as you progress
TaskUpdate(taskId="2", status="in_progress") # When starting
TaskUpdate(taskId="2", status="completed") # When done
```
## Supported Content Types
| Type | Source | Example |
|------|--------|---------|
| `skill` | skills/{name}/SKILL.md | `demo-producer skill commit` |
| `agent` | agents/{name}.md | `demo-producer agent debug-investigator` |
| `plugin` | plugins/{name}/plugin.json | `demo-producer plugin ork` |
| `marketplace` | Marketplace install flow | `demo-producer marketplace ork` |
| `tutorial` | Custom description | `demo-producer tutorial "Git workflow"` |
| `cli` | Any CLI tool | `demo-producer cli "npm create vite"` |
| `code` | Code walkthrough | `demo-producer code src/api/auth.ts` |
## Interactive Flow
When invoked without arguments, asks 4 questions:
### Question 1: Content Type
```
What type of demo do you want to create?
○ Skill - OrchestKit skill showcase
○ Agent - AI agent demonstration
○ Plugin - Plugin installation/features
○ Tutorial - Custom coding tutorial
○ CLI Tool - Command-line tool demo
○ Code Walkthrough - Explain existing code
```
### Question 2: Format
```
What format(s) do you need?
☑ Horizontal (16:9) - YouTube, Twitter
☑ Vertical (9:16) - TikTok, Reels, Shorts
☐ Square (1:1) - Instagram, LinkedIn
```
### Question 3: Style
```
What style fits your content?
○ Quick Demo (6-10s) - Fast showcase, single feature
○ Standard Demo (15-25s) - Full workflow, multiple steps
○ Tutorial (30-60s) - Detailed explanation, code examples
○ Cinematic (60s+) - Story-driven, high polish
○ Scrapbook (15-35s) - Warm paper, fast cuts, social proof collage (Anthropic style)
○ Code-drawn (15-40s) - Every frame drawn by a storyboard page; skills, agents, gates as moving pictures
```
### Question 4: Audio
```
Audio preferences?
○ Music Only - Subtle ambient background
○ Music + SFX - Background + success sounds
○ Silent - No audio
```
## Pipeline Architecture
> Load details: `Read("references/demo-pipeline.md")` for the full pipeline diagram, generation commands, and output structure.
Content Detector -> Content Analyzer -> Script Generator -> Terminal Script -> VHS Recorder -> Remotion Composer -> Final Outputs (horizontal/vertical/square).
## Code-drawn mode
> Load details: `Read("references/code-drawn-mode.md")` for the contract, the pipeline and what the compare can and cannot catch.
The storyboard page is the renderer: `drawFrame(g, t)` draws every frame, the owner approves the page, and the same code renders the film. Freeze the approved page in `approved-design/`, then:
```bash
python3 scripts/code-drawn/make-film.py storyboard/index.html # film.html, 2x canvas
node scripts/code-drawn/render-frames.mjs <url>/film.html frames # needs Chrome on CDP 9222
python3 scripts/code-drawn/compare.py approved-stills rendered-stills # exit 1 on any mismatch
```
Every string on screen comes from a real capture. The compare samples moments only, so a fresh reviewer still reads strips across every transition.
## Finish line and budget
**Finish line.** Done means: every requested format variant is rendered, written to the output directory, verified with ffprobe (non-zero duration, expected resolution per variant), and the completion PushNotification is sent.
Budget: at most 2 render retries per video, 3 format variants, and 45 minutes wall clock per variant (135 minutes total); stop and report at the finish line or the first cap, whichever comes first, naming the variants still unrendered.
## Template System
Four template architectures for different demo styles. Load `Read("references/template-system.md")` for detailed configuration and the SkillDemoConfig interface.
| Template | Use Case | Duration | Key Feature |
|----------|----------|----------|-------------|
| **TriTerminalRace** | Complexity comparisons | 15-20s | 3-panel split, color-coded difficulty |
| **ProgressiveZoom** | Tutorials, walkthroughs | 20-30s | Zoom transitions, layered reveals |
| **SplitThenMerge** | Before/after, transformations | 15-25s | Split screen -> unified merge |
| **ScrapbookDemo** | Product launches, social proof | 15-35s | Warm paper aesthetic, fast cuts |
Content type templates (skill, agent, plugin, tutorial, cli, code) are mapped in `Read("references/skill-category-mapping.md")`.
## Remotion Composition
> Load details: `Read("references/remotion-composition.md")` for folder structure, adding new compositions, and format variant prefixes.
Compositions organized under `Production/` by format (Landscape, Vertical, Square) and skill category.
## Customization Options
### Visual Themes
- **Dark mode** (default): Dark backgrounds, neon accents
- **Light mode**: Clean whites, subtle shadows
- **Terminal**: Pure terminal aesthetic
- **Cinematic**: High contrast, dramatic lighting
- **Scrapbook**: Warm paper (#F0F0E8), serif typography, fast cuts, mixed media collage
### Audio Presets
- **Ambient**: Subtle background, no SFX
- **Tech**: Electronic beats, UI sounds
- **Corporate**: Professional, clean
- **Energetic**: Upbeat, fast-paced
## PushNotification on Completion (CC 2.1.110+)
VHS recording and Remotion rendering commonly take 10–45 min per video, and full multi-variant productions (landscape + vertical + square) can exceed an hour. **After all output files are written and verified, call `PushNotification`** so the user knows the video is ready for review.
```python
PushNotification(
message=f"ork:demo-producer complete — {topic}: {variants_count} variants · {output_dir}",
status="proactive"
)
```
Full rule: `Read("${CLAUDE_PLUGIN_ROOT}/skills/chain-patterns/rules/push-notification-on-completion.md")`.
## Best Practices
1. **Keep it focused** - One feature/concept per video
2. **Show, don't tell** - Demonstrate actual usage
3. **Use real data** - Show actual command outputs
4. **Include context** - Brief setup before the demo
5. **End with CTA** - Always include install command
## Terminal Simulation Patterns
> Load details: `Read("references/terminal-simulation.md")` for TypeScript patterns: pinned header + scrolling content, agent color palette, and task spinner animation.
## Slop Avoidance
> Load details: `Read("rules/slop-avoidance.md")` for text density rules, timing compression, common slop patterns, and hook styles.
Core rule: If content doesn't earn its screen time, cut it.
## Rules Quick Reference
| Rule | Impact | What It Covers |
|------|--------|----------------|
| analyzer-patterns (load `rules/analyzer-patterns.md`) | MEDIUM | Frontmatter parsing, phase detection, example extraction |
| production-pipeline (load `rules/production-pipeline.md`) | HIGH | Pre-production, storyboarding, recording, VHS, manim |
| production-composition (load `rules/production-composition.md`) | HIGH | Remotion composition, audio mixing, thumbnails, captions |
| slop-avoidance (load `rules/slop-avoidance.md`) | HIGH | Text density, timing compression, hook styles |
## Related Skills
- `video-production`: Full video production pipeline (recording, composition, audio, pacing)
## References
Load on demand with `Read("references/<file>")`:
| File | Content |
|------|---------|
| `template-system.md` | Template architecture and SkillDemoConfig interface |
| `content-types.md` | Detailed content type specs |
| `format-selection.md` | Platform requirements and multi-format support |
| `script-generation.md` | Script templates and generation patterns |
| `demo-pipeline.md` | Pipeline architecture, generation commands, output structure |
| `remotion-composition.md` | Remotion folder structure and composition guide |
| `skill-category-mapping.md` | Skill category mapping and content type templates |
| `code-drawn-mode.md` | Storyboard page as renderer: contract, pipeline, compare limits, lessons |
© OrchestKit · MIT · yonatangross/orchestkit