Communitygithub.com

monogramdesign/skills

Erstellt ein erzähltes Produkt-Demo / Erklärvideo einer laufenden Web-App – Playwright zeichnet eine geführte Tour auf, ElevenLabs synthetisiert die Sprachausgabe und ffmpeg legt die Erzählung über einen sanften Musikteppich (der unter der Stimme abgesenkt wird). Verwende dies, wenn jemand ein KI-vertontes Demo-Video, einen Screencast mit Sprachkommentar, eine Produkt-Walkthrough/-Reel benötigt oder ein bestehendes Demo nach UI-Änderungen neu aufnehmen möchte.

Was ist skills?

Dieses Skill bietet ein vollständig automatisierbares Rezept, um aus einer laufenden Web-App ein professionelles, vertontes Demo-Video im MP4-Format zu erstellen. Es kombiniert ElevenLabs Text-to-Speech (TTS) für die Sprachsynthese, Playwright für die Bildschirmaufnahme einer choreografierten Tour durch die App und ffmpeg für die Nachbearbeitung: Dabei wird die Sprachausgabe zeitlich präzise mit den Szenen verknüpft, ein Hintergrundmusikbett erzeugt und die Musik per Sidechain-Kompression unter der Stimme abgesenkt, sodass die Stimme stets klar verständlich bleibt. Der gesamte Workflow wird durch ein einziges Node.js-Skript gesteuert, das für jedes Demo individuell angepasst wird. Jede Szene wird genau so lange gehalten, wie die dazugehörige Sprachzeile dauert, was aufwändiges manuelles Synchronisieren überflüssig macht. Das Skill ist ideal für Entwickler und Produktteams, die schnell und wiederholbar hochwertige Demo-Videos erstellen möchten, ohne Videobearbeitungssoftware manuell bedienen zu müssen. Unterstützte Plattformen: ElevenLabs (TTS), Playwright (Web-Automatisierung), ffmpeg (Audiovideo-Verarbeitung) und läuft lokal (Node.js).

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/monogramdesign/skills/tree/HEAD/skills/elevenlabs-demo-video

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

ElevenLabs-gestützte Demovideos

Ein wiederholbares Rezept, um aus einer laufenden Web-App ein poliertes, vertontes Demo-mp4 zu erstellen. Ein in sich geschlossenes Node-Skript pro Demo macht alles: Sprachaufnahme synthetisieren, eine choreografierte Tour der App aufzeichnen und Stimme + Musik unter das Filmmaterial mischen. Kein Videobearbeitungsprogramm, keine manuelle Zeitabstimmung.

Die Pipeline

ElevenLabs TTS ──► Erzählung .wav pro Zeile (zwischengespeichert)
                                   │
Playwright  ──► nimmt eine skriptgesteuerte Scroll-/Klick-Tour der live App auf (.webm)
                                   │
ffmpeg      ──► kürzt den Ladevorspann, platziert jede Erzählungszeile an ihrem Szenen-
               Stichwort, erzeugt einen Hintergrundmusikteppich, senkt die Musik unter der
               Stimme ab (Sidechain-Kompression), codiert das finale .mp4

Die Kernidee: Jede Szene hält exakt so lange wie ihre Erzählungszeile, sodass die Stimme immer auf dem richtigen Bild landet – ohne manuelle Synchronisation.

Voraussetzungen

  • Node 18+ und npm i -D playwright (verwendet das installierte Chrome via channel: "chrome" oder wechsle zu gebündeltem Chromium).
  • ffmpeg und ffprobe im PATH.
  • Ein ElevenLabs-API-Key mit Text-to-Speech-Berechtigung (die günstigeren Keys haben oft nicht user_read, verlasse dich also nicht auf den Quota-Endpunkt – versuche einfach TTS).
  • Die App läuft lokal (z.B. npm run dev auf :3000); übergib BASE_URL zum Überschreiben.

