video-edit
/video-edit
Montuje surowe pionowe nagrania z gadającą głową w dopracowany reel 9:16, zachowując wybrane ujęcia i dodając napisy.
- Autor
- decwap ↗
- Repozytorium
- video-edit ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 08.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 4
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 1
Brak sygnałów. Repozytorium zmienione 08.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Montuje surowe pionowe nagrania z gadającą głową w dopracowany reel 9:16, zachowując wybrane ujęcia i dodając napisy.
Oryginalny opis (EN)
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 B
Jak działa
- Defaults (settled — follow unless the user asks otherwise)
- Intake (one short form — only what the request and the footage don't answer)
- Workflow
- Writing scenes well
- Sound in one paragraph
- Gotchas that cost the most time
Podgląd SKILL.md
---
name: video-edit
description: 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.
compatibility: Claude Code (needs a shell and the local filesystem). Node.js 18+ (HyperFrames CLI via npx), ffmpeg + ffprobe with zscale and libvpx-vp9, Python 3.10+ with numpy, scipy, pillow and opencv-python. A free Pexels API key (PEXELS_API_KEY) for stock clips only. Windows, macOS or Linux.
---
# 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.
Pliki w paczce (4)
- .gitignore 1 KB
- LICENSE 1 KB
- README.md 8 KB
- SKILL.md 14 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · decwap/video-edit | 100 | MIT |
| video-db/skills | 100 | MIT |
| calesthio/OpenMontage | 100 | AGPL-3.0 |
| github774/claude-video-studio | 100 | MIT |
| 0xSero/video-edit | 100 | MIT |
| chriscrosscutler/video-edit | 100 | Apache-2.0 |
| teamwiseflow/xiaobei | 100 | Apache-2.0 |
| agentspace-so/runcomfy-agent-skills | 100 | MIT |
| YildizDikme/claude-video-edit | 95 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki 6b75edf1969f (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 87ghost-editor
Montuje surowe nagranie osoby mówiącej do kamery w gotowy pionowy reel 1080x1920: wybiera najudatniejsze ujęcia, skraca pauzy, dodaje napisy, sceny ruchu, efekty dźwiękowe, muzykę i B-roll. - 100edit-footage
Zamienia własne surowe nagranie mówione w pionową rolkę lokalnie i bez kosztów: transkrypcja, wybór właściwego ujęcia, usuwanie pauz i napisy. - 95video-editing
Montuje filmy z mówiącymi osobami na lokalnym komputerze darmowymi narzędziami: usuwa pauzy, dodaje napisy i formatuje pod Reels, Shorts i TikTok. - 100animation-video
Zamienia skrypt lub temat w krótki edukacyjny film animowany 9:16, z grafiką, napisami synchronizowanymi ze słowami, lektorem i muzyką. - 100auto-video-edit
Montuje w pełni automatycznie filmy z gadającą głową: wycina ciszę, dodaje zbliżenia, kartki statystyk i korekcję kolorów. - 100edit-footage-with-code
Montuje surowe nagrania z agentem: usuwa martwą ciszę i pomyłki, dodaje napisy, grafiki i dźwięk w HyperFrames lub Remotion, sprawdzając wynik liczbowo.