Skip to main content
skill CX Codex

site-reels — Claude Code skill: what it does, how to install

site-reels is a Claude Code skill that records scripted site interactions into 1080p MP4 videos for Figma Slides and product reels.

MIT ★ 91 updated 2026-11-11

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pedrojaques99/visant-skills-public --skill site-reels -a claude-code
Open on GitHub

What site-reels does

The skill records local web applications via Chrome DevTools Protocol and Puppeteer. The record.mjs script captures scenes at 30fps using x264 encoding while keeping files under 100MB for direct Figma imports. For complex WebGL or 3D sequences, snap.mjs uses timeweb virtual clocks to step frame by frame at 60fps regardless of system load.

Execution requires a visible desktop session with GPU hardware acceleration. Headless Chrome drops back to SwiftShader software rendering, which breaks WebGL frame rates. The utility auto-detects system Chrome, Edge, or Playwright Chromium builds and checks for ffmpeg and ffprobe in system PATH.

Every scene file defines prepare setup actions and act recording steps. Built-in helpers handle smooth easing scroll animations, while an injected stylesheet re-applies UI hiding rules every 100ms to resist React hydration resets.

What it helps with

  • record smooth 1080p MP4 captures of WebGL web pages for Figma decks
  • render deterministic 60fps product footage using virtual clock stepping
  • hide navigation bars and sticky headers during browser screen capture
  • audit rendered video clips for dead frames and file size limits

Example prompts for the agent

  • Run /site-reels to record scene actions defined in scenes.mjs
  • Capture deterministic 60fps WebGL canvas footage using snap.mjs
  • Generate an ffmpeg contact sheet to inspect exported product videos

How to install site-reels

1Skills CLI (Vercel)

npx skills add pedrojaques99/visant-skills-public --skill site-reels -a claude-code

2Manually: put the files in place

~/.claude/skills/site-reels/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/site-reels/

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

Questions about site-reels

How to install site-reels in Claude Code?

Run npx skills add pedrojaques99/visant-skills-public --skill site-reels -a claude-code in your terminal.

What does site-reels do?

It drives a headful browser session through Puppeteer to record scripted site scenes into 1080p MP4 files ready for decks.

What is required to run site-reels?

You need Node.js 18+, Chrome or Chromium, ffmpeg and ffprobe on PATH, and an OS with a GPU and visible desktop.

Source text

SKILL.md · MIT
---
name: site-reels
description: 'Records a site/app''s best scenes (WebGL, 3D, scroll) as 1080p MP4, uploads to Figma Slides, and builds brand/product showreels in Remotion or HyperFrames (logo reveal + branding burst). Use on "record the site scenes", "site video for the deck", "showreel", "launch video", "gerar vídeo do site", "vídeo pro deck", "reel do produto", /site-reels.'
metadata:
  family: video
---

# Site Reels: site → MP4 → deck

## Requirements

| Needed for | What | Check |
|---|---|---|
| everything | Windows, macOS or Linux with a GPU and a visible desktop (Chrome runs headful) | n/a |
| everything | Node.js 18+ | `node -v` |
| everything | ffmpeg + ffprobe on PATH (or `FFMPEG=<full path>`) | `ffmpeg -version` |
| everything | Chrome, Chromium or Edge (auto-detected, see below) | `node -e "import('./scripts/find-chrome.mjs').then(m=>console.log(m.findChrome()))"` |
| `record.mjs` | `puppeteer-core` + `puppeteer-screen-recorder` (npm, in the project) | `npm ls puppeteer-core puppeteer-screen-recorder` |
| `snap.mjs` | `puppeteer-core` + `timesnap` (brings `timeweb`) | `npm ls timesnap` |
| showreel | Remotion project | `npx remotion --version` |
| audits (optional) | ImageMagick | `magick -version` |
| Figma upload | Figma MCP (`use_figma`, `upload_assets`) + skills `figma-use`, `figma-use-slides` | MCP tool list |

