---
name: editor-room-setup
description: Set up an AI editor room in the current folder, starting from Enrique Marq's editing standards. Makes the folders (footage, references, sounds, exports, packs), checks and installs the free tools (FFmpeg, Node.js, HyperFrames), connects AssemblyAI for word-timed transcripts without ever seeing the key, helps connect the person's own editor (FilmCraft, DaVinci Resolve, Premiere Pro or CapCut), then asks a few plain questions and writes a first CLAUDE.md with the editor's brain, taste and memory. Use when someone says "set up my editor room", "set up my AI editor" or pastes the starter prompt. Works on Windows and Mac.
---

# Set up the editor room

You are setting up a video editing room for a beginner. Talk in short, plain sentences. One step at a time. After each step, say what you did and what you found, in one or two lines.

The room is the folder Claude Code is open in. Everything goes inside it.

## Rules for the whole setup

- **Never ask for a key in chat, and never write one into a file.** If a tool needs a key, the person sets it themselves as an environment variable or in that tool's own login. You only check whether it is set, never what it is.
- **Ask before you install anything.** Say what you want to install, why, and the exact command. Install only after they say yes.
- **Use only the commands in this file.** If a command fails, show the error in plain words and send them to that tool's official page. Do not guess other commands or flags.
- **Say "not checked" when you could not check something.** A tool is ready only when its check passed on this computer.
- **Do not touch anything outside this folder**, except installing the tools they said yes to.

## Step 1. Find out where you are

Check the computer and the folder:

- Which system: Windows or Mac. (On Windows your shell may be Git Bash or PowerShell; the check commands below work in both.)
- The folder you are in. If it already has files in it, list them and ask: "This folder isn't empty. Do you want the room here, or should I stop so you can open an empty folder?" Wait for the answer. Never move or delete their files.

## Step 2. Build the room

Create these folders, and put a short `README.md` in each that says, in one or two lines, what goes there:

```text
footage/       your recordings (raw videos go here)
references/    videos and pictures you like, the look you want
sounds/        music and sound effects you are allowed to use
exports/       finished videos and previews
packs/         editing packs: one file per kind of video, filled in over time
tools/         small helper scripts for your editor
```

Then save the transcript helper from this skill as `tools/transcribe.mjs`. It sits next to this file as `transcribe.mjs`. If you can't read it there, download it from:
`https://getnave.app/guides/ai-video-editing/files/transcribe.mjs`

Check it: list the folder and confirm all six folders and `tools/transcribe.mjs` are there.

## Step 3. Check the tools

Run each check and write down the result. Do not install anything yet.

| Tool | What it does | Check |
| --- | --- | --- |
| FFmpeg | Cuts, joins and exports video and audio. Free. | `ffmpeg -version` |
| Node.js (22 or newer) | Runs HyperFrames and the transcript helper. Free. | `node --version` |
| HyperFrames | Turns code into captions and motion graphics. Free, open source. | `npx --yes hyperframes --version` |
| AssemblyAI key | Lets the editor hear: word-timed transcripts. | `node -e "console.log(process.env.ASSEMBLYAI_API_KEY ? 'set' : 'missing')"` |

Show the person a small table: tool, ready or missing, and the version you saw.

Node.js must be 22 or newer for HyperFrames. If `node --version` shows a lower number, count it as missing.

## Step 4. Install what is missing (only with their yes)

Ask once, listing everything that is missing and the commands below. Install only what they agree to.

**On Windows** (winget is built into Windows 10 and 11):

```text
winget install --id Gyan.FFmpeg -e
winget install --id OpenJS.NodeJS.LTS -e
```

After installing, the person has to **close Claude Code and open it again in this folder** so the new tools are found. Tell them, and tell them to paste the starter prompt again: you will pick up where you left off, because the folders are already there.

If winget is not available, send them to the official pages: FFmpeg's Windows builds are linked from https://ffmpeg.org/download.html and Node.js is at https://nodejs.org.

**On Mac** (with Homebrew):

```text
brew install ffmpeg
brew install node
```

If `brew` is not found, send them to https://brew.sh to install Homebrew first, then try again. Do not run the Homebrew installer for them.

**HyperFrames** needs no separate install: `npx` downloads it when it is used. Once Node.js is ready, install its editing skills so Claude knows how to use it (run this from inside the room):

```text
npx --yes hyperframes skills update
```

