reel-kit

[!IMPORTANT]
Recommended model: for best results at the time this repo was published (October 2026), use Claude Opus 5.5
on max effort. In Claude Code, pick Opus 5.5 and max effort in the model menu (in a terminal: claude --model opus --effort max). In Claude Cowork, pick Opus 5.5 and
the highest effort in the model menu. On Codex and ChatGPT Work, use the most capable model at its highest
reasoning effort.

An AI agent skill that turns one talking-head clip into a finished vertical video, in your own style. Give it a
take; it cuts the edit, writes the captions, builds the motion graphics and lays the sound, then shows you a
storyboard to comment on before anything renders.

Works with Claude Code, Claude Cowork, Codex and ChatGPT Work. Runs on your computer, on your footage. Free and
open source. Made by Justyn (@justyn.ai); the full walkthrough course is at
justyn.ai/waitlist.

_{One edit, three style packs. Same cut, same effects, same timing; the look is the pack's. Every image in this
README is drawn on a stand-in figure.}

What it makes

• A clean edit of one take: dead air out, the last good take of every line, J-cuts on every join, two framings
  from one camera, lip sync checked before and after the render.
• Captions that land on the words, in your fonts and colours.
• Words and numbers behind your head (you stay in front of the type).
• Hand-built motion-graphic cards for the numbers in your script: charts that draw, figures that roll, data kept
  to scale.
• Sound effects under every visual moment, mixed under your voice to streaming loudness (-14 LUFS).
• A storyboard first: every beat with real frames, what moves, what you hear, and what the agent needs from you.
  Leave notes on any beat. Nothing renders until you say go.

Three modes

• Hi-fi: produced. A sit-down take, full-screen data cards, type behind your head.
• Lo-fi: selfie. A phone take where you never leave the frame; screenshots and clips land on top of you or
  behind your head, captions light up word by word, native-looking text boxes carry the hook and the call to action.
• Showcase: the show-off edit. Every line gets a different hand-built motion graphic the words call for (kinetic
  type, a magazine cover behind your head, a grade that wipes across, a grid of you, a timeline that builds), a
  different transition on every cut, and dense sound. Forty effects ship in the library.

Your style decides how each mode edits for you, not just its colours: the hook shape, how captions move, what the
camera does, which transitions you use and how a big word lands all come from your brand and your inspiration.

The effects

Forty hand-built motion graphics for showcase videos, each one driven by your style pack: kinetic type, a word
stamped behind your head, giant captions, a receipt that prints what you told the AI, projected film, a silent-film
title card, a screenplay page of your own lines, keycaps that pile up, a grease pencil that circles you as you
move, your storyboard dealt out like cards, a frame that recurses into itself, a different shape transition on
every cut, and more. Ask for any of them by name ("receipt-printer as the motif, keycaps on the editing line"), or
ask the agent what effects there are. What each one does and when to reach for it: fx/LIBRARY.md.

Your style, not ours

The first time you run it, the agent builds your style pack:

1. Have a brand file? A brand guide, a DESIGN.md, a PDF or your website. It reads your fonts and colours.
2. No? Send 2 or 3 links to videos whose style you like. It studies them: pace, captions, colour, motion.
3. Neither? Four quick questions.

Then it shows you a style board: your type and colours, a frame of your own footage in each of the three modes,
and a few cards in your look, and asks if it looks like you. Change anything, any time: "update my style".

The pack lives in ~/reel-kit/style/, outside the skill, so updates never touch it. Each video keeps a copy of
the style it was made with.

Install

It runs on your own computer, on your own footage: a Mac or Linux (Windows is untested; WSL should work). You don't
install anything else by hand. When your computer doesn't have them, setup fetches its own Python, ffmpeg and Node
into ~/reel-kit/: no Homebrew, no admin password, nothing changed on the rest of your computer. Setup ends by
drawing a test frame, so READY means it can render.