**Chrome detection** (`scripts/find-chrome.mjs`, used by `record.mjs` and `snap.mjs`): `CHROME`
env var if set; else installed Chrome/Edge (Windows: Program Files and LocalAppData; macOS:
`/Applications` and `~/Applications`; Linux: `google-chrome`, `chromium`, `microsoft-edge` on PATH);
else the newest `ms-playwright/chromium-<N>` (or `PLAYWRIGHT_BROWSERS_PATH`); else it stops and
tells you how to set `CHROME` or run `npx playwright install chromium`. On Windows it adds
`--use-angle=d3d11`; on other OSes Chrome keeps its default GPU backend.

## What it does

Records scripted scenes of a site running locally and delivers MP4s ready for Figma (1920×1080,
30fps, x264, < 100MB). Validated engine: **puppeteer-core + puppeteer-screen-recorder** (CDP
screencast + ffmpeg). Never screen-record.

## Run

```
mkdir <proj>-reels && cd <proj>-reels && npm init -y && npm i puppeteer-core puppeteer-screen-recorder
mkdir -p scripts && cp <skill-dir>/scripts/{record,find-chrome}.mjs scripts/
cp <skill-dir>/scripts/scenes.example.mjs scenes.mjs   # edit the scenes
# in the site repo: npx next build && npx next start -p 3100   (production build: smoother WebGL)
OUT="<output folder>/Videos" node scripts/record.mjs scenes.mjs [scene ...]
```

Run the scripts **copied into the project**: ESM resolves `puppeteer-core` from the script's
folder, not from the cwd.

Env: `BASE` (default `http://localhost:3100`), `OUT`, `CHROME`, `FFMPEG`, `W`, `H`, `DPR`,
`MOBILE=1` (touch emulation), `KEEP_UI=1` (keeps the nav), `MIN_FPS` (24). Phone 4:5:
`W=360 H=450 DPR=2 MOBILE=1` gives 720x900.

Each scene = `{ name, path, theme?, trim?, crf?, css?, prepare(page, ctx), act(page, ctx) }`.
`prepare` runs before recording (scroll to the section, wait for 3D to load); `act` is what goes
into the video. `ctx` has `wait`, `scrollTo(page, y|selector, ms)` and
`scrollThrough(page, selector|null, ms, from, to)` with easing. Intro that runs on load:
`page.reload()` inside `act` and use `trim` to cut the loading.

Brand script that works: logo/hero intro (light and dark), hero media swap, 3D section with the
camera entering on scroll, immersive route (walk), footer wordmark and one full page pass.
5–7 scenes of 12–55s.

## Audit before delivering (do not trust the exit code)

- Contact sheet per video: `ffmpeg -i x.mp4 -vf "fps=6/<dur>,scale=480:-1,tile=3x2" -frames:v 1 sheet.png` and **look**.
- 1MB for 19s = blank scene. > 100MB = does not go into Figma (scene `crf` fixes it; 24 for a scene with grain + trails).
- Top strip (`crop=1920:120:0:0`) at several times to catch a leaking nav.
- `LOW-FPS` with a long pause at the start/end is a false alarm (the meter counts still frames); check the contact sheet.
- Designed brand films: run the release-level pass in `references/showreel-variants.md` (one palette via `scripts/duo.sh`, a returning motif, real media before faceless stock, no dead frames). Then `blackdetect` the render and patch isolated black frames with `scripts/tapar-pretos.sh`.

## Known pitfalls

1. **Hidden window freezes rAF** → frozen frames. The launch already passes
   `--disable-backgrounding-occluded-windows --disable-renderer-backgrounding
   --disable-background-timer-throttling --disable-features=CalculateNativeWinOcclusion`.
   `headless: false` on purpose: headless falls back to SwiftShader and WebGL stutters.
2. **Hide-UI CSS disappears** on reload and when React hydration clears `<head>` → the script
   re-attaches a `<style id="reels-hide">` to the body every 100ms.
