Przejdź do treści
Biblioteka skilli
Marketing i treści · Budowanie i kod

make-video

/make-video

Zamienia prosty opis w wideo 1080p MP4 z lektorem i napisami, np. szkolenie, instruktaż lub prezentację produktu.

Repozytorium
video-studio ↗
Licencja
MIT
Ostatnia zmiana repozytorium
30.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
14
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 30.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Zamienia prosty opis w wideo 1080p MP4 z lektorem i napisami, np. szkolenie, instruktaż lub prezentację produktu.

Wyzwalacze z opisu

make a marketing video for example.comI need a training video on how X worksexplain what our product does
Oryginalny opis (EN)

Turn a plain-language request ("make a marketing video for example.com", "I need a training video on how X works", "explain what our product does") into a narrated, captioned 1080p MP4 in this repo. Use when the user asks for any video (training, tutorial, walkthrough, explainer, marketing, product) or to change or re-render an existing one in videos/.

Jak działa

  1. 0. Privacy
  2. 1. Understand the request and gather sources
  3. 2. Design the look
  4. 3. Plan the script
  5. 4. Write videos/<id>/video.json
  6. 5. Voice
  7. 6. Visuals: videos/<id>/Video.tsx and videos/<id>/index.ts
  8. 7. Storyboard and the distinctiveness check
  9. 8. Render and verify
  10. 9. Hand-off
Sekcje z nagłówków SKILL.md, w oryginale · 441 linii, 4 386 słów
Podgląd SKILL.md
---
name: make-video
description: Turn a plain-language request ("make a marketing video for example.com", "I need a training video on how X works", "explain what our product does") into a narrated, captioned 1080p MP4 in this repo. Use when the user asks for any video (training, tutorial, walkthrough, explainer, marketing, product) or to change or re-render an existing one in videos/.
---

# Make a video

You are the whole pipeline: researcher, art director, script writer, voice producer, motion designer and QA.
The user gives a request, often a single line. You hand back `out/<id>/<id>-v<N>.mp4` that you have rendered
and looked at.

Every video gets its own look, decided from its subject, audience, purpose, brand and tone. You decide the
design yourself: never ask the user to pick a style. In the hand-off you name the look you chose and two
others that would also fit, so they can ask for one.

The public examples are `videos/openclaw/` and `videos/getting-started/`. They teach the mechanics only:
how audio is wired, how scenes are timed, how an animation is tied to a spoken word. Do not start a new video
from either of them or from any other video in `videos/`: do not copy its `Video.tsx`, its helpers, its palette
or its layout. A helper that turns out to be generally useful belongs in `src/kit/`, not in a copy.

## 0. Privacy

`videos/*`, `out/*` and `series/*` are git-ignored except the two examples and `series/demo/`, because videos
and series usually contain client material. Keep every file for a video inside `videos/<id>/`, never commit
one, and never move one into a tracked folder. Screenshots of real apps can show personal data (names, phone
numbers, emails): blur it or use demo data before the user shares the video, and say so in your reply.

## 1. Understand the request and gather sources

Pick a video id (kebab-case). Work out three things, and ask only when the request leaves one open and a
wrong guess would waste a render:

- **Kind.** *Training/tutorial*: how to do a task, step by step, plain and calm. *Explainer*: how something
  works. *Marketing*: what a product does for its users, confident and benefit-led, written as a working
  product in the present tense.
- **Audience.** Who watches it, and what they already know.
- **Sources.** Every fact in the video comes from one of these:
  - A public website: `pnpm capture-site <id> <url> [<url> ...]` saves a screenshot, a full-page screenshot
    and the visible text of each page to `videos/<id>/research/`. Read the `.txt` files. Capture the home
    page plus the pages that explain the product (features, how it works, pricing only if the user wants
    prices in the video). Use WebFetch for pages that need no screenshot.
  - A codebase or docs folder: read its README and docs. Delegate wide reading to a subagent and keep the
    conclusions.
  - A running app: capture real screenshots (see "App walkthroughs" below).
  - Files the user attaches: transcripts, PDFs, decks.

