agentleFS
decwapdecwap/video-edit/SKILL.md

video-edit

Skill1 starsChanged 8 days agoMITView on GitHub

Edit raw vertical talking-head footage — a phone recording full of retakes, mistakes and long pauses — into a polished 9:16 reel (TikTok / Reels / Shorts), rendered in Full HD or 2K with HyperFrames. It keeps the best take of every line, tightens the pauses, adds captions, a motion graphic every 2–3 seconds (paper cards, kinetic words, a pop-out face panel, giant words behind the head, punch-ins), real B-roll, transitions and light sound effects, then plays the edit in nine styles (Warm Paper, Midnight Glow, Storybook Doodle, Bold Editorial, Colour Block, Riso Print, Signal Terminal, Sticker Board, Aurora) side by side in a Style Picker and renders only the pick. Use it whenever someone shares a raw or face-to-camera video and wants it edited, cut down, cleaned up, "made engaging", given motion graphics, captions, B-roll, transitions or sound effects, asks to keep the good takes, says "video-edit", "edit my raw footage" or "edit it like this reel" — even if they never name the skill.

  • Reads credentials

29 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use flux-2-klein, flux-kontext and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • agentspace-soSkill

    flux-2-klein

    Generate images with Flux 2 Klein (Black Forest Labs' distilled fast variant of Flux 2) on RunComfy — bundled with the model's documented prompting patterns so the skill gets sharper output than naive prompting against the same model. Documents Flux 2 Klein's strengths (sub-second latency, multi-reference brand styling, declarative subject-first prompts), the step-count strategy (4–8 for fast iteration, ~25 for polish), the 9B vs 4B variant trade-off, and when to route to Flux 2 Pro / Seedream 5 / GPT Image 2 instead. Calls `runcomfy run blackforestlabs/flux-2-klein/9b/text-to-image` (or `/4b/`) through the local RunComfy CLI. Triggers on "flux 2 klein", "flux-2-klein", "flux klein", "BFL flux 2", or any explicit ask to generate with this model.

    Also in 4 projects that use this

  • agentspace-soSkill

    flux-kontext

    Edit images with Flux 1 Kontext Pro (Black Forest Labs' precise local image-edit model) on RunComfy — bundled with the model's documented prompting patterns so the skill gets sharper output than naive prompting against the same model. Documents Flux Kontext's strengths (single-reference precise local edits, strong prompt control, consistent high-fidelity outputs), the schema (single image + prompt), and when to route to Nano Banana Edit / GPT Image 2 edit / Flux 2 Klein instead. Calls `runcomfy run blackforestlabs/flux-1-kontext/pro/edit` through the local RunComfy CLI. Triggers on "flux kontext", "flux-kontext", "flux 1 kontext", "kontext", "BFL kontext", or any explicit ask to edit with this model.

    Also in 4 projects that use this

  • prime-skillsSkill

    ace-step

    Generate, inpaint, and outpaint music with ACE Step on RunComfy via the `runcomfy` CLI. ACE Step is StepFun-AI's open-weights music foundation model — tag-driven composition (genre, mood, instruments), multilingual lyrics with section markers, 5 s to 4 min stereo output, $0.0002–0.0003 per second (≈ 27× cheaper than ElevenLabs Music). Four endpoints: ACE Step text-to-audio (the default), ACE Step 1.5 text-to-audio (50+ language lyrics, refined structured-lyric handling), ACE Step audio-inpaint (regenerate a time range inside an existing track), ACE Step audio-outpaint (extend an existing track before or after). Triggers on "ace step", "ace-step", "acestep", "ACE music", "open music model", "cheap AI music", "inpaint audio", "audio inpaint", "extend music", "audio outpaint", "lengthen track", "music with tags", or any explicit ask to generate or edit music with ACE Step.

    Also in 3 projects that use this

  • prime-skillsSkill

    codex-pet

    Codex Pet generator on RunComfy. Build a Codex-compatible Codex Pet spritesheet.webp + pet.json from a single reference image, drop it into `${CODEX_HOME:-$HOME/.codex}/pets/<name>/` and Codex picks it up as a custom Codex Pet next to the 8 built-ins. This skill produces the exact Codex Pet atlas Codex expects (1536x1872 PNG/WebP, 8 cols x 9 rows, 192x208 cells, 9 animation states — idle, running-right, running-left, waving, jumping, failed, waiting, running, review). Calls OpenAI GPT Image 2 edit ONCE via the local RunComfy CLI as `runcomfy run openai/gpt-image-2/edit` to produce a canonical Codex Pet pose, then assembles all 9 animation rows programmatically with ImageMagick micro-transforms — no Codex Pro, no `$imagegen`, no OPENAI_API_KEY required, only RUNCOMFY_TOKEN. Triggers on "codex pet", "create codex pet", "make codex pet", "hatch codex pet", "/hatch image", "desktop pet codex", "codex pets", "spritesheet.webp", or any explicit ask to build a custom pet for OpenAI Codex.

    Also in 3 projects that use this

  • +3 more from agentspace-so
  • +5 more from prime-skills

The file

We split this skill into the rules it gives an agent

3 rules. 0 are common, 1 is distinctive, and 2 are very specific to this project.

  • 0

    Common

    Most of the 24 edited versions we read keep these.

  • 1

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Read references/takes.md before choosing takes, style.md + motion.md + sound.md before planning, pipeline.md before running commands, and …

    line 37
  2. Distinctive:

    Keep the best take of each line and every word of it.

    line 46
  3. Very specific:

    No music bed — light action sounds only (references/sound.md).

    line 49

“Common” is measured: kept by at least 6 in 10 of the 24 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Video Edit

Turns one raw vertical recording into a finished reel: the best read of every line (retakes, tangents and dead air removed), then the speaker alternating with paper cards, real B-roll and small UI props every 2–3 s, captions on every line, three payoff words behind the speaker's head, varied transitions (face-card rise/expand, paper cover, whip, flip, zoom-through, bar sweep, light-leak flash) and a light action sound on every visible event. Output: <name> (Edited).mp4 (1080×1920 Full HD, or 1440×2560 2K) and a frame sheet, next to the original.

Every edit comes in nine styles. The edit is built once (Warm Paper), then styles.py restyles it into Midnight Glow, Storybook Doodle, Bold Editorial, Colour Block, Riso Print, Signal Terminal, Sticker Board and Aurora — same cut, words, timing, footage, motion and sound; only the look changes. A workflow checks and fixes every style, the Style Picker plays all nine side by side in the browser, the creator picks one, and only the pick is rendered (references/styles.md).

The face panel is the default speaker layout: the speaker stays in a panel on the bottom third of the frame, with the head rising above its edge onto a light stage that carries the graphics (references/style.md, "Face panel"). It replaces the alternating full-frame layouts unless the user asks for them.

Worked example: a 5:26 iPhone recording → 16 takes → a 75 s reel with 34 beats — examples/takes.json, examples/STORYBOARD.md, examples/scenes.py + scenes_b.py.

Bundled: scripts/ — phrases.py (read the raw take, spot retakes), takes.py (best-take cuts snapped to the audio), aroll.py (wide + punch intermediates + clean voice; HDR → SDR), strip.py (raw→edited proof strip), prep_broll.py (clips from the creator's own videos), stock.py (Pexels B-roll, needs a free API key), screen_replace.py (app screens on a real phone), make_panel.py + face_panel.py (the pop-out face panel), make_matte.py (DEPTH cut-outs), video_kit.py (the scene kit, on reel_kit.py + paper_reel.py), verify_render.py, sync_check.py, styles.py (the nine styles, the Style Picker, per-style check / snapshots / the all-styles sheet), make_sfx.py + make_voice_sfx.py + make_textures.py (regenerate the assets). workflows/check-styles.js — one agent per style: check, look, fix. assets/ — fonts (OFL), original paper textures, 76 original sounds, Lucide icons (ISC, packed into one file, assets/icons.json). references/ — takes.md, style.md, styles.md, motion.md, sound.md, pipeline.md, storyboard-skeleton.md.

Read references/takes.md before choosing takes, style.md + motion.md + sound.md before planning, pipeline.md before running commands, and styles.md before step 10. HyperFrames' own skills (hyperframes-core, hyperframes-cli) own the composition contract — load them when you debug composition HTML.

Defaults (settled — follow unless the user asks otherwise)

  • 1080×1920 at the footage's own fps; Full HD delivery by default, 2K (1440×2560) when asked for "2K", "1440p", "higher quality" or when the source is 2K/4K; 4K on request (pipeline.md §7). Never ship below 1080×1920.
  • Face panel for the whole reel: the first frame is already the panel and the stage, and only the stage changes after that; captions are 1–3 words. Full-frame PUNCH, DEPTH and CARD beats and the old flat card (split_at) only when asked for.
  • Keep the best take of each line and every word of it; pauses tightened to a breath (~0.2 s).
  • No colour grade, no vignette: the footage keeps its own colours. HDR phone video is converted to SDR only so it doesn't play washed out.
  • No music bed — light action sounds only (references/sound.md).
  • All nine styles, then the creator picks; render only the pick. Build in Warm Paper (accent teal #0B7A73 on paper #F5F1EA; Instrument Serif Italic + Instrument Sans + JetBrains Mono), then steps 10–11. "Render all" or several letters → render each. If the creator names one style up front ("in Midnight Glow"), build and check only that one and skip the picker. A creator-chosen accent carries into every style.
  • Real visuals only: the creator's own videos, the product's real site/app, this recording's own frames. Never invent UI, logos, numbers or stats; keep links off screen when the CTA gates them ("comment X and I'll send it").
  • Final mix −14 LUFS / −1 dBTP; deliver <name> (Edited).mp4 next to the original; older versions stay in renders/.

Intake (one short form — only what the request and the footage don't answer)

  1. The CTA keyword, if they say "comment X" (ASR often mishears it; confirm the spelling).
  2. Folders or files of their own earlier videos, demos or screen recordings to use as B-roll (strongly preferred).
  3. Accent colour and resolution, if they care (default teal, Full HD). The style is chosen later, in the picker.
  4. Storyboard first, or straight to the build? Recommend "storyboard first, then build right away" (the render waits for the style pick either way).

Workflow

Track these as tasks; run long steps (A-roll, mattes, check, render) in the background with a log file.

  1. Set up — check the tools (pipeline.md §0). hyperframes init videos/<slug>, copy assets/fonts, assets/img/*.png and assets/sfx from this skill into the project's assets/, write BRIEF.md (message, audience, length, CTA, B-roll sources, notes).
  2. Look — probe (HDR? fps? duration), a 1-per-5 s contact sheet; note framing changes (pipeline.md §1).
  3. Best takes — transcribe → phrases.py → choose the last clean read of every line in the message's order → build/takes.json → takes.py --show → build the voice → re-transcribe the cut voice and read it; fix clipped or doubled words before anything else (references/takes.md). Note the jump-cut list.
  4. A-roll — aroll.py --face writes build/face/grid.jpg; read the head top, eye line and face-centre x on it, then aroll.py --head-top Y --eyes Y --face-x X (prints and uses the punch crop + face shift; add --size 1440x2560 for 2K).
  5. Plan — map the clean read onto beats with references/storyboard-skeleton.md: something new on the stage every 2–3 s, every jump cut covered (panel(tight=True) or a new stage), 1 held beat, 1 proof beat, 1 name reveal. For a full-frame reel on request: 3 DEPTH words, transitions varied. Write STORYBOARD.md and show the table (beat · time · layout · on screen · why) with the clean read.
  6. B-roll & props — prep_broll.py for the creator's own videos, real product captures, strip.py for a raw→edited proof, stock.py only when nothing real fits (needs PEXELS_API_KEY; pipeline.md §4). No past videos? Build the "styles like this" and held beats from clips of this recording in phone mockups, the raw→edited strip, captures of the named product, and stock clips of the named action; never fake someone else's content as the creator's.
  7. Face panel — make_panel.py --src assets/aroll_wide.mp4 as one background job: it fits the panel to this speaker, cuts the whole A-roll out and tracks the head (pipeline.md §5). DEPTH beats, if any: make_matte.py for each.
  8. Build — build/scenes.py on video_kit (start from examples/panel_scene.py; props and patterns from examples/scenes.py): use_panel(PROJECT / "build/panel.json"), reel.scene(), s.paper + panel for the speaker, graphics in framed / phone_vid / lay, s.seam_caps inside lay for captions, props from references/motion.md, a sound cue for every visible action (C(t, "sparkle-1", .4), T(t) on cuts into a punch-in or new section), then print(finish(reel, PROJECT, accent=…)). Reel(total=voice + 1.5–2 s, voice_dur=voice): the end card holds silent after the last word.
  9. Verify — hyperframes lint → hyperframes check until "Check passed" → snapshot one frame per beat and read every sheet (layout balance, nothing covering the face, captions in the safe zone) → fix → rebuild.
  10. Styles — python <SK>/scripts/styles.py build <P> (all nine, seconds). Then check them with the workflow: the Workflow tool with scriptPath: <SK>/workflows/check-styles.js and args: {"project": "<P>", "skill": "<SK>"} (absolute paths; add "python": "python" on Windows). Using this skill counts as asking for that workflow; it runs one agent per style (lint + check, frames against Warm Paper, fixes in build/style-overrides/<id>.css). No Workflow tool → styles.py check <P> + styles.py snap <P> and read each contact sheet yourself. Then styles.py sheet <P> → styles/sheet.jpg. A style the workflow reports as broken stays in the picker with its issue named, or is fixed first if the creator wants it.
  11. Pick — python <SK>/scripts/styles.py serve <P> as a background job; open the URL it prints (http://127.0.0.1:8770/picker.html, or the next free port) in the Browser pane (Claude Code desktop) and give the creator the same URL (any browser on this computer, while serve runs); send styles/sheet.jpg too (SendUserFile when you have it). Ask which style (A–I) and wait — never render before a pick. The picker's "Use this style" writes styles/pick.json; if they say it instead, styles.py pick <P> <id>. A change they ask for in one style goes in that style's override file (rebuild + check that style); a change to the edit itself goes back to step 8 and every style is built again.
  12. Render & deliver — the pick, from <P>: render styles/<pick> with an absolute --output into <P>/renders/ (styles.md, "Rendering the pick"; HD or 2K per pipeline.md §7), check the render log for unready media, read a few real frames at the panel's edge (pipeline.md §5), verify_render.py --sheet --normalize, sync_check.py (+0.0 ms), copy <name> (Edited).mp4 + frames sheet next to the original ("render all" / several picks: one render per style, <name> (Edited, <Style>).mp4). Stop serve. Summarise: what was cut (raw length → edit length, takes kept), what was built, the style picked, what was inferred (keyword spelling, caption corrections), and anything the footage couldn't support.

Writing scenes well

  • Text sizes are canvas pixels: seam caption 78 px; plates 78 px sans / 112–124 px serif; card keyword 150–300 px; DEPTH word 260–600 px. Captions stay inside y 760–1500, x 140–940.
  • Ink = the word that matters, g() grey = connective words, acc() = the one accent word. One keyword per card.
  • Ids are prefixed with the scene id; every timed element is a .clip; videos that start mid-scene live in s.body (phone_vid, framed, win_vid do it). Helpers take global seconds, J(s, …) lines take s.L(global).
  • Entrances 0.3–0.55 s (rise power3.out, pop back.out(1.6–2.4), slam expo.out from 1.25–1.5×); captions pop in over 0.16–0.2 s and swap by hard cut.
  • Balance every frame: CARD content centred near y 900 (card(dy=…)), props in a PUNCH above the shoulders not on the chin, a DEPTH word low enough that the hair covers its bottom edge, cursors entering from off-canvas.
  • Product visuals are real captures inside phone / browser / frame props; steps, commands and file names quote the tool's own docs or the user's real prompt.

Sound in one paragraph

Light and bright: crystal sparkle-1..3 when a real visual appears, marimba ting-1..5 (rotating, via T(t)) on every cut into a punch-in or new section, wooden click-1..3 per word or item as things stack in, glint when a big keyword lands, then the literal action — key-N typing, tap presses, ding checks, blip steps, riser→success completions, notify DMs, shutter cameras, paper-slide / card-place-* cards, marker strikes, whoosh-* / swoosh-* with whips and zooms. One thud (the name reveal). Volumes 0.16–0.5, at most two sounds on one instant, quiet held beats. The flavour library (meme / cinematic sounds) is opt-in by content — see references/sound.md.

Gotchas that cost the most time

  • Cutting on ASR times clips words: always takes.py (audio-snapped) and the re-transcription check.
  • Phone HDR played as SDR looks washed out; phones are variable-frame-rate — aroll.py handles both.
  • Many separate images → some render blank: one sprite (strip.py), and read the render log for readiness warnings.
  • A line across the head at the panel's edge: footage and cutout have different colour tags; make_panel.py tags both.
  • Full list: references/pipeline.md §8.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.