3. **One invalid selector kills the whole rule**: `\[` in a JS template literal becomes `[` and
   `.z-[60]` invalidates `header, nav, .z-[60]`. One rule per risky selector.
4. **Do not hide `[data-cursor]`**: sites tag the 3D canvas and carousels with it. Target the
   custom cursor element (fixed + mix-blend + pointer-events-none).
5. **Lazy-loaded 3D** (IntersectionObserver + dynamic import): wait 5–7s after reaching the
   section. Reading the WebGL canvas comes back empty without `preserveDrawingBuffer`: use a
   fixed wait or a screenshot.
6. Screencast delivers ~32 unique frames/s → **record at 30fps** (60 gives irregular repeated
   frames). Default `trim` 0.3s drops the first cached frame.
7. **Screencast stutters on a loaded machine** (Photoshop open, parallel render): the MP4 says
   "30fps" with 9–18 unique frames/s. `record.mjs` measures (`mpdecimate=hi=64:lo=24:frac=0.05`)
   and re-records up to 2x below `MIN_FPS` (24). For WebGL/3D plates prefer `snap.mjs`.
8. Cookie banner: accept it in `prepare` (generic click on "Accept/Aceitar/OK") before recording.
9. A tool page without scrolling (generator, effect editor) records still: the scene has to
   **interact** (upload a file to `input[type=file]`, click presets by button text). A custom
   slider does not respond to a synthetic `input`.

## 60fps locked plates: `snap.mjs` (deterministic)

`scripts/snap.mjs` injects **timeweb** (timesnap's virtual clock: rAF, performance.now,
setTimeout and video), advances 1/60s per frame and screenshots. Independent of machine load.
Scene: `{ name, path, theme, css, dur, wait (real ms to load 3D), pre (virtual ms before
scrolling, 2000; **0 for an intro that runs on load**), start (virtual s skipped),
scroll: { sel, from, to, at, len } | { bottom: [from, to] in screen heights },
frame(page, t) (e.g. mouse) }`. Scrolling is a function of virtual time.

```
npm i puppeteer-core timesnap && mkdir -p scripts
cp <skill-dir>/scripts/{snap,find-chrome,patch-timeweb}.mjs scripts/
npm pkg set scripts.postinstall="node scripts/patch-timeweb.mjs" && npm run postinstall
FPS=60 OUT=... node scripts/snap.mjs scenes-snap.mjs [scene]
```

- **Do not use `timesnap()` itself**: with Next + R3F + Lenis it recorded a blank page and left
  frozen stretches on the WebGL hero (rAF does not run). The own loop (goTo + scrollTo +
  screenshot) worked everywhere: 60/60 unique frames.
- **timeweb patch is mandatory**: it swaps `video.play()` for a version with no Promise and no
  `playing` event → `video.play().catch()` throws and the page goes blank.
- `preserveDrawingBuffer: true` forced on getContext (turn off with `preserve: false`).
- Frames go to the OS temp dir, never to a synced drive (thousands of jpgs syncing).
- **No GPU work in parallel** (Remotion render, Photoshop): WebGL loses its context and records
  seconds of background only. The script warns `FLASH` (frame flashing by luminance); a long blank
  stretch only shows on the contact sheet. Look.
- Real smoothness audit: `magick compare -metric MAE` between neighbor frames at full resolution.
  0 = repeated frame.
- Delivery: `scripts/deliver.example.sh` (copy and rename the plates; `V=` required) builds
  reveals, loops (`loop.sh`) and clean 3D, raising crf by 3 until < 95MB.

## Upload to Figma Slides (hidden, without disturbing the team)

The MP4 **does not go in through MCP**: `use_figma` has no network and the Plugin API does not
create video from bytes; `upload_assets` only accepts images (≤ 10MB). So:

