# Edit your own video takes into one checked film with Claude Code

> A documentation-based guide to turning real owned takes into one reviewed film with Claude Code and Video Use: source-linked cuts, optional graphics, preview, final MP4 and full human playback.

By BIGCHANGE.AI Editorial

Published: 2026-10-22T05:26:37.890Z
Updated: 2026-10-22T05:26:37.890Z
Canonical: https://bigchange.ai/blog/edit-owned-video-takes-one-film-claude-code-video-use

![Conceptual charcoal illustration of three unlabelled camera memory cards in an open case beside a small reader and a freestanding monitor showing a generic landscape frame.](https://bigchange.ai/api/media/file/owned-takes-reviewed-film-hero-v2.png)
AI-generated conceptual illustration by BIG CHANGE.

Claude Code can help turn several recorded takes into one film using the open-source Video Use skill. It links source speech and inspected frames to a proposed cut list, preview and MP4. The editor still decides what the footage means, which takes belong together and whether the delivered file is fit to use. This guide follows the [Video Use maintainer's documentation](https://github.com/browser-use/video-use) and [HyperFrames quickstart](https://hyperframes.app/docs/1-startup/2-quickstart), checked October 22, 2026. BIG CHANGE did not install these tools, process footage, call a model or transcription service, or test a render.

## The big change

- **What changed:** Video Use gives a coding agent a documented path to transcribe multiple takes, propose an edit, render from a source-linked edit decision list (EDL) and inspect the output.
- **Why it matters:** An editor can review the chosen source intervals and cut strategy before a final film is made.
- **What to watch:** Transcription sends extracted audio to ElevenLabs Scribe; transcript and sampled-frame context may reach the configured Claude model. Local rendering does not make those analysis steps local, and automated checks do not establish rights or editorial quality.

## 1. Secure the footage and define the film

Start with the real takes you have permission to edit. Keep an untouched copy outside the working `edit/` directory. For each file, record its name, source, people and music permissions, and allowed uses in a private record; add its hash after the tools are ready in step 2. Write a brief that names the audience, message, target length and aspect ratio, required and forbidden moments, exact approved claims and on-screen text, caption needs, and delivery format. Check the footage yourself; the brief should reflect what was recorded, not a desired scene that may not exist. Hold any source whose rights or consent are unresolved.

The examples below assume **macOS**, Homebrew, Claude Code and a folder containing only the permitted source takes. Replace `/absolute/path/to/owned-takes` with your actual folder. These are documented commands for a reader to run after approving the tool, data transfer and cost; they are not results from a BIG CHANGE session. Video Use also gives Debian/Ubuntu setup examples, but its POSIX symlink commands should not be copied to Windows without checking a supported installation route.

## 2. Pin and register Video Use on a supported machine

The [installation instructions](https://github.com/browser-use/video-use/blob/main/install.md) require Python 3.10 or newer, `ffmpeg` and `ffprobe`, the Python dependencies, the whole skill directory and an ElevenLabs API key for transcription. The repository's `pyproject.toml` says `0.1.0`; that is project metadata, not proof of the installed checkout or resolved package versions. The commands below pin the repository commit inspected for this guide, `43cfc566833548093455c9d4a46bd69913b7e552`. Review that commit and its dependencies in your environment before installation. First inspect the proposed checkout and skill paths with `ls -ld "$HOME/Developer/video-use" "$HOME/.claude/skills/video-use" 2>/dev/null`. Run the block only if neither path exists. If either is occupied, inspect what is there and choose an approved, unused checkout and registration path; change every later path accordingly. Do not check out a revision in someone else's clone or replace an existing skill registration.

```bash
brew install ffmpeg uv
python3 --version
ffmpeg -version
ffprobe -version
mkdir -p "$HOME/Developer"
git clone https://github.com/browser-use/video-use "$HOME/Developer/video-use"
cd "$HOME/Developer/video-use"
git checkout 43cfc566833548093455c9d4a46bd69913b7e552
git rev-parse HEAD
uv sync
mkdir -p "$HOME/.claude/skills"
ln -s "$HOME/Developer/video-use" "$HOME/.claude/skills/video-use"
readlink "$HOME/.claude/skills/video-use"
uv run python helpers/timeline_view.py --help
uv run python helpers/render.py --help
```

Check that Python reports at least 3.10, both FFmpeg programs respond, `git rev-parse HEAD` matches the pinned revision, `readlink` names the intended checkout, helper help opens, and Claude Code discovers the registered skill in a new session (`/video-use` for the default path). Register the **directory**, not only `SKILL.md`: its `helpers/` must remain beside the instructions. If a command fails, inspect its actual error, your paths and versions before going further. If you use another checkout or dependency resolution, record those actual revisions instead. The maintainer's installation guidance calls for a real-file check before declaring an editing pipeline working; help output verifies interfaces, not a successful edit.

Now use `ffprobe` on each real take before transcription to confirm duration, streams, dimensions and the correct audio track. Replace the example filename with one from your source folder:

```bash
ffprobe -v error -show_format -show_streams "/absolute/path/to/owned-takes/actual-take.mov"
shasum -a 256 "/absolute/path/to/owned-takes/actual-take.mov"
```

Save the output beside the rights record. If the probe fails, establish that the file opens in a player and identify the actual format or damaged source before calling the agent. A hash identifies the source version; it does not prove rights.

Before any transcription, check the current [ElevenLabs account terms and prices](https://elevenlabs.io/pricing), quota, file limits, retention and permission to send this audio. Video Use's [transcribe helper](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py) extracts mono audio and sends it to Scribe with word timestamps and speaker labels. Provide `ELEVENLABS_API_KEY` through your approved secret storage or the private repo-root `.env` described by the maintainer. Keep it out of the prompt, footage folder, logs and shared records. Also review the configured [Claude Code data handling](https://code.claude.com/docs/en/data-usage) and [tool permissions](https://code.claude.com/docs/en/permissions) for transcript, sampled frames and shell access. Limit the agent to this edit's files and approved services. Transcription and model usage may cost money; a local FFmpeg export changes neither data destination.

## 3. Inspect the takes and correct the transcript

From the pinned Video Use checkout, use the documented helpers only after approving the Scribe call. The batch command walks source video files in the named folder, writes cached transcripts under its `edit/transcripts/` folder and may make several paid calls. If a source has multiple audio streams, use `ffprobe` to select the right track and check the helper's `--audio-track` option first. Do not treat silence or a failed upload as an empty take.

```bash
cd "$HOME/Developer/video-use"
uv run python helpers/transcribe_batch.py "/absolute/path/to/owned-takes" --workers 1
uv run python helpers/pack_transcripts.py --edit-dir "/absolute/path/to/owned-takes/edit"
```

`--workers 1` keeps the first batch easy to supervise; the helper's documented default is four workers. Inspect `edit/transcripts/` and `edit/takes_packed.md`, then compare names, speakers, quotes and missing context with the original files. The packed transcript groups phrases with source time ranges; it is a navigation aid, not a verified account of what a speaker intended. For an uncertain pause or take choice, the helper offers an on-demand filmstrip and waveform, with times in seconds:

```bash
uv run python helpers/timeline_view.py "/absolute/path/to/owned-takes/actual-take.mov" 12 18
```

Use ranges from your own footage, inspect the PNG and play the original interval. If Scribe rejects a file or quota, preserve the exact error and decide on access or format before another paid call. If text or timing is wrong, correct the source-linked decision and captions against the original; never invent a missing line. The helper caches transcripts, so check that a cached result belongs to the exact current source before reusing it.

## 4. Approve the cut plan before rendering

Open Claude Code in the source folder with Video Use available. Give it the private brief and actual source inventory. Ask first for a plain-language strategy: the film's shape, proposed take order, source intervals and why they were chosen, expected duration, caption treatment, audio and grade approach, and any graphic slots. Tell it to flag uncertain words, conflicting takes, unsupported claims and missing permissions. Review each selected interval in the original video. Approve or revise the plan explicitly **before** it makes cuts; this is a rule in the [Video Use skill](https://github.com/browser-use/video-use/blob/main/SKILL.md).

Once approved, ask the agent to produce the EDL using the pinned skill and helper source. Video Use documents `edit/edl.json` for decisions, word-boundary cuts, output-timeline subtitle offsets and `edit/project.md` for project memory. Record source filename, in/out range, take purpose, caption correction and approval beside each retained passage. Verify the proposed cut on both picture and sound: word timestamps alone cannot tell whether a gesture, reaction, sentence or claim loses its context. Reject any edit that changes what the source says. Keep source files untouched and preserve EDL revisions so a later correction can be traced to its cause.

## 5. Add motion graphics only where the film needs them

An approved name card, diagram or transition may help this film. Specify each slot's wording, timing, position, font and image rights before generation. Video Use documents animation files inside `edit/animations/slot_<id>/` and its render helper reads EDL overlays with a file path, output start and duration. Confirm the actual EDL and helper interface in your pinned checkout; this article does not supply a guessed EDL schema.

For a HyperFrames slot, its [quickstart](https://hyperframes.app/docs/1-startup/2-quickstart) requires Node.js 22 or newer, npm and FFmpeg. Once the approved slot directory exists, replace `<approved-id>` with its actual ID and work there. The documented route is to install its agent skills or initialize a local project, then preview the composition:

```bash
cd "/absolute/path/to/owned-takes/edit/animations/slot_<approved-id>"
node --version
npx skills add heygen-com/hyperframes
npx hyperframes init my-graphic
cd my-graphic
npx hyperframes preview
```

`init` is interactive; `preview` starts a local Studio and keeps running while you inspect it. Stop that preview with Ctrl-C, or use a separate terminal in the same `my-graphic` directory, before rendering:

```bash
cd "/absolute/path/to/owned-takes/edit/animations/slot_<approved-id>/my-graphic"
npx hyperframes render --output graphic.mp4
```

These commands belong in a chosen graphic slot, not the Video Use repository root. Inspect the rendered graphic, its exact text, dimensions, duration, codec and rights. Confirm the asset's timing and path in the supported Video Use overlay entry, then view it in the **composite** at final viewing size; subtitles must remain visible. If setup or rendering fails, inspect the actual Node, package, FFmpeg and project errors. Leave that slot unapproved or use an explicitly approved no-graphics plan. HyperFrames Cloud is optional; this local route does not require it.

## 6. Render, repair and accept the actual MP4

Video Use documents a preview render from the reviewed EDL. Run it from the pinned checkout after verifying its current `render.py --help` and the saved EDL:

```bash
cd "$HOME/Developer/video-use"
uv run python helpers/render.py "/absolute/path/to/owned-takes/edit/edl.json" -o "/absolute/path/to/owned-takes/edit/preview.mp4" --preview --build-subtitles
```

The helper's current code applies overlays before subtitles and normalizes audio by default. Check that those defaults suit your actual delivery specification; a platform's loudness or codec target cannot be inferred from the helper. Inspect the full preview from beginning to end with sound, as well as its cut boundaries, opening, ending, captions, audio continuity and each graphic. Video Use describes `timeline_view.py` and `ffprobe` self-checks; they can reveal a jump or a bad duration, but they do not replace watching and listening. Write timecoded changes, update the EDL or graphic, rerender and repeat affected checks. Obtain the owner's explicit approval of the corrected preview before running the final export:

```bash
cd "$HOME/Developer/video-use"
uv run python helpers/render.py "/absolute/path/to/owned-takes/edit/edl.json" -o "/absolute/path/to/owned-takes/edit/final.mp4" --build-subtitles
```

Reopen **the exact final MP4**. Record its hash and probe its streams and duration against the brief:

```bash
shasum -a 256 "/absolute/path/to/owned-takes/edit/final.mp4"
ffprobe -v error -show_format -show_streams "/absolute/path/to/owned-takes/edit/final.mp4"
```

The probe reports such properties as duration, frame dimensions and rate, codecs, channels and size. It does **not** measure loudness. If the delivery brief has a loudness or true-peak target, measure the exported file separately and compare the result to that target; the [Video Use skill](https://github.com/browser-use/video-use/blob/main/SKILL.md) documents this FFmpeg check:

```bash
ffmpeg -i "/absolute/path/to/owned-takes/edit/final.mp4" -af ebur128=peak=true -f null -
```

Finally, play the full file on the intended device and listen throughout. Compare every retained claim and quote with the source, and check caption timing and legibility, graphic placement, picture continuity, music and image rights, and the actual delivery format. Save the source hashes, rights record, approved EDL, tool revisions, preview corrections, final hash, measurements and owner accept-or-hold decision privately. A failed check means another repair and review; file existence or an agent's self-assessment is not acceptance. Sharing or publishing the film is a separate decision.

## Sources & further reading

- [Video Use README](https://github.com/browser-use/video-use) — Maintainer description of the transcript, EDL, render and review flow, checked October 22, 2026. Its quality and automation claims are project claims; BIG CHANGE did not reproduce them.
- [Video Use installation guide](https://github.com/browser-use/video-use/blob/main/install.md) — Setup requirements, whole-directory skill registration, helpers and account key. Its examples cover POSIX environments; verify your actual machine and installed dependencies.
- [Video Use skill and helper source](https://github.com/browser-use/video-use/blob/main/SKILL.md) — Strategy approval, supported helper commands, output paths, cut rules and self-check guidance. The [transcription](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py) and [render](https://github.com/browser-use/video-use/blob/main/helpers/render.py) code establish the service call and current CLI flags; a pinned checkout governs any reader run.
- [Video Use project metadata](https://github.com/browser-use/video-use/blob/main/pyproject.toml) — Lists Python 3.10+ and package metadata version `0.1.0`. It does not identify a reader's installed version.
- [HyperFrames quickstart](https://hyperframes.app/docs/1-startup/2-quickstart) — Optional Node 22+ local composition, preview and MP4 render commands. It does not establish that a graphic suits a particular film or integrates successfully without an inspected render.
- [Claude Code permissions](https://code.claude.com/docs/en/permissions) and [data usage](https://code.claude.com/docs/en/data-usage) — Controls and account data-handling context to review before granting an agent access to real footage or transcript material; account terms and settings may vary.

## Sources

- [Video Use README](https://github.com/browser-use/video-use) — Maintainer overview checked October 22, 2026; describes source folder, strategy approval, transcript and EDL flow, render and edit/final.mp4. Claimed editing quality and self-evaluation were not tested by BIG CHANGE.
- [Video Use installation guide](https://github.com/browser-use/video-use/blob/main/install.md) — Documents stable checkout, Python dependencies, FFmpeg/ffprobe, full-directory Claude Code skill registration, ElevenLabs key and helper checks. POSIX examples do not establish Windows compatibility.
- [Video Use SKILL.md](https://github.com/browser-use/video-use/blob/main/SKILL.md) — Documents source inventory, strategy confirmation, transcription, EDL, optional overlay slots, preview/final helper flow and self-evaluation. A human must verify contextual accuracy and the entire actual export.
- [Video Use project metadata](https://github.com/browser-use/video-use/blob/main/pyproject.toml) — States Python >=3.10 and metadata version 0.1.0. The checked Git revision and a reader's resolved installed versions are separate facts.
- [Video Use transcription helper](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py) — Current source posts extracted mono audio to hosted ElevenLabs Scribe with word timestamps. Confirms sensitive transfer; no call, quota or price was tested.
- [Video Use batch transcription helper](https://github.com/browser-use/video-use/blob/main/helpers/transcribe_batch.py) — Confirms source-directory input, --workers and --audio-track flags, cached output and paid-call path. The article chooses one worker for supervised first use.
- [Video Use packed transcript helper](https://github.com/browser-use/video-use/blob/main/helpers/pack_transcripts.py) — Confirms --edit-dir and takes_packed.md output from cached JSON. Packed text is navigation material, not independently verified speech.
- [Video Use timeline view helper](https://github.com/browser-use/video-use/blob/main/helpers/timeline_view.py) — Confirms positional source/start/end filmstrip command. Full-project --edl mode is not implemented in checked source and is not used in the guide.
- [Video Use render helper](https://github.com/browser-use/video-use/blob/main/helpers/render.py) — Confirms EDL/-o, --preview, --build-subtitles, overlays, subtitle-last rendering and current loudness normalization behavior. No sample EDL schema or successful render is asserted.
- [HyperFrames quickstart](https://hyperframes.app/docs/1-startup/2-quickstart) — Documents optional local project skills/init/preview/render commands, Node 22+, npm and FFmpeg. A rendered slot must still be checked and integrated with the pinned Video Use helper.
- [Claude Code permissions](https://code.claude.com/docs/en/permissions) — Official permission controls; actual file, shell and network grants depend on the reader's account and configuration. The guide instructs limited scope.
- [Claude Code data usage](https://code.claude.com/docs/en/data-usage) — Official data-handling context; account terms and settings vary. Local video rendering does not imply that model analysis is local.
- [ElevenLabs pricing](https://elevenlabs.io/pricing) — Current account price and quota require reader-specific verification before Scribe use. The guide makes no fixed-rate or free-tier claim.