Speichere den Key außerhalb von Git (z.B. in einer gitignorierten Datei demo/.eleven.key). Die gerenderten .mp4-Dateien sind groß – ignoriere sie in Git und verteile sie über eine Freigabe (Drive usw.), nicht über das Repository.

Verwendung

  1. Ein Skript pro Demo. Kopiere die Vorlage unten nach demo/build-<name>.mjs. Jedes Skript ist unabhängig und schreibt seine temporären Dateien in demo/<name>-work/.
  2. Schreibe die Erzählung als LINES-Array – wortwörtlich, ein Eintrag pro Szene. Ziel: ~2,3 Wörter/Sekunde bei der Zeitplanung.
  3. Choreografiere die Szenen in actions – ein Eintrag pro Zeile, in derselben Reihenfolge. Eine einfache async-Funktion erstellt ein Standbild; ein {action, hold}-Objekt erstellt das Bild (action) und führt dann eine Schwenk-/Klickbewegung während die Erzählung läuft (hold) aus.
  4. Führe es im VORDERGRUND aus für jedes Demo, das die App steuert (Klicks, Formulareingaben, Identitäts-/Routenwechsel): node demo/build-<name>.mjs. Statische Scroll-Touren können im Hintergrund laufen, aber interaktive Touren können oft nicht auf den Dev-Server zugreifen oder gesteuerte Eingaben aus einer Hintergrund-Sandbox steuern – führe es daher im Zweifelsfall im Vordergrund aus.
  5. Nehme nach UI-Änderungen neu auf. Selektoren sind an das DOM gekoppelt; ein Redesign wird sie brechen. Führe das betroffene Skript erneut aus und überprüfe einen Frame stichprobenartig (ffmpeg -ss <t> -i out.mp4 -frames:v 1 frame.jpg).