1. Cover of each video: `ffmpeg -ss <t> -i x.mp4 -frames:v 1 -q:v 2 _capas/x.jpg`.
2. `use_figma` (skills `figma-use` + `figma-use-slides`): `createSlideRow(idx)` before the final
   slide, `row.name = 'WIP · Motion (hidden)'`, one `createSlide(idx, i)` per video with
   `isSkippedSlide = true`, black background, a 1920×1080 rectangle named `VIDEO · x.mp4` and the
   instruction in `speakerNotes`.
3. `upload_assets` with the rectangles' `nodeIds` → multipart POST of the covers.
4. The user drags the MP4 onto the rectangle (replaces the cover with the video). Say this
   clearly; never promise an inserted video.

`getSlideGrid()` omits skipped slides: check the structure via `SLIDE_GRID.children[i].children`.

## Showreel variants

**Before writing the story of any brand showreel, read [brand-showreel-playbook.md](references/brand-showreel-playbook.md):** what the reference films do, the transition grammar, rhythm and music, and the anti-patterns that scored 2/10 (slideshow, invented grids, ray wipes, piano).

Once plates/footage exist, pick the variant that matches the brief. Full
technique for each → [showreel-variants.md](references/showreel-variants.md).

| Brief | Variant |
|---|---|
| Logo, colors, type, layouts, manifesto, mockups — clean plates + Remotion | Brand showreel (Remotion) |
| "Logo reveal / branding film like the Kargul reference", fully designed | Brand film in HyperFrames (code-only) |
| Real app filmed, cursor redrawn on top | Product showreel |
| Site/portfolio cards, studio reel | Portfolio cards and studio reel |

Origin stories, reference projects and machine-specific tips: `references/cases.md`.

## Neighbors

- **[[visant-video-editor]]**: footage from a camera
- **[[visant-premiere-editor]]**: a rough cut in Premiere
- **[[sound-design-de-sfx-para-motion]]**: SFX, break track and stems for the film
- **[[render-e-entrega-de-reels-hyperframes]]**: HyperFrames render, check and delivery

© pedrojaques99 · MIT · pedrojaques99/visant-skills-public

Similar skills

All skills for Frontend and UI →

From the same set12

The whole set →
visant-methodology visant-methodology is a Claude Code skill that builds brand strategy through a 9-stage cascade across 3 phases. Triggers on requests for brand audits, messaging frameworks, or full identity setups. CX Codex +1 ★ 91repo stars visant-design visant-design is a Claude Code skill that redesigns interfaces and checks the result against the running app. It activates for UI/UX improvements, screen redesigns, or requests to remove generic AI styling. CX Codex +1 ★ 91repo stars visant-mcp-connect visant-mcp-connect is a Claude Code skill that connects the agent to Visant Labs over MCP. It activates for requests to set up Visant, use its tools, or extract information from a PDF. CX Codex +1 ★ 91repo stars visant-preflight visant-preflight is a Claude Code skill that runs a stakeholder questionnaire and validates brand assets, fonts, and images before new site builds or redesigns. CX Codex +1 ★ 91repo stars visant-video-editor visant-video-editor is a Claude Code skill that turns raw footage into an edited video by preparing a cut list and assembling approved cuts. It activates for requests to edit a vlog, lesson, or silence in a recording. CX Codex +1 ★ 91repo stars visant-premiere-editor visant-premiere-editor is a Claude Code skill that builds rough cuts in Adobe Premiere Pro from a JSON plan. It transfers timelines through FCP7 XML and MCP without dropping frames. CX Codex +1 ★ 91repo stars visant-refine visant-refine is a Claude Code skill for styling charts, gauges, sparklines, and control panels as parts of one interface. It activates for requests to add a chart, build a simulator slider, or polish a screen. CX Codex +1 ★ 91repo stars visant-copy visant-copy is a Claude Code skill that writes and audits pt-BR copy in Visant's voice, with a linter for AI tics in PT and EN. It fires on requests about headlines or tone of voice. CX Codex +1 ★ 91repo stars

Project sponsors

Companies that keep this analytics open