Ui Demo
Record polished UI demo videos using Playwright. Use when the user asks to create a demo, walkthrough, screen recording, or tutorial video of a web application. Produces WebM videos with visible cursor, natural pacing, and professional feel.
Get the complete skill folder, including its scripts and reference files.
·
When to use this skill
Use Ui Demo when an AI agent needs a reusable SKILL.md workflow for this job: Record polished UI demo videos using Playwright. Use when the user asks to create a demo, walkthrough, screen recording, or tutorial video of a web application. Produces WebM videos with visible cursor, natural pacing, and professional feel.
When not to use it
Skip Ui Demo when the task is outside the writing category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/ui-demo # Save SKILL.md to ~/.claude/skills/ui-demo/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/ui-demo/SKILL.md. For a shared project, commit the folder at .claude/skills/ui-demo/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Ui Demo skill for this task: User asks for a "demo video", "screen recording", "walkthrough", or "tutorial". Confirm any required inputs or files before making changes.
What supports this recommendation?
81/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 87/100
- Practical detail
- 92/100
- Source evidence
- 63/100
- Source signals
- 70/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# UI Demo Video Recorder
Record polished demo videos of web applications using Playwright's video recording with an injected cursor overlay, natural pacing, and storytelling flow.
## When to Use
- User asks for a "demo video", "screen recording", "walkthrough", or "tutorial" - User wants to showcase a feature or workflow visually - User needs a video for documentation, onboarding, or stakeholder presentation
## Three-Phase Process
Every demo goes through three phases: **Discover -> Rehearse -> Record**. Never skip straight to recording.
---
## Phase 1: Discover
Before writing any script, explore the target pages to understand what is actually there.
### Why
You cannot script what you have not seen. Fields may be `<input>` not `<textarea>`, dropdowns may be custom components not `<select>`, and comment boxes may support `@mentions` or `#tags`. Assumptions break recordings silently.
### How
Navigate to each page in the flow and dump its interactive elements:
```javascript // Run this for each page in the flow BEFORE writing the demo script const fields = await page.evaluate(() => { const els = []; document.querySelectorAll('input, select, textarea, button, [contenteditable]').forEach(el => { if (el.offsetParent !== null) { els.push({ tag: el.tagName, type: el.type || '', name: el.name || '', placeholder: el.placeholder || '', text: el.textContent?.trim().substring(0, 40) || '', contentEditable: el.contentEditable === 'true', role: el.getAttribute('role') || '', }); } }); return els; }); console.log(JSON.stringify(fields, null, 2)); ```
### What to look for
- **Form fields**: Are they `<select>`, `<input>`, custom dropdowns, or comboboxes? - **Select options**: Dump option values AND text. Placeholders often have `value="0"` or `value=""` which looks non-empty. Use `Array.from(el.options).map(o => ({ value: o.value, text: o.text }))`. Skip options where text includes "Select" or value is `"0"`. - **Rich text**: Does the comment box support `@mentions`, `#tags`, markdown, or emoji? Check placeholder text. - **Required fields**: Which fields block form submission? Check `required`, `*` in labels, and try submitting empty to see validation errors. - **Dynamic content**: Do fields appear after other fields are filled? - **Button labels**: Exact text such as `"Submit"`, `"Submit Request"`, or `"Send"`. - **Table column headers**: For table-driven modals, map each `input[type="number"]` to its column header instead of assuming all numeric inputs mean the same thing.
### Output
A field map for each page, used to write correct selectors in the script. Example:
```text /purchase-requests/new: - Budget Code: <select> (first select on page, 4 options) - Desired Delivery: <input type="date"> - Context: <textarea> (not input) - BOM table: inline-editable cells with span.cursor-pointer -> input pattern - Submit: <button> text="Submit"
/purchase-requests/N (detail): - Comment: <input placeholder="Type a message..."> supports @user and #PR tags - Send: <button> text="Send" (disabled until input has content) ```
---
## Phase 2: Rehearse
Run through all steps without recording. Verify every selector resolves.
### Why
Silent selector failures are the main reason demo recordings break. Rehearsal catches them before you waste a recording.
### How
Use `ensureVisible`, a wrapper that logs and fails loudly:
```javascript async function ensureVisible(page, locator, label) { const el = typeof locator === 'string' ? page.locator(locator).first() : locator; const visible = await el.isVisible().catch(() => false); if (!visible) { const msg = `REHEARSAL FAIL: "${label}" not found - selector: ${typeof locator === 'string' ? locator : '(locator object)'}`; console.error(msg); const found = await page.evaluate(() => { return Array.from(document.querySelectorAll('button, input, select, textarea, a')) .filter(el => el.offsetParent !== null) .map(el => `${el.tagName}[${el.type || ''}] "${el.textContent?.trim().substring(0, 30)}"`) .join('\n '); }); console.error(' Visible elements:\n ' + found); return false; } console.log(`REHEARSAL OK: "${label}"`); return true; } ```
### Rehearsal script structure
```javascript const steps = [ { label: 'Login email field', selector: '#email' }, { label: 'Login submit', selector: 'button[type="submit"]' }, { label: 'New Request button', selector: 'button:has-text("New Request")' }, { label: 'Budget Code select', selector: 'select' }, { label: 'Delivery date', selector: 'input[type="date"]:visible' }, { label: 'Description field', selector: 'textarea:visible' }, { label: 'Add Item button', selector: 'button:has-text("Add Item")' }, { label: 'Submit button', selector: 'button:has-text("Submit")' }, ];
let allOk = true; for (const step of steps) { if (!await ensureVisible(page, step.selector, step.label)) { allOk = false; } } if (!allOk) { console.error('REHEARSAL FAILED - fix selectors before recording'); process.exit(1); } console.log('REHEARSAL PASSED - all selectors verified'); ```
### When rehearsal fails
1. Read the visible-element dump. 2. Find the correct selector. 3. Update the script. 4. Re-run rehearsal. 5. Only proceed when every selector passes.
---
## Phase 3: Record
Only after discovery and rehearsal pass should you create the recording.
### Recording Principles
#### 1. Storytelling Flow
Plan the video as a story. Follow user-specified order, or use this default:
- **Entry**: Login or navigate to the starting point - **Context**: Pan the surroundings so viewers orient themselves - **Action**: Perform the main workflow steps - **Variation**: Show a secondary feature such as settings, theme, or localization - **Result**: Show the outcome, confirmation, or new state
#### 2. Pacing
- After login: `4s` - After navigation: `3s` - After clicking a button: `2s` - Between major steps: `1.5-2s` - After the final action: `3s` - Typing delay: `25-40ms` per character
#### 3. Cursor Overlay
Inject an SVG arrow cursor that follows mouse movements:
```javascript async function injectCursor(page) { await page.evaluate(() => { if (document.getElementById('demo-cursor')) return; const cursor = document.createElement('div'); cursor.id = 'demo-cursor'; cursor.innerHTML = `<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"> <path d="M5 3L19 12L12 13L9 20L5 3Z" fill="white" stroke="black" stroke-width="1.5" stroke-linejoin="round"/> </svg>`; cursor.style.cssText = ` position: fixed; z-index: 999999; pointer-events: none; width: 24px; height: 24px; transition: left 0.1s, top 0.1s; filter: drop-shadow(1px 1px 2px rgba(0,0,0,0.3)); `; cursor.style.left = '0px'; cursor.style.top = '0px'; document.body.appendChild(cursor); document.addEventListener('mousemove', (e) => { cursor.style.left = e.clientX + 'px'; cursor.style.top = e.clientY + 'px'; }); }); } ```
Call `injectCursor(page)` after every page navigation because the overlay is destroyed on navigate.
#### 4. Mouse Movement
Never teleport the cursor. Move to the target before clicking:
```javascript async function moveAndClick(page, locator, label, opts = {}) { const { postClickDelay = 800, ...clickOpts } = opts; const el = typeof locator === 'string' ? page.locator(locator).first() : locator; const visible = await el.isVisible().catch(() => false); if (!visible) { console.error(`WARNING: moveAndClick skipped - "${label}" not visible`); return false; } try { await el.scrollIntoViewIfNeeded(); await page.waitForTimeout(300); const box = await el.boundingBox(); if (box) { await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2, { steps: 10 }); await page.waitForTimeout(400); } await el.click(clickOpts); } catch (e) { console.error(`WARNING: moveAndClick failed on "${label}": ${e.message}`); return false; } await page.waitForTimeout(postClickDelay); return true; } ```
Every call should include a descriptive `label` for debugging.
#### 5. Typing
Type visibly, not instant-fill:
```javascript async function typeSlowly(page, locator, text, label, charDelay = 35) { const el = typeof locator === 'string' ? page.locator(locator).first() : locator; const visible = await el.isVisible().catch(() => false); if (!visible) { console.error(`WARNING: typeSlowly skipped - "${label}" not visible`); return false; } await moveAndClick(page, el, label); await el.fill(''); await el.pressSequentially(text, { delay: charDelay }); await page.waitForTimeout(500); return true; } ```
#### 6. Scrolling
Use smooth scroll instead of jumps:
```javascript await page.evaluate(() => window.scrollTo({ top: 400, behavior: 'smooth' })); await page.waitForTimeout(1500); ```
#### 7. Dashboard Panning
When showing a dashboard or overview page, move the cursor across key elements:
```javascript async function panElements(page, selector, maxCount = 6) { const elements = await page.locator(selector).all(); for (let i = 0; i < Math.min(elements.length, maxCount); i++) { try { const box = await elements[i].boundingBox(); if (box && box.y < 700) { await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2, { steps: 8 }); await page.waitForTimeout(600); } } catch (e) { console.warn(`WARNING: panElements skipped element ${i} (selector: "${selector}"): ${e.message}`); } } } ```
#### 8. Subtitles
Inject a subtitle bar at the bottom of the viewport:
```javascript async function injectSubtitleBar(page) { await page.evaluate(() => { if (document.getElementById('demo-subtitle')) return; const bar = document.createElement('div'); bar.id = 'demo-subtitle'; bar.style.cssText = ` position: fixed; bottom: 0; left: 0; right: 0; z-index: 999998; text-align: center; padding: 12px 24px; background: rgba(0, 0, 0, 0.75); color: white; font-family: -apple-system, "Segoe UI", sans-serif; font-size: 16px; font-weight: 500; letter-spacing: 0.3px; transition: opacity 0.3s; pointer-events: none; `; bar.textContent = ''; bar.style.opacity = '0'; document.body.appendChild(bar); }); }
async function showSubtitle(page, text) { await page.evaluate((t) => { const bar = document.getElementById('demo-subtitle'); if (!bar) return; if (t) { bar.textContent = t; bar.style.opacity = '1'; } else { bar.style.opacity = '0'; } }, text); if (text) await page.waitForTimeout(800); } ```
Call `injectSubtitleBar(page)` alongside `injectCursor(page)` after every navigation.
Usage pattern:
```javascript await showSubtitle(page, 'Step 1 - Logging in'); await showSubtitle(page, 'Step 2 - Dashboard overview'); await showSubtitle(page, ''); ```
Guidelines:
- Keep subtitle text short, ideally under 60 characters. - Use `Step N - Action` format for consistency. - Clear the subtitle during long pauses where the UI can speak for itself.
## Script Template
```javascript 'use strict'; const { chromium } = require('playwright'); const path = require('path'); const fs = require('fs');
const BASE_URL = process.env.QA_BASE_URL || 'http://localhost:3000'; const VIDEO_DIR = path.join(__dirname, 'screenshots'); const OUTPUT_NAME = 'demo-FEATURE.webm'; const REHEARSAL = process.argv.includes('--rehearse');
// Paste injectCursor, injectSubtitleBar, showSubtitle, moveAndClick, // typeSlowly, ensureVisible, and panElements here.
(async () => { const browser = await chromium.launch({ headless: true });
if (REHEARSAL) { const context = await browser.newContext({ viewport: { width: 1280, height: 720 } }); const page = await context.newPage(); // Navigate through the flow and run ensureVisible for each selector. await browser.close(); return; }
const context = await browser.newContext({ recordVideo: { dir: VIDEO_DIR, size: { width: 1280, height: 720 } }, viewport: { width: 1280, height: 720 } }); const page = await context.newPage();
try { await injectCursor(page); await injectSubtitleBar(page);
await showSubtitle(page, 'Step 1 - Logging in'); // login actions
await page.goto(`${BASE_URL}/dashboard`); await injectCursor(page); await injectSubtitleBar(page); await showSubtitle(page, 'Step 2 - Dashboard overview'); // pan dashboard
await showSubtitle(page, 'Step 3 - Main workflow'); // action sequence
await showSubtitle(page, 'Step 4 - Result'); // final reveal await showSubtitle(page, ''); } catch (err) { console.error('DEMO ERROR:', err.message); } finally { await context.close(); const video = page.video(); if (video) { const src = await video.path(); const dest = path.join(VIDEO_DIR, OUTPUT_NAME); try { fs.copyFileSync(src, dest); console.log('Video saved:', dest); } catch (e) { console.error('ERROR: Failed to copy video:', e.message); console.error(' Source:', src); console.error(' Destination:', dest); } } await browser.close(); } })(); ```
Usage:
```bash # Phase 2: Rehearse node demo-script.cjs --rehearse
# Phase 3: Record node demo-script.cjs ```
## Checklist Before Recording
- [ ] Discovery phase completed - [ ] Rehearsal passes with all selectors OK - [ ] Headless mode enabled - [ ] Resolution set to `1280x720` - [ ] Cursor and subtitle overlays re-injected after every navigation - [ ] `showSubtitle(page, 'Step N - ...')` used at major transitions - [ ] `moveAndClick` used for all clicks with descriptive labels - [ ] `typeSlowly` used for visible input - [ ] No silent catches; helpers log warnings - [ ] Smooth scrolling used for content reveal - [ ] Key pauses are visible to a human viewer - [ ] Flow matches the requested story order - [ ] Script reflects the actual UI discovered in phase 1
## Common Pitfalls
1. Cursor disappears after navigation - re-inject it. 2. Video is too fast - add pauses. 3. Cursor is a dot instead of an arrow - use the SVG overlay. 4. Cursor teleports - move before clicking. 5. Select dropdowns look wrong - show the move, then pick the option. 6. Modals feel abrupt - add a read pause before confirming. 7. Video file path is random - copy it to a stable output name. 8. Selector failures are swallowed - never use silent catch blocks. 9. Field types were assumed - discover them first. 10. Features were assumed - inspect the actual UI before scripting. 11. Placeholder select values look real - watch for `"0"` and `"Select..."`. 12. Popups create separate videos - capture popup pages explicitly and merge later if needed.
Intended uses
- User asks for a "demo video", "screen recording", "walkthrough", or "tutorial"
- User wants to showcase a feature or workflow visually
- User needs a video for documentation, onboarding, or stakeholder presentation
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.