# Set up an AI video editor (from SSKTECHY's Claude video editing video)

You are an AI coding assistant (Claude Code, Codex, Cursor, Gemini CLI or similar) helping a
person who watched a video. Do everything below for them. They should not need to type commands.

# Goal

When you finish, the person can drop a raw talking-head recording in a folder and ask you to
edit it. You will cut the mistakes and silences, add captions and motion graphics with
HyperFrames, show them a preview, and render the final MP4 only after they approve it. You will
also have a `style.md` file that grows after every edit, so the edits start to look like theirs.

# Rules for you (the AI)

- Check the operating system first (macOS, Windows or Linux) and use commands that work there.
- Check what is already installed before installing anything. Never overwrite existing files,
  folders, skills or config without asking.
- Ask the person only for what only they can do: a choice, or an API key. Explain each in one
  plain sentence.
- Everything here is free. Say before anything would cost money.
- If a key is ever needed, create `.env` in the project folder with only `NAME=` and ask the
  person to paste their key after the `=` and save, so the key never goes into this chat.
- If something fails, stop and explain it simply. Do not guess or loop on retries.

# Steps

## 1. Tools

- **Node.js 22 or newer** (`node -v`). HyperFrames needs it. If it is older, look for a version
  manager first (`ls ~/.nvm/versions/node`, fnm or volta) and switch to 22 or newer; otherwise
  install Node 22 LTS (macOS Homebrew `node@22`, Windows winget `OpenJS.NodeJS.LTS`). Every
  `npx hyperframes` command must run under that Node. Each of your commands may run in a new
  shell, so put the switch in the same command (for example
  `source ~/.nvm/nvm.sh && nvm use 22 && npx hyperframes ...`).
- **FFmpeg** (`ffmpeg -version`). On macOS install with Homebrew, on Windows with winget, on
  Linux with the package manager.
- **Python 3.10 or newer**, for transcription.

## 2. HyperFrames (open source, by HeyGen, renders HTML into video)

If HyperFrames skills are already available to you, skip the install.

- Claude Code:

```bash
claude plugin marketplace add heygen-com/hyperframes
claude plugin install hyperframes@hyperframes
```

- Any other assistant (installs the core skills without an interactive picker):

```bash
npx hyperframes skills update
```

- After installing in Claude Code, ask the person to restart it so the skills load. For edits,
  `my-video-editor` (step 5) is the workflow; use the HyperFrames skills as reference and skip
  their new-video interview. Docs: https://hyperframes.heygen.com/introduction
- The commands you will use (all through `npx hyperframes`):
  - `init <folder> --non-interactive --video <clip>` starts a project with the canvas matching
    the clip (use `--resolution portrait` for a vertical video).
  - `lint` must show 0 errors (warnings are fine), and `check` must say it passed.
  - `preview --background` opens Studio for the person without blocking you.
  - `render --quality draft` while working, `render --quality delivery` for the final.

## 3. Transcription

- Install a free local Whisper with word-level timestamps, in a virtual environment in the
  project folder (recent macOS Python blocks a plain `pip install`): `mlx-whisper` on an Apple
  Silicon Mac with the model `mlx-community/whisper-large-v3-turbo`, `faster-whisper` elsewhere
  with `large-v3-turbo`, and `word_timestamps=True` in both (the default model is too small).
  Tell the person the first run downloads about 1.5 GB.
- Whisper works very well for English. For Telugu, Hindi and other Indian languages it makes
  more mistakes. Tell the person that, and offer a speech-to-text service built for Indian
  languages instead:
  - Recommended: Sarvam AI (paid, Indian company): https://www.sarvam.ai
  - Alternatives, if they prefer: ElevenLabs Scribe (paid): https://elevenlabs.io/speech-to-text,
    or AI4Bharat IndicConformer (free, open source): https://github.com/AI4Bharat/IndicConformerASR
- If they pick one, set it up from that service's own current docs, with the key rule above.

## 4. Real screen recordings (Playwright CLI, free, by Microsoft)

Lets you open a real browser, go to a website, click through it and record the screen, so the
video can show the real site or app instead of a drawn mock-up.

```bash
npm install -g @playwright/cli@latest
```

- Then add its skill: in a temporary folder run `playwright-cli install --skills` (Claude Code)
  or `playwright-cli install --skills agents` (other assistants). It writes the skill into that
  folder; move the `playwright-cli` skill folder it created into the same skills folder as
  `my-video-editor` (Claude Code: `~/.claude/skills/`), asking before overwriting one that exists.
- Recording: `playwright-cli video-start clip.webm --cursor`, do the clicks, `playwright-cli
  video-stop`. Convert the .webm to MP4 with FFmpeg before using it in an edit.
- Docs: https://github.com/microsoft/playwright-cli

## 5. Install the editing skill

Create a skill named `my-video-editor` in the folder where your assistant loads skills
(Claude Code: `~/.claude/skills/my-video-editor/`; others: your skills folder, or add it to your
instructions file such as `AGENTS.md`). Ask before overwriting one that exists. It has two files.

