Skip to content
Skillpedia
Video editing280k · #302

ui-demo

Has your agent record polished UI demo videos. Useful for creating tutorials or showing how a web app works.

What it does

This tool creates polished demo videos of web applications. It records your screen with a visible cursor and natural pacing, making it look like a professional presentation.

When to use it

  • ✓When you ask for a demo video, screen recording, or tutorial.
  • ✓When you want to visually show how a feature or workflow works.
  • ✓When you need a video for documentation or to present to others.

Example of what to ask your AI

“Create a video showing how to fill out the purchase request form.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/affaan-m/ECC/blob/main/skills/ui-demo/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/affaan-m/ECC/blob/main/skills/ui-demo/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool first explores the page to understand the elements (fields, buttons). Then, it rehearses the steps without recording to ensure everything works. Finally, it records the video following a story, with natural pauses.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add affaan-m/ECC --skill ui-demo

Or download just the file:

curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/skills/ui-demo/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

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:

// 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:

/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:

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

const steps = [
  { label: 'Login email field', selector: '#email' },
  { label: 'Login submit', selector: 'button[type="submit"]' },

…
FAQ

What is 'Playwright'?

It's a tool that allows automating actions in web browsers, like clicking buttons or filling forms, to create videos or tests.

What does 'polished' mean?

It means the video will have a professional look, with a visible cursor and pacing that is neither too fast nor too slow.

Why rehearse before recording?

To make sure all the buttons and fields the tool needs to interact with are found correctly. If something fails during rehearsal, the video might not be recorded properly.

Details

Original description by the author

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.

repo: affaan-m/ECC

Popularity

GitHub stars
280k
Ranking position
#302
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills