Przejdź do treści
Biblioteka skilli
Marketing i treści · Konwersja i formaty

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.

Repozytorium
video-edit ↗
Licencja
MIT
Ostatnia zmiana repozytorium
08.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 08.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

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

  1. Defaults (settled — follow unless the user asks otherwise)
  2. Intake (one short form — only what the request and the footage don't answer)
  3. Workflow
  4. Writing scenes well
  5. Sound in one paragraph
  6. Gotchas that cost the most time
Sekcje z nagłówków SKILL.md, w oryginale · 137 linii, 1 927 słów
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

RepozytoriumWynikLicencja
Ta strona · decwap/video-edit100MIT
video-db/skills100MIT
calesthio/OpenMontage100AGPL-3.0
github774/claude-video-studio100MIT
0xSero/video-edit100MIT
chriscrosscutler/video-edit100Apache-2.0
teamwiseflow/xiaobei100Apache-2.0
agentspace-so/runcomfy-agent-skills100MIT
YildizDikme/claude-video-edit95MIT

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.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.