`SKILL.md`, exactly this:

````markdown
---
name: my-video-editor
description: Edit a raw talking-head recording into a finished video with clean cuts, captions, visuals and sound, built in HyperFrames. Use when the person says "edit this video", "cut this recording" or gives you a raw video file.
---

# My video editor

Read `style.md` in this folder before every edit. It holds this person's own taste, and it wins over
everything below.

The aim: a viewer should never feel like skipping. Every cut, caption, visual and sound has to make
the video easier to follow or make a moment land. If something adds nothing, leave it out.

## 1. Understand the recording

- If it is not clear, ask once: what the video is for, its language, and vertical or horizontal.
- Transcribe with word timestamps. English: the local Whisper. Telugu, Hindi and other Indian
  languages: the Indian-language speech-to-text service if one is set up, otherwise Whisper with a
  warning that the cuts need a closer check.
- Split the transcript into short phrases at every small pause and read each one on its own. A long
  stretch of transcript hides repeated words.

## 2. Cut

Read the whole transcript twice: once for lines said more than once, once for everything else.

Remove:
- earlier attempts at a line (keep the last complete one)
- false starts and restarts in one breath ("so today we, so today we will...")
- a sentence that trails off unfinished when the next one starts the idea fresh
- the same point or number said twice (keep the clearer, complete version)
- lone fillers between sentences ("um", "uh", "okay", "yeah") and mumbles
- thinking aloud, side remarks that go nowhere, and describing a click without saying anything
- long silences, including waits while something loads on screen

Keep:
- natural lead-ins such as "So", "Okay so", "Now"
- anything you cannot understand. Keep it and flag it: a leftover filler costs the person one
  click to remove, a missing word is worse.

How to cut:
- Cut in the quiet between words, never through a word. Let the last sound of each line fade out
  fully, then go straight into the next line.
- Inside a sentence keep only the natural breathing pauses. Between sentences leave a short beat.
- Transcript word times can be slightly off. Check the audio level at every cut and move the cut to
  the quietest spot nearby.
- Leave a little air after the last word of the video.
- Before adding anything else, go through the whole cut in order and check every join. You cannot
  hear audio, so say that, and list the joins you checked by their sound levels.

## 3. Build it in HyperFrames

Copy the raw clip into the project's `assets/` folder.

- Captions: timed to the words, a few words at a time (2 to 4 on a vertical video), big and easy to
  read, in a band that never covers the face or the thing being shown. Keep them clear of the
  platform's buttons at the edges.
- Visuals show what is being said. When the person names a website or app, record the real thing
  with Playwright CLI instead of drawing a mock-up. Use motion graphics for ideas: a number, a
  comparison, a list.
- For a list, put every item on one screen and bring each one forward as it is spoken, instead of a
  new card per item.
- One main thing moves at a time. Every move eases in and out and starts on its word. Text stays up
  long enough to read.
- Show the face when the delivery is the point. Show the visual full screen when the viewer needs
  to look at a detail.
- Sound: instrumental music, quiet under the voice, chosen for the mood (no copyrighted tracks on
  YouTube). Small sound effects only on key moves such as a reveal, never on everything. The voice
  always stays clearly on top.
- Ask the person for any logos, screenshots or music they want used.

## 4. Check it before showing it

- `npx hyperframes lint` shows 0 errors and `check` passes.
- Step through every transition frame by frame: nothing cut off, nothing covering a caption,
  nothing outside the safe area.
- Watch it once as a first-time viewer. Note every moment you would skip or lose the thread, and fix
  it.

## 5. Preview, then render

Show the preview in HyperFrames Studio. Never render before the person approves it. After approval,
render at delivery quality and check that the file plays and its length is right.

## 6. Learn their style

Ask what they would change. Write each answer into `style.md` as one short dated rule in plain
words, and follow it next time without being told. Over time, `style.md` becomes their editing style.
````

`style.md`, exactly this:

```markdown
# My editing style

Rules learned from my corrections. Newest at the bottom. These win over the default skill.

```

## 6. Model tip (tell the person)

- As of October 2026: Opus 5.5 on High effort usually gets an edit right in the first try, but it uses up usage
  limits fast. On the Pro plan you can edit only a few videos with it.
- Sonnet 5.5 edits well too, with a few rounds of corrections. It is the better daily choice on
  the Pro plan.

# Final check

1. Confirm `node -v` (22 or newer), `ffmpeg -version`, Whisper, the HyperFrames skills and
   `playwright-cli --version` work.
2. Ask the person for a short raw clip (20 to 60 seconds) and make a first edit with
   `my-video-editor`. Show the preview.
3. Ask what they would change and write the answers into `style.md`. Tell them that this file is
   how the editor learns their style.

# Cost

- Free: Node.js, FFmpeg, HyperFrames, Playwright CLI, Whisper, the skill and your work.
- Your AI plan's usage limits apply (see the model tip).