Write `videos/<id>/NOTES.md`: the request, the sources you used, and every assumption. It stays with the
video and tells the next session what this video rests on.

Rules for content:
- State only what the sources say. That includes decorative numbers on screen (counts, uptimes, prices).
- Marketing: no invented customers, quotes, testimonials, metrics or awards. Leave out anything the
  sources mark as planned or beta unless the user says to include it.
- Real people in sources (support transcripts, team pages) stay out of the video unless the user asks.
- Product UI only ever comes from real screenshots. Never draw a fake version of a real app screen.

## 2. Design the look

Before the script, decide how this video looks. Skip to "Series" below when the request names a series
("the next video in the onboarding series") or says "same style as <id>".

**Inputs.** The subject, the audience, the purpose (training, marketing, explainer), the tone, and the brand:

- `videos/<id>/research/brand.json`, when the capture wrote one: the site's colours with their CSS role
  (`background`, `surface`, `text`, `muted`, `link`, `button`, `accent`, `border`) and `share` (how much of
  the page uses each, sorted high to low), its fonts with their role and whether each is on Google Fonts
  (`googleFont`), and `logo`, `favicon` and `ogImage` paths (relative to `videos/<id>/`, or `null`).
  A missing `brand.json` is normal: work from the screenshots and the text.
- A brand font that is not on Google Fonts: use the nearest Google family, unless the user supplied the
  font files, which then go in `videos/<id>/assets/` as a local font token.
- Use a logo only from the brand's own site or files.

**Pick a look.** Read `.claude/skills/make-video/looks/README.md` and the entries that could fit. A look is a
starting vocabulary, not a template: adapt it to this content, mix two, or invent your own. Choose two
alternates while you are at it; they go in the hand-off.

**Write `videos/<id>/design.md`** (about one page):

- the look and why it fits this subject, audience and brand
- the palette, with where each colour came from (`brand.json` role and share, a screenshot, or chosen)
- the type pairing (display, body, mono) and why
- the layout grammar: where content sits, how dense, what repeats
- title treatment, caption treatment, motion preset, default transition and any per-scene overrides
- two or three recurring devices that belong to this subject (not to the look in general)
- the two alternates, one line each

**Write the `design` block in `video.json`** (schema: `src/video/design.ts`). Only `look`, `palette` and
`fonts` are required; everything else has a default.

```json
"design": {
  "look": "blueprint",
  "palette": { "bg": "#0f2a4a", "surface": "#13355d", "fg": "#e8f1ff", "muted": "#8fb0d9", "line": "#3f6a9c", "accent": "#ffd166", "accents": ["#7bdff2"] },
  "fonts": { "display": { "family": "IBM Plex Mono", "weights": [500, 700] }, "body": { "family": "IBM Plex Sans", "weights": [400, 700] } },
  "type": { "titleCase": "upper", "titleTracking": 0.06, "titleScale": 0.9 },
  "shape": { "radius": 2, "stroke": 2, "shadow": "none" },
  "background": { "kind": "grid", "size": 48 },
  "motion": "mechanical",
  "transition": { "kind": "wipe", "frames": 16, "direction": "left" },
  "title": "lowerThird",
  "caption": "strip",
  "logo": { "src": "research/brand/logo.svg", "placement": "top-right", "height": 56 }
}
```

- **Fonts:** any Google Fonts family by its exact name with the weights it has, or local files:
  `{ "family": "Brand Sans", "files": [{ "src": "assets/BrandSans-Bold.woff2", "weight": 700 }] }`.
  `pnpm render` checks every family, weight and file before it bundles.
- **Titles:** `banner` (top-left badge and headline), `hero` (centred, then clears), `lowerThird`, `rail`
  (left column), `kinetic` (full-screen words, then clears), `none`. A scene can override with `"title"`.