Lektionen, die Stunden sparen

  • Erzählung nach Index zwischenspeichern. Jede Zeile ist l<i>.wav; verwende sie wieder, falls vorhanden, sodass Neuaufnahmen keine Credits verbrauchen. Um eine Zeile zu ändern, bearbeite LINES[i] und lösche die entsprechende l<i>.wav. Wenn du eine Zeile in der Mitte der Liste einfügst, verschiebe die zwischengespeicherten WAVs um eine Position nach oben (mv l7.wav l8.wav; mv l6.wav l7.wav; …), sodass nur die neue Zeile synthetisiert wird – die Schleife speichert nach Index zwischen und prüft nicht den Text.
  • Ausfallsicherheit bei Quota. Wenn ein TTS-Aufruf fehlschlägt, falle auf Filmmaterial + Musik ohne Erzählung zurück und schätze die Dauer jeder Zeile anhand der Wortanzahl, sodass der Build immer ein mp4 erzeugt.
  • Kürze den Ladevorspann. Nimm das GoTo/Seed/Hydrate auf, markiere contentStart, sobald die erste Aufnahme stabil ist, und schneide mit -ss contentStart den Anfang ab, sodass das Video mit einem ruhigen Bild beginnt. Die Erzählungsstichworte werden beim Mischen um contentStart verschoben.
  • Halten = max(Erzählung, Schwenk). Bei aktiven Haltevorgängen verlängere auf mindestens die Zeilenlänge, damit die Stimme nie abgeschnitten wird; wenn die Interaktion länger dauert, lass sie laufen.
  • Scharf aufnehmen. Verwende ein großes Viewport (z.B. 1920×1200) und setze document.documentElement.style.zoom (z.B. 1.5) über ein Init-Skript, sodass das logische Layout auf der gewünschten Größe bleibt, der Frame aber schärfer rendert.
  • Abgehacktes Scrollen vermeiden. Feste, vollbilddeckende Overlays mit mix-blend-* (Filmkörnung, Verläufe) erzwingen bei jedem Scroll-Frame eine vollständige Neuberechnung des Bildes. Verstecke sie während der Aufnahme: page.addStyleTag({content: ".grain{display:none!important}"}). Verstecke auch immer sichtbare CTAs/Footer, die du nicht im Bild haben möchtest.
  • Steuere kontrollierte Eingaben robust. Ein React-gesteuertes <select> ignoriert ein einfaches selectOption. Setze es mit dem nativen Setter + einem change-Event, das bubbelt, und wiederhole, bis ein Bestätigungslocator erscheint:
    const setter = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "value").set;
    setter.call(el, value); el.dispatchEvent(new Event("change", { bubbles: true }));
    
  • Verwende typografische Anführungszeichen in Selektoren. Wenn Überschriften geschweifte Anführungszeichen (', ', ") rendern, passt ein Regex mit einem geraden ' nicht. Verwende . für den Apostroph: /Tell us who you.re looking for/i.
  • Lokalisiere Fragen/Felder anhand ihrer Bezeichnung und handle dann innerhalb des Blocks. Robust gegenüber Layoutänderungen: page.locator("label", { hasText: q }).first().locator("xpath=..") dann .getByRole("radio"/"checkbox", { name }) darin.
  • Musikbett + Ducking. Synthetisiere einen loopenden Ambient-Pad aus Sinuswellen-Akkorden mit ffmpeg aevalsrc, dann sidechaincompress die Musik unter der Erzählung, sodass die Stimme immer klar zu hören ist. Halte die Musik bei ca. 0,4 und lasse den Kompressor sie absenken.

Vorlage (demo/build-<name>.mjs)

import { chromium } from "playwright";
import fs from "node:fs";
import path from "node:path";
import { execFileSync } from "node:child_process";

const DIR = path.resolve("demo");
const WORK = path.join(DIR, "name-work");
fs.mkdirSync(WORK, { recursive: true });
const KEY = fs.readFileSync(path.join(DIR, ".eleven.key"), "utf8").trim();
const BASE = process.env.BASE_URL || "http://localhost:3000";
const OUT = path.join(DIR, "name.mp4");
const W = 1920, H = 1200, ZOOM = 1.5;

const sh = (c, a) => execFileSync(c, a, { stdio: ["ignore", "pipe", "pipe"] }).toString();
const probe = (f) => parseFloat(sh("ffprobe", ["-v","error","-show_entries","format=duration","-of","default=noprint_wrappers=1:nokey=1", f]).trim());
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// 1 Zeile pro Szene, in Szenen-Reihenfolge.
const LINES = [
  "Eröffnungszeile – der Aufhänger, gesprochen über das erste ruhige Bild.",
  "Zweite Zeile – erzähle, während die Kamera durch den nächsten Abschnitt schwenkt.",
  "Schlusszeile – ein ruhiger Abschluss.",
];
const TAILS = LINES.map(() => 1.4); // Puffer nach jeder Zeile

// ── ElevenLabs ──────────────────────────────────────────────────────────────
async function voiceId() {
  const r = await fetch("https://api.elevenlabs.io/v1/voices", { headers: { "xi-api-key": KEY } });
  const { voices } = await r.json();
  return (voices.find((v) => v.name.toLowerCase().startsWith("jessica")) || voices[0]).voice_id;
}
async function tts(id, text, out) {
  const r = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${id}?output_format=mp3_44100_128`, {
    method: "POST", headers: { "xi-api-key": KEY, "content-type": "application/json" },
    body: JSON.stringify({ text, model_id: "eleven_multilingual_v2",
      voice_settings: { stability: 0.55, similarity_boost: 0.8, style: 0, use_speaker_boost: true } }),
  });
  if (!r.ok) throw new Error(`tts ${r.status} ${await r.text()}`);
  fs.writeFileSync(out, Buffer.from(await r.arrayBuffer()));
}

// ── Ambient-Musikbett (Am–F–C–G Pad) ────────────────────────────────────────
function buildMusic(total, out) {
  const chords = [[220,261.63,329.63],[174.61,220,261.63],[261.63,329.63,392],[196,246.94,293.66]];
  const CH = 6;
  const files = chords.map((freqs, i) => {
    const expr = freqs.map((f) => `0.17*sin(2*PI*${f}*t)`).join("+");
    const f = path.join(WORK, `chord${i}.wav`);
    sh("ffmpeg", ["-y","-f","lavfi","-i",`aevalsrc=${expr}:duration=${CH}:sample_rate=44100`,
      "-af", `afade=t=in:d=1.4,afade=t=out:st=${CH-1.4}:d=1.4`, f]);
    return f;
  });
  const list = path.join(WORK, "chords.txt");
  fs.writeFileSync(list, files.map((f) => `file '${f}'`).join("\n"));
  const loop = path.join(WORK, "loop.wav");
  sh("ffmpeg", ["-y","-f","concat","-safe","0","-i",list,"-c","copy", loop]);
  const loops = Math.ceil(total / (chords.length * CH)) + 1;
  sh("ffmpeg", ["-y","-stream_loop",String(loops),"-i",loop,"-af",
    ["aecho=0.8:0.88:70|130:0.25|0.18","lowpass=f=2200","tremolo=f=0.12:d=0.25",
     "aformat=channel_layouts=stereo","afade=t=in:d=0.5",
     `afade=t=out:st=${Math.max(0,total-3)}:d=3`,`atrim=0:${total}`].join(","), out]);
}

// ── Choreografie-Hilfsfunktionen ────────────────────────────────────────────
async function smoothTo(page, y, ms) {
  await page.evaluate(({ y, ms }) => new Promise((res) => {
    const s = window.scrollY, d = y - s, t0 = performance.now();
    const e = (t) => (t < 0.5 ? 2*t*t : -1 + (4-2*t)*t);
    const f = (n) => { const p = Math.min(1, (n-t0)/ms); window.scrollTo(0, s + d*e(p)); p < 1 ? requestAnimationFrame(f) : res(); };
    requestAnimationFrame(f);
  }), { y, ms });
}
async function scrollToText(page, text, ms = 1500, offset = 150) {
  const y = await page.evaluate(({ text, offset }) => {
    const all = [...document.querySelectorAll("h1,h2,h3,h4,p,span,button,a,li")].filter((e) => e.getClientRects().length);
    let el = all.find((e) => (e.textContent || "").trim() === text)
          || all.filter((e) => (e.textContent || "").includes(text)).sort((a,b)=>a.textContent.length-b.textContent.length)[0];
    return el ? el.getBoundingClientRect().top + window.scrollY - offset : null;
  }, { text, offset });
  if (y != null) await smoothTo(page, Math.max(0, y), ms);
}

// ── 1) Erzählung synthetisieren (zwischengespeichert), Dauer messen ─────────
const clips = []; let vid = null, narrationOk = true;
for (let i = 0; i < LINES.length; i++) {
  const mp3 = path.join(WORK, `l${i}.mp3`), wav = path.join(WORK, `l${i}.wav`);
  if (fs.existsSync(wav)) { clips.push({ wav, dur: probe(wav) }); continue; }
  try {
    if (!vid) vid = await voiceId();
    await tts(vid, LINES[i], mp3);
    sh("ffmpeg", ["-y","-i",mp3,"-ar","44100","-ac","2", wav]);
    clips.push({ wav, dur: probe(wav) });
  } catch (e) {
    narrationOk = false;
    clips.push({ wav: null, dur: LINES[i].trim().split(/\s+/).length / 2.3 });
  }
}

// ── 2) Aufnehmen, jedes Bild für seine Zeile halten ─────────────────────────
const browser = await chromium.launch({ channel: "chrome", headless: true });
const context = await browser.newContext({ viewport: { width: W, height: H }, recordVideo: { dir: WORK, size: { width: W, height: H } } });
await context.addInitScript((z) => {
  const apply = () => { try { document.documentElement.style.zoom = String(z); } catch {} };
  apply(); document.addEventListener("DOMContentLoaded", apply);
}, ZOOM);
const page = await context.newPage();
page.setDefaultTimeout(20000);
const video = page.video();
const t0 = Date.now();

await page.goto(`${BASE}/`, { waitUntil: "domcontentloaded" });
await page.evaluate(() => (document.fonts ? document.fonts.ready : null));
await page.addStyleTag({ content: ".grain{display:none !important}" }); // Misch-Overlays ausblenden
await sleep(1500);
const contentStart = (Date.now() - t0) / 1000; // alles davor abschneiden

const actions = [
  async () => { await sleep(300); },                                  // stiller Aufhänger
  { action: async () => { await scrollToText(page, "Eine Überschrift"); await sleep(300); },
    hold:   async () => { await smoothTo(page, 1600, Math.max(4000, clips[1].dur*1000)); } }, // Schwenk während der Zeile
  async () => { await smoothTo(page, 0, 2500); await sleep(500); },   // Abschluss
];

const cues = [];
for (let i = 0; i < actions.length; i++) {
  const sc = actions[i];
  const act = typeof sc === "function" ? sc : sc.action;
  const hold = typeof sc === "function" ? null : sc.hold;
  await act();
  cues.push((Date.now() - t0) / 1000);
  if (hold) {
    const start = Date.now();
    await hold();
    const min = clips[i].dur + TAILS[i], elapsed = (Date.now() - start) / 1000;
    if (elapsed < min) await sleep((min - elapsed) * 1000);
  } else {
    await sleep((clips[i].dur + TAILS[i]) * 1000);
  }
}
await sleep(400);
await context.close();
await browser.close();

// ── 3) Muxen: Vorspann kürzen, Erzählung an Stichworten platzieren, Musik ducken ──
const raw = await video.path();
const outDur = probe(raw) - contentStart;
const music = path.join(WORK, "music.wav");
buildMusic(outDur, music);

if (!narrationOk) {
  sh("ffmpeg", ["-y","-ss",String(contentStart),"-i",raw,"-i",music,
    "-filter_complex","[1:a]volume=0.7[a]","-map","0:v","-map","[a]",
    "-c:v","libx264","-preset","medium","-crf","18","-pix_fmt","yuv420p",
    "-c:a","aac","-b:a","192k","-movflags","+faststart","-t",String(outDur), OUT]);
} else {
  const lead = 0.35, narr = path.join(WORK, "narration.wav");
  const inputs = clips.flatMap((c) => ["-i", c.wav]);
  const fc =
    clips.map((c, i) => { const at = Math.max(0, Math.round((cues[i]-contentStart+lead)*1000)); return `[${i}:a]adelay=${at}|${at}[d${i}]`; }).join(";") +
    ";" + clips.map((_, i) => `[d${i}]`).join("") +
    `amix=inputs=${clips.length}:normalize=0:dropout_transition=0[mix];[mix]apad=whole_dur=${outDur},volume=1.25[a]`;
  sh("ffmpeg", ["-y", ...inputs, "-filter_complex", fc, "-map","[a]", narr]);
  sh("ffmpeg", ["-y","-ss",String(contentStart),"-i",raw,"-i",music,"-i",narr,
    "-filter_complex",[
      "[1:a]volume=0.42[m]","[2:a]asplit=2[k][n]",
      "[m][k]sidechaincompress=threshold=0.035:ratio=9:attack=15:release=350[md]",
      "[md][n]amix=inputs=2:normalize=0:duration=longest[a]",
    ].join(";"),
    "-map","0:v","-map","[a]",
    "-c:v","libx264","-preset","medium","-crf","18","-pix_fmt","yuv420p",
    "-c:a","aac","-b:a","192k","-movflags","+faststart","-t",String(outDur), OUT]);
}
console.log(`FERTIG: ${OUT}  (${outDur.toFixed(1)}s)`);

Anpassung

  • Neue Stimme: Ändere den Namensfilter in voiceId() oder hinterlege eine voice_id fest.
  • Interaktive Touren: Füge Hilfsfunktionen wie answerChoice/clickTab hinzu, die auf einen Block per Label eingrenzen und wiederholen, bis ein Bestätigungselement erscheint.

Verwandte Skills