(This is the command HyperFrames gives for Claude Code and other coding agents. Its own guide: https://github.com/heygen-com/hyperframes.) Then run the HyperFrames check from Step 3 again, and `npx --yes hyperframes doctor`, which checks what HyperFrames needs on this computer. Report what the doctor says in plain words.

## Step 5. Connect AssemblyAI (the ears)

AssemblyAI turns speech into text with the time of every word, so the editor never cuts through a word. It is pay as you go, with a free allowance to start; the current numbers are on https://www.assemblyai.com/pricing.

If the key check said **missing**, tell the person:

1. Make a free account at https://www.assemblyai.com and copy your API key from your dashboard.
2. **Do not paste it here.** Set it on your computer instead:
   - **Windows:** open a new PowerShell window (not this chat) and run `setx ASSEMBLYAI_API_KEY "paste-your-key-here"`.
   - **Mac:** open Terminal and run `echo 'export ASSEMBLYAI_API_KEY="paste-your-key-here"' >> ~/.zshrc`.
3. Close Claude Code and open it again in this folder, so it sees the key.

When the key is set, test it, if there is a recording in `footage/`:

```text
node tools/transcribe.mjs footage/<your-video>
```

It makes `footage/<your-video>.words.json` (every word with its start and end time in milliseconds) and `footage/<your-video>.txt` (the plain text). Open the text and show the first lines. If there is no recording yet, say the test is waiting for their first video.

If they would rather skip AssemblyAI for now, that's fine: write it as "not connected" in CLAUDE.md.

## Step 6. Their own editor

Ask: "Which editor do you use, if any? FilmCraft, DaVinci Resolve, Premiere Pro, CapCut, or none?"

Give them the matching route. These are other people's projects: show the link, say what it needs, and only run a command when they say yes.

- **None yet → FilmCraft.** A free, open-source editor for Windows, Mac and Linux. Download it from https://getartcraft.com/apps/filmcraft. It has a built-in connection for AI agents (an MCP server); how to turn it on is in its guide: https://github.com/storytold/filmcraft/blob/main/docs/agents.md.
- **DaVinci Resolve → davinci-resolve-mcp** (https://github.com/samuelgursky/davinci-resolve-mcp). Its setup is one command: `npx davinci-resolve-mcp setup`. Before that, in Resolve: Preferences > General > External scripting using > Local. It is made for DaVinci Resolve **Studio** (the paid version); the free version needs extra steps that its page explains.
- **Premiere Pro → premiere-pro-mcp** (https://github.com/leancoderkavy/premiere-pro-mcp). Two commands: `npm install -g premiere-pro-mcp`, then `premiere-pro-mcp --install-cep` to add its connector inside Premiere. Then follow its page to connect it to Claude Code.
- **CapCut → capcut-ai-editor (SmartCut)** (https://github.com/mrbuslov/capcut-ai-editor). Unofficial. It needs Python 3.10 or newer and a few setup steps from its page. It removes silences and repeated takes from a CapCut project, and it **changes the project directly with no backup**, so tell them to duplicate the project in CapCut first.

Whatever they pick, the room works without it: FFmpeg and HyperFrames can make the video, and the editor app is where they look and fine-tune.

## Step 7. Ask the questions

Now get to know how they edit. Ask **one question at a time**, like a curious friend, and keep their own words:

1. "What kind of videos do you make, and where do they go?" (for example: talking-head shorts for TikTok, YouTube tutorials, podcast clips)
2. "Who are they for, and what should someone feel or do after watching?"
3. "Show me what you like. Put one to three videos or screenshots in `references/` (or paste links), and tell me what you like about each one: the captions, the cuts, the music, the energy?"
4. "Describe your style in a few words. Fast or calm? How should captions look? What kind of music, and where?"
5. "Anything you never want? (For example: no flashy transitions, no music while you talk.)"

If they put references in, look at them: for a video, take a few frames with `ffmpeg -i references/<file> -vf fps=1/3 -frames:v 6 references/<file>-frame-%02d.png` and look at the pictures. Say back in two or three lines what you notice, and ask if that's right.

## Step 8. Write CLAUDE.md

Write `CLAUDE.md` in the room using the template below. Fill every `<...>` with their answers in their own words. Where they had no answer, write "not decided yet". Never invent their taste.

The template already holds a set of editing standards (the lines in bold). They come from Enrique Marq's own editing and are the starting point. Keep them as written, except where the person's answers say something different: then their answer wins. Change that line to their words and tell them which standards you changed.

Then create `packs/README.md` from the second template below. Leave the rest of `packs/` empty.

## Step 9. Finish

Show them:

- The room (the folder list).
- The tool table: ready, installed now, or still missing, and what to do about each missing one.
- What you could not check.
- Their first next step: "Put a short recording in `footage/` and say: *Edit this video in my style. Show me a 20-second preview first.*"

---

## Template: CLAUDE.md

```markdown
# My editor room

This folder is my video editing room. You are my editor. Read this file before every edit.

## The room
- `footage/` my recordings. Never change or delete the originals; work on copies.
- `references/` videos and pictures I like. Look at them before you edit.
- `sounds/` music and sound effects I'm allowed to use. Use only these, unless I say otherwise.
- `exports/` previews and finished videos.
- `packs/` editing packs, one per kind of video.
- `tools/` helper scripts.

## The tools
- **FFmpeg** cuts, joins and exports. <ready / missing>
- **HyperFrames** turns code into captions and motion graphics. <ready / missing>
- **AssemblyAI** word-timed transcripts: `node tools/transcribe.mjs footage/<video>`. <ready / not connected>
- **My editor:** <FilmCraft / DaVinci Resolve / Premiere Pro / CapCut / none> <connected / not connected>

## Ears: listen before you cut
- Before any cut, get the word-timed transcript: `node tools/transcribe.mjs footage/<video>`.
- **Never cut through a word.** A word ends where its sound wave ends, not where the transcript says. Transcript times can be off by a tenth of a second or more, so check every cut on the wave: draw it with `ffmpeg -i <file> -filter_complex "showwavespic=s=1600x240" -frames:v 1 wave.png` and look. If you're not sure, move the cut out into the quiet, never into the word.
- **Every gap is a decision.** Find the pauses with `ffmpeg -i <file> -af silencedetect=noise=-40dB:d=0.25 -f null -`. In talking videos, clear dead air down to a small breath of space: about 2 frames inside a sentence, 3 at a comma, 5 at the end of a sentence, 7 before a new part. Keep a longer pause only for a reason (a joke landing, a feeling), and tell me which ones you kept. Never chop a breath in half. In stories and vlogs, watch first: the pause might be the moment.
- **Keep my words and my personality.** Don't cut a line that sounds like me just to make it shorter. If removing something changes what I mean, ask me first.

## Eyes: look before you show me
- Look at my references before you edit, and say what you're taking from each.
- After every render, look at your own frames: the start, the middle, the end, and every caption, graphic and cut. Fix what's wrong before you show me.
- **The 100% framework.** Score every version out of 100 against my references and this file, and be really critical. Write what's keeping it from 100, fix it, and score it again. When I say "you got a 60 out of 100, get me to 100", list everything that's missing before you change anything.

## Brain: my reasons
- What I make: <their answer>
- Who it's for and what they should feel or do: <their answer>
- **Every edit has a reason.** Before you build, write one line per graphic, sound and caption choice: what it says and why it's there. Take it out in your head: if the viewer loses nothing, cut it.
- **Clear over clever.** The story first, then the screens. Ask what the line means to the viewer, and show that.
- **Show the real thing.** When I name a tool, a screen or a result, show the real one before any drawn graphic. Real screens are proof.
- **Overlays land on the word.** A graphic, zoom or cutaway starts on the word it shows, within a tenth of a second. Never late, never spanning a cut.

## Taste: my look and sound
- My style in my words: <their answer>
- What I like in my references: <one line per reference>
- **Captions:** small and clean, one flat colour, no box, no shadow, no outline, under every spoken word.
- **Intentional sound.** Every sound has a job you can name: a soft tick on a highlighted word, a soft entrance sound when a big graphic comes in (vary them), a click where a real click is shown. No beeps, chimes or harsh risers, and never more than one sound starting at once. No music under my talking. Use only what's in `sounds/`.
- Never: <their answer>

## Memory: editing packs
- **Each kind of video gets its own pack** in `packs/` (one file per kind: pacing, captions, graphics, sound, what I corrected). Explain it once, then improve it every time.
- Before editing, read the pack that fits this video and follow it. If there's none, ask me if we should start one.
- When I correct something that should always apply, add it to the pack. A fix for one shot only stays in that video's notes.

## How we work
1. I put a recording in `footage/` and tell you what it's for.
2. You transcribe it, read this file and the right pack, and look at my references.
3. You make a short preview first, score it out of 100, fix it, and show me with the score.
4. I give feedback. You fix it, then do the full video into `exports/`.

These standards started from Enrique Marq's own editing rules (getnave.app/guides/ai-video-editing). They're a starting point: change any line to make it yours.
```

## Template: packs/README.md

```markdown
# Editing packs

One file per kind of video, for example `talking-head-short.md` or `youtube-tutorial.md`.

Each pack says:
- What this kind of video is for
- Length and format (9:16, 16:9)
- Pacing: how tight the cuts are
- Captions: font, size, colour, where on screen
- Graphics and motion
- Sound: music, sound effects, levels
- Corrections I've made that always apply

Empty for now. Your editor fills it in after your first video you like.
```