- **Captions:** `pill`, `strip` (full-width band), `outline` (plain text with a ring), `highlight` (marks
  the word being spoken). Captions are always burned in and the `.srt` is always written.
- **Motion:** `calm`, `snappy`, `bouncy`, `mechanical`: each sets easing, spring, stagger and entrance style.
- **Transitions:** `cut`, `crossfade`, `wipe`, `push`, `zoom`, `iris`, with `frames` and `direction`.
  A scene can override the transition into it with `"transition"`.
- **Background:** `solid`, `gradient`, `grid`, `dots`, `grain`, `texture` (an image `src`), plus `grain`
  0-0.4 on any of them.

To see every treatment, run `pnpm gallery` (stills in `out/kit-gallery/`) or open `kit-gallery` in
`pnpm studio`.

### Series

A series is a saved look, in `series/<name>/`: `design.json` (the tokens), `design.md` (the direction and
its continuity rules), `series.json` (the voice and where it came from), `components/` (series parts such as
an intro card) and `assets/` (logos, font files). `series/demo/` is the tracked example.

When the request names a series, or says "same style as <id>" (export that video's look first, see below;
when its `video.json` already names a series, use that series instead):

```bash
pnpm series:use <name> <id>     # copies the tokens, components, brand files and design.md into videos/<id>/
```

The episode copies the series: `video.json` gets the `design` block and `"series": "<name>"`, and the files
land in `videos/<id>/`. Skip look selection. Read the series `design.md` and keep everything its Continuity
section fixes (palette, fonts, title and caption treatment, intro and outro, transitions, voice, kicker
convention, logo placement). Vary only what it allows. Note the series in `NOTES.md`.

To save a look as a series (when the user asks, or for "same style as <id>"). If `<id>` has no design block
(the two public examples and videos made before design blocks), first write one into its `video.json` that
matches how it looks, starting from the closest entry in the looks library (`neon-3d` for openclaw, `flat-2d`
for getting-started), then export:

Series parts, such as an intro or outro card, go in `videos/<id>/components/` before you export: export
copies every `.ts` and `.tsx` file directly in that folder (not subfolders) to `series/<name>/components/`, and `series:use`
copies them into each episode's `videos/<id>/components/`. `Video.tsx` imports them from `./components/...`.
They import the kit as `../../../src/kit/...`, which resolves from both folders. Only those files travel:
an image a part needs must be a design file (the logo, a font, a texture).

```bash
pnpm series:export <id> <name>  # writes series/<name>/ from videos/<id>/, and sets "series": "<name>" in its video.json
```

The source video becomes the series' first episode, so `pnpm compare` on the next episode finds it. The two
public examples are the exception: export never writes a series name into a tracked file.
`series/<name>/design.md` starts with a Continuity section generated from the design block and the scenes,
per-scene title and transition overrides included, then quotes the source video's `design.md` under "Notes
from the source video". Those notes are that video's own prose and bind no other episode. Read the file and
tighten the Continuity section into real rules.

## 3. Plan the script