Claude Code or Cowork? Both make the same video. Claude Code runs directly on your computer, so it renders a lot
faster (it uses every core and your Mac's graphics chip for the cutout). Cowork runs in a sandbox on your
computer: it works, it's just slower. If renders feel slow, switch to Claude Code.

Claude Code

Open the Code tab in the Claude desktop app (or Claude Code in a terminal) and paste this:

Install Reel Kit for me, doing every step yourself and telling me in plain words what's happening:
1. Run: claude plugin install reel-kit --marketplace justynberk/reel-kit -y
   If the claude command isn't found, use the one inside the Claude app: the newest
   ~/Library/Application Support/Claude/claude-code/*/*/claude.app/Contents/MacOS/claude
2. In ~/.claude/settings.json, add "autoUpdate": true to the "reel-kit" entry under "extraKnownMarketplaces",
   so updates arrive on their own.
3. Run the plugin's setup until it prints READY: sh <the installed plugin>/skills/reel-kit/setup/setup.sh
   (the plugin is under ~/.claude/plugins/cache/reel-kit/reel-kit/).

The first setup takes 10 to 20 minutes (the speech model, a render browser and the tools, once). Then start a new
session (or type /reload-plugins) and make your first video: /reel-kit:showcase my-clip.mov. On a Mac that has
never used developer tools, a popup may ask to install Apple's command line developer tools: click Install and let
it finish (Claude Code downloads plugins with git).

Prefer typing it yourself? /plugin install reel-kit --marketplace justynberk/reel-kit, then /reel-kit:setup,
then turn on auto-update in /plugin > Marketplaces > reel-kit.

Claude Cowork

Cowork (the Claude desktop app) runs tasks in a Linux sandbox on your computer that can only reach the folders you
give it.

1. In the Claude desktop app: Customize > Plugins > Add marketplace, enter justynberk/reel-kit, and install Reel Kit.
2. In Settings > Capabilities, turn on code execution and file creation.
3. Make a folder for your videos, for example reel-kit in your home folder, and put your clips in it. Start a
   Cowork task, give it access to that folder, and ask: "Use reel-kit to make a hi-fi video from my-clip.mov."
4. The first run sets the kit up inside the sandbox (10 to 20 minutes, once). Your style, projects and finished
   videos are saved in the folder you gave it, so they stay on your computer.

No Plugins page on your account? Download reel-kit.zip from the
latest release and upload it in Customize > Skills >
Create skill > Upload a skill.

Codex

For the Codex CLI, the IDE extension or the Codex tab in the ChatGPT desktop app:

git clone https://github.com/justynberk/reel-kit ~/.agents/reel-kit-src
mkdir -p ~/.agents/skills && ln -s ~/.agents/reel-kit-src/skills/reel-kit ~/.agents/skills/reel-kit
sh ~/.agents/skills/reel-kit/setup/setup.sh

Then type $reel-kit, or ask Codex to edit your clip with reel-kit. Codex runs commands in a sandbox that blocks
the browser the kit renders with, so give the session Full access (the permissions menu in the app, or
codex --sandbox danger-full-access); setup tells you if it can't render.

ChatGPT Work

ChatGPT Work runs in the new ChatGPT desktop app (not ChatGPT Classic) and does its local work through the Codex
built into it.

1. Download reel-kit.zip from the latest release.
2. In ChatGPT: your profile icon > Skills, then upload the zip. ChatGPT scans uploaded skills and may mark this one
   "Needs review" because it contains code; that's expected.
3. Make a folder for your videos, for example reel-kit in your home folder, put your clips in it, and open it in
   a Work task so ChatGPT has access to it.
4. Rendering opens a headless browser, which the Codex sandbox blocks: give the task Full access when it asks.
5. Ask: "@reel-kit make a lo-fi video from my-clip.mp4." The first run sets the kit up in that folder (a few
   minutes, once).

Everything setup makes (the kit's Python environment, its tools, GSAP, the render browser, the speech model) goes
in ~/reel-kit/ (or the folder you gave Cowork or ChatGPT), next to your style and your projects, never inside the
skill folder. Run it again any time; it only fixes what's missing.

Moving from the cloned skill

Installed reel-kit before 0.4.0 by cloning it into ~/.claude/skills/reel-kit? Delete that folder
(rm -rf ~/.claude/skills/reel-kit) and install the plugin as above. On Codex, delete ~/.agents/skills/reel-kit
and follow the Codex steps. Your style, projects and videos in ~/reel-kit/ stay exactly as they are.

Update

New effects, fixes and features ship as releases (CHANGELOG.md says what each one
changes for you).

• Claude Code: automatic if you installed with the message above (it turns on auto-update): new releases
  download in the background and apply on your next session. Otherwise turn it on in /plugin > Marketplaces >
  reel-kit, or update now with /plugin update reel-kit@reel-kit.
• Cowork: Customize > Plugins, then Update on the reel-kit marketplace.
• Codex: git -C ~/.agents/reel-kit-src pull.
• ChatGPT Work (or the zip in Cowork): download the new reel-kit.zip from the latest release and upload it in
  place of the old skill.

After an update, your next video runs setup again by itself if the new release needs anything.

What an update never touches: your style pack, your projects and your finished videos. They live in ~/reel-kit/
(or the folder you gave Cowork or ChatGPT), not in the skill folder. Each project keeps its own copy of the style
and the effects it was made with, so a video you already made keeps its look after an update; new effects show
up in your next video. The cut, build and render steps do come from the kit you have now: if an old project ever
renders differently, its edit.py records the release it was started on (KIT_VERSION), and that release's tag
in this repo renders it exactly as before.

Change things through the agent, never by editing files inside the skill folder: "update my style" for your look,
a note on the storyboard for a single video. An update replaces the skill folder, and nothing of yours lives there.

Make a video

1. Run it with your clip, the mode and what it's about:
   /reel-kit:hifi ~/Videos/take.mov, about this article: <link> (or /reel-kit:lofi, /reel-kit:showcase; on
   Codex and ChatGPT, $reel-kit or @reel-kit and say the mode)
2. The agent cuts the take, plans every beat, builds the cards, and sends you the storyboard with a list of
   anything it needs from you (a screen recording, a screenshot of your dashboard), or "nothing needed".
3. Leave notes on the storyboard. Send what it asked for. Say go.
4. The finished video and a phone-size copy land next to your clip.

The storyboard opens as a Claude artifact with inline comments when you use Claude, or as a local page on your
computer anywhere else (your notes save to a file the agent reads).

Extend it (optional)

Everything above works out of the box with real footage, real screenshots and the kit's own sound effects. Connect
any of these to your agent to go further; the skill uses what it finds and skips what it doesn't.

Music is off by default. Most creators add a track when they post (Instagram, Edits, TikTok, CapCut), where it
can be a licensed trending sound. Generated images are used sparingly and tagged on the storyboard so you can cut
any of them before the render.

What's inside

.claude-plugin/       plugin.json (name, version) and marketplace.json: this repo is its own plugin marketplace
commands/             /reel-kit:hifi, :lofi, :showcase and :setup
agents/               fx-builder and card-builder, the subagents that build effects and cards in parallel
skills/reel-kit/      the kit itself (the folder Codex, Cowork's zip and ChatGPT install):
  SKILL.md              the instructions every agent reads
  modes/                hi-fi, lo-fi and showcase: how each edit is structured
  onboarding/           style setup: ONBOARDING.md, refs.py (studies inspiration videos), board.py (the style board)
  pipeline/             cut, transcribe, cutout, build, mix, storyboard, QA, render (Python)
  kit/                  the composition's CSS, the card and effect briefs, the style token and style pack references
  cards/                the motion-graphic card library (LIBRARY.md), each card driven by your tokens
  fx/                   the showcase effects library (LIBRARY.md), each effect driven by your tokens
  audio/sfx/            sound effects, synthesized from scratch for this kit (CC0)
  storyboard/           the review page and a local server for hosts without artifacts
  examples/             a reference edit.py for each mode, and three sample style packs
  setup/                setup.sh (start here), setup.py, package.py
  VERSION, CHANGELOG.md the release you have and what each release changed
  dev/                  the kit's own test bench, the README images, release.py
  docs/img/             the README images (dev/readme_shots.py regenerates them)

Credits and licenses

reel-kit is MIT licensed (see LICENSE). It stands on:

• HyperFrames (Apache-2.0): renders the video from HTML. Run through
  npx, pinned to one version.
• GSAP (GreenSock standard license, free): the animation timeline. Downloaded by setup, not
  included here.
• faster-whisper (MIT): word-level transcription.
• Robust Video Matting (GPL-3.0): the optional smoother cutout.
  Its model is downloaded only if you run setup.sh --matte; none of its code is in this repo.
• Fonts come from Google Fonts (SIL Open Font License), fetched for your pack.
• The sound effects are synthesized by audio/make_sfx.py and released CC0.
• The $1 bill in the dollar-split card is a US government work in the public domain.