- 4-8 scenes, 45-120 seconds unless the user says otherwise. One idea per scene.
- Training arc: what you'll do / each step / done. Explainer: what it is / the parts / how they fit /
  recap. Marketing: the problem / what the product does / how it works / the result / call to action
  (the site's own call to action, e.g. "Book a demo at example.com").
- Narration: plain spoken English, 125-155 words per minute, short sentences. Each scene's narration is
  one voice clip.
- Each scene's narration opens with its heading as a phrase of its own, then a slight pause, then the body:
  "Answer by message. When someone asks...". Say the heading the way the screen shows it, so the spoken
  and on-screen headings match. Mark it with `spokenHeading` (section 4); the pause is the kit's default.
  A scene with no heading (an intro line, a call to action) needs no mark.
- Pause inside a scene where a listener needs a beat: after a question the next sentence answers, before
  a change of subject ("...save your work. Locked out? Call..."), before the closing line. Mark each with
  `pauses` (section 4). A full stop alone often gives no audible gap.
- Give the viewer a moment before the first words: hold about a second on the opening scene
  (`timing.openingLeadInSeconds`) rather than speaking over its first frame.

## 4. Write `videos/<id>/video.json`

Schema: `src/video/schema.ts`. After `pnpm series:use` the file already holds `id`, `series`, `design` and
`voice`: edit it and keep those. Each scene has `id`, `narration`, and optional `kicker` (small label, e.g.
"Step 2 · Upload the file"), `headline` (one line on screen), `minSeconds`, `title` and `transition`. The
title treatment draws `kicker` and `headline`. Leave them out when the scene speaks for itself, or when its
title treatment is `none` and the scene does not draw them itself (a look may show the kicker as a window-tab
label, say). In a series, follow the Continuity section's kicker rule. Copy `voice`
from the OpenClaw example unless the user asks for another voice or the series sets one. For the free voice
(no ElevenLabs key, or the user asks for it), use `"voice": { "provider": "kokoro", "voice": "af_heart" }`. Put the user's
original request in `brief`.

`spokenHeading` is the scene's heading exactly as its narration starts ("Answer by message."); it must be the
start of `narration`, with more narration after it. The kit holds a pause after it of `timing.headingPauseSeconds`
(default 0.6, on top of the voice's own short gap), which a scene can change with `headingPauseSeconds` (0 turns it
off). `pauses` holds more pauses inside the scene: `[{ "after": "save your work." }, { "after": "Locked out?", "seconds": 0.8 }]`.
Each `after` is whole words found once in `narration`, followed by a space (after any punctuation) and more
narration; `seconds` defaults to `timing.headingPauseSeconds`, and 0 turns that pause off. Other `timing` fields: `leadInSeconds` (0.35) before each scene's narration, `openingLeadInSeconds` for the
first scene only (defaults to `leadInSeconds`), `tailSeconds` (0.9) after it, and `outroSeconds` (2) on the last
scene. To slow a whole video, raise these and lower the voice's `speed` (section 5) before rewriting the script.

## 5. Voice

```bash
pnpm voice <id>                      # video.json's voice; ElevenLabs needs ELEVENLABS_API_KEY in the environment
pnpm voice <id> --kokoro             # one-off: the free offline Kokoro voice, video.json unchanged
pnpm voice <id> --kokoro=bm_george   # the same with another Kokoro voice
pnpm voice <id> --placeholder        # silent clips sized to the text, no key needed
```

Clips are cached by a hash of text + voice, so only new or reworded scenes spend ElevenLabs credits. If the
key is exported in a shell profile that non-interactive shells skip (such as `~/.bashrc`), load just that
line, e.g. `eval "$(grep '^export ELEVENLABS_API_KEY=' ~/.bashrc)"`. Never write the key into a file.

**No ElevenLabs key?** Do not stop. Tell the user the key is missing and offer the free Kokoro voice: a
one-off `pnpm voice <id> --kokoro` to test the video without spending credits, or
`"voice": { "provider": "kokoro", "voice": "af_heart" }` in video.json to keep it. Never switch silently.

**Kokoro** (Kokoro-82M, Apache-2.0) runs on this machine's CPU in Node, so it needs nothing beyond Node, pnpm
and ffmpeg. The first run installs its engine (onnxruntime-node and phonemizer, about 300 MB, locked in
`scripts/kokoro-engine/`) and downloads about 330 MB of model into `~/.cache/video-studio/kokoro` (or
`$KOKORO_CACHE_DIR`); later runs are offline. It voices at about twice real time on 8 cores. Its clips are real
narration: full renders accept them, and `pnpm render` prints which voice narrated the video. Settings in video.json:
`voice` (default `af_heart`; the first letter is the language, `a` US English, `b` British English; voices are
listed at <https://huggingface.co/hexgrad/Kokoro-82M/blob/main/VOICES.md>), `speed` (0.5 to 2, default 1)
and `lang` (an espeak language code, normally left out). A wrong name fails with the list of voices. Only English
works: the phonemizer has no other language, so a voice in another one (`ef_dora`, say) fails with the languages
it has, unless `lang` names one of them.

**One-off `--kokoro`** records the Kokoro voice in `voice.json` as `override`, so previews and renders work
without touching video.json, and `pnpm render` warns that the video is not in video.json's voice. Run plain
`pnpm voice <id>` to go back. Scenes voiced with ElevenLabs before are still in `audio/`, so they come back
`cached` with no key; any others need the key. Kokoro and ElevenLabs clips never share a cache key.

**Pace.** To slow the voice itself, set `"speed"` in the ElevenLabs `settings` (0.7 to 1.2, default 1; about 0.9 is
calmer without dragging) or Kokoro's `speed`. A new speed is a new voice, so every clip is voiced again.

`pnpm voice` writes `videos/<id>/voice.json` with each clip's duration and character timings. Real audio
durations set each scene's length; never speed speech up to fit. Placeholder clips let you build and
preview scenes first; `pnpm render <id> --preview` renders them, and a full render refuses until real
narration exists. Changing the voice or its settings needs a fresh `pnpm voice`.

**Reusing narration.** To give a video the narration of another one (a re-cut, a new look, an episode with
the same lines), copy the other video's `audio/` folder into `videos/<id>/`, then run `pnpm voice <id>`.
The cache key is the text and the voice, so every scene whose narration and voice match finds its clip and
its word timings. When all of them match, no key is needed. That run writes this video's `voice.json`. Do not
copy `voice.json` itself: a copied one names the source in `"videoId"`, and the video does not load until
`pnpm voice <id>` rewrites it.

**Pauses.** For each scene's `spokenHeading` and each `pauses` phrase, `pnpm voice` finds the gap the voice left
after it (from the word timings, else the nearest silence) and records where to cut the clip in `voice.json`
(`heading cut at 1.60s`, `"save your work." cut at 3.10s`). The clip itself is not changed, so pause lengths can change
without re-voicing, but a new or edited `spokenHeading` or `pauses` phrase, or a new `fps`, needs `pnpm voice <id>`
again (a stale one stops the video loading). The timeline plays the clip up to each cut, holds the pause and plays
on; `phraseFrame`, `wordFrame` and captions shift with it, and a caption never runs across a pause. In `Video.tsx`, use `narrationEndFrame(scene, fps)` for the end of a
scene's speech, not `audioFrom + audioSeconds * fps`, which ignores the pause. When no gap is found the run
prints `pause: NONE` for it (`heading pause: NONE` for the heading) and the scene plays on without that pause. `pnpm render` warns about that, and about any cut
it is unsure of (no silence at the gap, or no word timings); listen to those scenes. `spokenHeading` must be whole
words followed by a space ("Answer by message," before " when" is fine, "message—when" is not), and a scene's `headingPauseSeconds` needs one. If no gap is found, end the phrase with a full stop
("Answer by message." rather than "Answer by message, when...") and voice it again.

**Adopted clips** are audio files from outside ElevenLabs (a recording, say), brought in with
`pnpm voice <id> --adopt <sceneId>=<file.mp3>`. The scene's narration must still say what the file says.

**Word timings.** ElevenLabs and Kokoro clips carry character timings, so effects can land on an exact word.
Kokoro times each sound; `pnpm voice` lines those up with the words of the narration (it prints
`timing: exact`). If they cannot be lined up, the clip gets none, and the run that voiced it says why. Adopted or
placeholder clips have none (`voice.json` prints `timing: estimated`). Without them:
- `highlight` captions fall back to the plain form of the same treatment (`pnpm render` prints a note);
- `phraseFrame` estimates from the text, so a sync is right to the phrase, not the word;
- use `hasWordTimings(scene)` or `wordFrame(...)` (returns `null`) to leave out an effect that only works on
  the exact word.

## 6. Visuals: `videos/<id>/Video.tsx` and `videos/<id>/index.ts`

`index.ts` registers the video:

```ts
import { defineVideo } from "../../src/video/registry";
import { MyVideo } from "./Video";
import spec from "./video.json";
import voice from "./voice.json";

export default [defineVideo(spec, voice, MyVideo)];
```

It can register variants of one script with `defineVideo(spec, voice, OtherComponent, "flat")`, which renders
as composition `<id>-flat`.

Build the scenes for this video's design, from the kit in `src/kit/`. The component gets
`{ videoId, timeline, design }` (`VideoProps`). Wrap everything in `<Designed>`; inside it every kit part
reads the tokens. Without it the design block has no effect, and `pnpm render` warns:

```tsx
export const MyVideo: React.FC<VideoProps> = ({ videoId, timeline, design }) => (
  <Designed videoId={videoId} design={design}>
    <AbsoluteFill>
      <Backdrop />
      <SceneTrack timeline={timeline} render={(scene) => <Scene scene={scene} />} />
      <Titles scenes={timeline.scenes} />
      <Logo />
      <Captions timeline={timeline} />
      <NarrationAudio videoId={videoId} timeline={timeline} />
    </AbsoluteFill>
  </Designed>
);
```

Design-driven parts:
- `design.tsx`: `Designed`, `useDesign()` (palette, `families`, `weights`, `accents`, `shape`, ...),
  `useMotion()`, `surfaceStyle(d)` for cards and panels.
- `motion.ts`: `entrance(m, frame, fps, start, index)` and `exit(...)` (spread onto a style), `motionRamp`,
  `motionSpring`.
- `titles.tsx`: `Title`, `Titles`, `titleClear(scene, fps, treatment)` (when a hero or kinetic title has
  left), `useContentArea(scene)`.
- `transitions.tsx`: `SceneTrack` runs each scene only while it is on screen and transitions between
  neighbours. Scenes keep their timeline frames, so narration and `phraseFrame` stay in sync. Pass `opaque`
  when neighbouring scenes are different full-frame pictures.
- `backdrop.tsx`: `Backdrop` (the background treatment), `Logo` (the logo at its placement).
- `overlay.tsx`: `Captions` (takes the caption treatment inside `<Designed>`), `NarrationAudio` (always
  include it), `Headline` (the banner), `Label`, `Phone`, `Chip`.

Building blocks, all of which take their colours from the tokens:

| Kit | Pieces |
|---|---|
| `objects.tsx` (3D, neon) | `Starfield`, `Core`, `ServerBox`, `Orb`, `Connector`, `Glow`, `Trail`, `WireBuilding` |
| `flat.tsx` (2D) | `Avatar`, `RoleTag`, `FlowLine`, `StepTracker` |
| `illustrated.tsx` (3D, clay) | `Person` + poses, `Room`, furniture, outdoors, `DaylightRig`; `Stage look="lit"` (slow: shadows) |
| `walkthrough.tsx` | `Walkthrough` (`frame="light" | "dark" | "none"`), `scheduleBeats` |
| `Stage.tsx`, `camera.ts` | a WebGL world with an HTML overlay, `useProject()`, `cameraAt(frame, moves)` |

Plain HTML, SVG and CSS in `Video.tsx` are fine and often the right tool for a look's signature devices.

**Layout and safe zones.** Each treatment holds part of the 1920x1080 frame (`src/kit/zones.ts`):

| Treatment | Holds |
|---|---|
| title `banner` | top 200px |
| title `lowerThird` | bottom 380px (above the captions; more with a larger `titleScale`). Keep its headline to two lines |
| title `rail` | left 480px |
| title `hero`, `kinetic` | the whole frame until `titleClear()`, then nothing |
| caption `pill`, `highlight` | bottom 170px |
| caption `strip` | bottom 150px, full width |
| caption `outline` | bottom 160px |
| `logo` | its height plus 48px at the top (or 40px at the bottom) |

`useContentArea(scene)` returns the rectangle left over. Keep objects and their labels inside it, and start
a scene's content after `titleClear()` when the title is a hero or kinetic.

Hard rules (renders must be deterministic and frame-addressable):
- Derive everything from `useCurrentFrame()`. No `useFrame`, `Date`, `performance.now`, timers or
  `Math.random` (use `random(seed)` from `remotion`).
- No network assets at render time except Google Fonts. Images, audio and font files live in
  `videos/<id>/` and load with `staticFile("<id>/...")` (the public dir is `videos/`).
- Sync every reveal, click and status change to the narration with `phraseFrame(scene, "exact words", fps)`.

## 7. Storyboard and the distinctiveness check

```bash
pnpm typecheck
pnpm render <id> --stills-only                    # one still per scene + out/<id>/stills/contact.jpg
pnpm render <id> --stills-only --frames 240,610   # specific frames
pnpm compare <id>                                 # out/<id>/compare.jpg
```

Open `contact.jpg` and look. Fix before rendering the video:
- text overlapping text (labels, captions, headline, logo), anything cut off at an edge
- objects hidden behind labels, small text that would be unreadable on a phone
- a scene whose picture does not match what the narration says at that moment

Then open `compare.jpg`. It sits outside `stills/`, so it survives later renders. Its top row is this
storyboard. Each row below is labelled: a version's kept contact sheet, `storyboard (not rendered yet)`, or
`frames from the MP4` for a video rendered before contact sheets were kept. The sheet holds frames of other
videos, which may be private client work: it is a local working file. Never send it to anyone, attach it to
a hand-off or commit it; send the user `contact.jpg` instead. Below the top row:
- **A video with no series:** this video's previous look (if it was rendered before) and the three other
  videos rendered most recently. Write down in one or two sentences how this video differs from each. If it
  reads as the same look (same title treatment, same palette family and same layout), revise the design
  and the scenes before rendering.
- **A series episode:** the previous episode in the series. Check it reads as the same family (palette,
  fonts, titles, captions, intro and outro). Fix any drift.

When the user wants to approve the look first, send them the contact sheet and wait.

## 8. Render and verify

```bash
pnpm render <id>
```

Takes about 1-3 minutes per minute of video for 2D and neon styles (software WebGL); illustrated 3D with
shadows is much slower. Every render writes a new version and never replaces an earlier one:
`out/<id>/<id>-v<N>.mp4` (H.264/AAC, -16 LUFS), `.srt` captions and `.md` script. Files only appear once
QA passes (streams, size, fps and duration against the timeline). Treat anything but `QA passed` as failed.
A passed render also saves the sources that made it in `videos/<id>/versions/<id>-v<N>/` and its contact
sheet in `out/<id>/contacts/`.

Then pull 6-9 frames from the MP4 itself at moments of motion and look at them:

```bash
mkdir -p out/<id>/frames
ffmpeg -v error -ss <seconds> -i out/<id>/<id>-v<N>.mp4 -frames:v 1 -vf scale=640:-1 out/<id>/frames/v<N>-<seconds>s.jpg
```

Only report the video as done after you have looked at frames from the rendered file.

## 9. Hand-off

Give the user:
- the path and the duration
- the look you chose, in a few words, and two alternates that would also fit, e.g. "Look: blueprint.
  Would also work: editorial, or terminal. Say 'make it editorial instead' for a new version."
- anything you assumed or simulated
- after a training video, one line: the look can be saved as a series for the next videos.

## 10. Revisions

- Reworded narration: edit `video.json`, `pnpm voice <id>` (only changed clips are re-made), re-render.
- Visual change: edit `Video.tsx`, check stills, re-render.
- Another look ("make it blueprint instead"): a new version of the same id. Update `design.md`, the design
  block and `Video.tsx`, then storyboard, compare (the earlier look counts as one to differ from) and render.
  The earlier version's sources stay in `versions/`.
- Back to an earlier look: `pnpm restore <id> v2` puts that version's sources back (current unsaved sources
  are kept first), then render; it becomes the next version.
- Preview interactively: `pnpm studio`.

## App walkthroughs (real screenshots)

1. Write a capture recipe at `videos/<id>/capture.ts` with Playwright on top of `scripts/capture/harness.ts`:
   - `openBrowser()` opens a read-only browser. Every request that could change data is aborted and
     recorded in `violations`, unless `allowWrite` lets it through (a login POST, say) or a `fakeWrites`
     entry answers it with a canned response. `rewriteReads` patches JSON responses, for a state the
     test account lacks. WebSockets are closed unless `allowWebSocket` lets them connect. Throw when `violations` is non-empty.
   - `recorder(page, "videos/<id>/capture").snap(id, action, label, locator)` saves a 2x screenshot and the
     target's box for each step; `write(meta)` writes `capture.json`. Pass
     `simulated: [...h.rewritten, ...h.faked]` in `meta` and tell the user what was simulated.
   - Use stable selectors (`getByTestId`, roles). Read credentials from the environment, and set passwords
     with a value setter rather than `fill()` so they never land in a log.
   - Run it with `pnpm exec tsx videos/<id>/capture.ts`.
2. Never write to a shared or production environment from a capture.
3. Build the scenes with `Walkthrough` and `scheduleBeats`: each beat shows one capture step, eases the
   camera onto its target, moves the cursor there, clicks, spotlights and labels it. Anchor beats to the
   narration with `phraseFrame`. Pick the frame (`light`, `dark`, `none`) that suits the design.
4. Blur or replace personal data in the screenshots before the video goes public.
Pliki w paczce (14)
  • SKILL.md 28 KB
  • looks/README.md 4 KB
  • looks/blueprint-technical.md 4 KB
  • looks/bold-poster-retro.md 4 KB
  • looks/cinematic-3d.md 4 KB
  • looks/editorial-magazine.md 4 KB
  • looks/flat-2d.md 4 KB
  • looks/hand-drawn-sketch.md 4 KB
  • looks/kinetic-typography.md 4 KB
  • looks/minimal-swiss.md 4 KB
  • looks/neon-3d.md 4 KB
  • looks/paper-collage.md 4 KB
  • looks/soft-product-ui.md 4 KB
  • looks/terminal-data.md 4 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · theunisdk/video-studio100MIT
mvrks-inc/nolang-plugin100Apache-2.0
murathany7/reel-studio100MIT
TheNoumanDev/zero-dollar-studio100MIT
EyesofInfinity/claude-resolve-editing-suite100MIT
jutsuhq/content-factory100MIT
GoldLegendW80/llm-video-maker100MIT
av/skills95MIT
msrshahrukh100/quran-content-creator-claude-skill95MIT

Migawka bazy z 13.11.2026 · wersja paczki 4a50902804e7 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100creating-videos
    Tworzy wideo z lektorem, napisami i prezentacją HTML na podstawie plików tekstowych, z darmowym głosem edge-tts i eksportem MP4 w 1080p.
  • 100creating-videos
    Tworzy wideo z lektorem, napisami i prezentacją HTML na podstawie plików tekstowych, z darmowym głosem edge-tts i eksportem MP4 w 1080p.
  • 90screenbrowser
    Tworzy film instruktażowy z lektorem dla aplikacji webowej: pisze przewodnik z kodu, przekazuje go do Screen Browser i odbiera film.
  • 95gomotion
    Tworzy wideo z lektorem i napisami na podstawie pomysłu lub skryptu: pisze scenariusz, generuje głos, napisy i ujęcia oraz eksportuje MP4.
  • 85scenecast
    Zamienia plik sceny działającej aplikacji webowej w wideo demo z narracją, a potem sprawdza każdy moment i poprawia błędy renderu.
  • 100walkthrough-video
    Tworzy narracyjne filmy instruktażowe o produkcie w MP4: skrypt, lektor AI, zrzuty ekranu, podkreślenia i napisy.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.