Skip to content
Back to search

clipify

Find compelling moments in a video — funny dialogue OR repeated impact actions like axe chops, hits, throws, drumbeats — cut them as standalone clips, optionally reformat 16:9 ↔ 9:16, time-warp pans for tighter reveals, and burn opus-style word-by-word captions. Use when the user mentions "clipify," "cut clips from this video," "make shorts from this," "find funny moments," "action montage," "cut on each chop/hit/punch," "reframe to 9:16," "vertical clips," or pastes a video file path and wants social-ready cuts.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/louisedesadeleer-clipify/badge.svg)](/listings/louisedesadeleer-clipify)

HTML

<a href="/listings/louisedesadeleer-clipify"><img src="/api/listings/louisedesadeleer-clipify/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/louisedesadeleer/clipify.git ~/.claude/skills/clipify

That's it. Restart Claude Code and `/clipify` is available as a slash command.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 244 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: clipify
  3. description: Find compelling moments in a video — funny dialogue OR repeated impact actions like axe chops, hits, throws, drumbeats — cut them as standalone clips, optionally reformat 16:9 ↔ 9:16, time-warp pans for tighter reveals, and burn opus-style word-by-word captions. Use when the user mentions "clipify," "cut clips from this video," "make shorts from this," "find funny moments," "action montage," "cut on each chop/hit/punch," "reframe to 9:16," "vertical clips," or pastes a video file path and wants social-ready cuts.
  4. ---
  5. # Clipify
  6. Find compelling moments in a video, cut them as standalone clips, optionally reformat 16:9 → 9:16 (face-pan or split-screen), time-warp pans for tighter reveals, and burn opus-style word-by-word captions.
  7. ## Modes
  8. Pick one before Step 1. The choice changes how you find moments and whether captions apply.
  9. - **Dialogue mode** (default for podcasts, interviews, talking-heads): Whisper transcribes, you scan for punchlines / reactions / awkward pauses. → Step 1A. Captions in Step 5.
  10. - **Action mode** (woodchopping, sports, percussion, drumming, anything with repeated impact sounds): skip Whisper entirely, run `detect_transients.py` to find each strike, cut on each one. → Step 1B. Skip Step 5; the strike sounds *are* the rhythm.
  11. - **Hybrid**: dialogue mode for talking sections, action mode for the rest, intercut. Use both 1A and 1B.
  12. If the user says "I'm not talking in this," you're in action mode. If they say "cut on each X" (chop, hit, punch, drumbeat, swing, footstep), you're in action mode. Default to dialogue mode otherwise.
  13. ## Inputs
  14. - A video file path (the user will provide it; otherwise ask)
  15. - Optional: requested format (9:16, 16:9, 1:1) — if not given, ask after candidates are picked
  16. - Optional: subtitle style preference — if not given, ask before captioning
  17. ## Tooling (use only the fastest path)
  18. - **Whisper:** `whisper --model tiny.en --word_timestamps True --output_format json` (≈10× faster than `small.en`; quality fine for English). For non-English: `--model base` (drop `--language`).
  19. - **ffmpeg:** add `-hwaccel videotoolbox` for decode and `-preset ultrafast` for renders. Use `-c:v libx264 -crf 20` for the final master.
  20. - **Numpy** for audio alignment (FFT cross-correlation). No scipy/cv2 needed.
  21. - **Scripts:** `<skill-dir>/scripts/` (where `<skill-dir>` is the directory containing this SKILL.md — typically `~/.claude/skills/clipify/`)
  22. - `analyze.py` — speaker timeline from two ROI motion files
  23. - `build_pan.py` — ffmpeg crop x-expression with hard cuts
  24. - `build_ass.py` — opus-style ASS captions from whisper JSON
  25. - `audio_align.py` — find offset of a sub-clip in a longer source
  26. - `detect_transients.py` — find sharp impact sounds (action mode); see `--help`
  27. Working dir: `/tmp/clipify/` (mkdir at start, leave artifacts for debugging).
  28. ---
  29. ## Workflow
  30. ### Step 1A — Find dialogue moments (dialogue mode)
  31. ```bash
  32. mkdir -p /tmp/clipify
  33. ffmpeg -y -hwaccel videotoolbox -i "$VIDEO" -vn -ac 1 -ar 16000 /tmp/clipify/audio.wav
  34. whisper /tmp/clipify/audio.wav --model tiny.en --word_timestamps True --output_format json --output_dir /tmp/clipify --language en
  35. ```
  36. Read the resulting JSON (or `.txt`) and pick 3–5 candidate clips. Funny signals to scan for:
  37. - **Punchlines and reactions:** words like "what", "wait", "no way", laughter, "haha", swearing
  38. - **Reversal moments:** setup question → unexpected answer
  39. - **Awkward pauses:** Whisper segment with long gap, or filler ("uh", "um")
  40. - **Self-roast / quotable one-liners:** short declarative sentences that stand alone
  41. - **Audio peaks:** detect via `ffmpeg -af volumedetect` or look for rapid back-and-forth (alternating short Whisper segments)
  42. For each candidate, propose: `[start, end, why-it's-funny, suggested title]`. Aim for 10–25s clips. Show the list and let the user confirm/pick.
  43. ### Step 1B — Find each strike (action mode)
  44. Replace Whisper with audio-transient detection. The detector finds sharp impacts (axe-on-wood, fist-on-pad, drumhead, ball-on-bat, wood landing on a pile) by computing spectral flux on the 1–6 kHz band — the broadband impulse an impact creates that ambient/wind doesn't.
  45. ```bash
  46. ffmpeg -y -hwaccel videotoolbox -i "$VIDEO" -vn -ac 1 -ar 16000 /tmp/clipify/audio.wav
  47. python3 <skill-dir>/scripts/detect_transients.py /tmp/clipify/audio.wav \
  48. --min-flux 30 --min-gap 0.6 > /tmp/clipify/strikes.json
  49. ```
  50. Tuning:
  51. - `--min-flux 30` is the sane default. Real impacts register 50–300; ambient/wind sits at 5–15. Too many false positives → raise to 40–50. Too few hits → drop to 20.
  52. - `--min-gap 0.6` (seconds) is the closest two strikes can be. Fast drumming may need 0.2; chopping is fine at 0.6–1.0.
  53. - `--band 1000:6000` covers wood/metal/glass impacts. Heavy thuds (kick drum, body shots) live lower (`--band 200:2000`); whistles/clinks/snare cracks higher (`--band 4000:10000`).
  54. - For multi-clip sources (a folder of phone clips), run the detector on each clip and pick a varied set across angles. Aim for 50–65 strikes for a 45–60s montage at ~0.9s per shot.
  55. Each "shot" should start ~0.4s before the strike (showing wind-up) and end ~0.5s after (strike + brief follow-through). That's ~0.9s per beat.
  56. ### Step 1.5 — Verify each candidate is in frame
  57. **Always do this before rendering**, in either mode. Audio detection finds the *sound* of an event; the camera might not have captured it. Skipping this is the #1 way to get user feedback like "you cut on chops where I'm not even visible."
  58. ```bash
  59. # Sample one frame at each candidate strike time T:
  60. for T in $STRIKE_TIMES; do
  61. ffmpeg -y -ss "$T" -i "$VIDEO" -frames:v 1 -vf scale=320:-1 \
  62. /tmp/clipify/verify_${T}.jpg
  63. done
  64. ```
  65. Read each verify image and drop the candidate if:
  66. - The subject is bent down, off-frame, or behind an obstacle
  67. - A thumb is on the lens (yes, this happens — and you only catch it visually)
  68. - It's clearly a different sound source (door slam, dropped tool) that triggered the detector
  69. For ~30 candidates this is one fast `ffmpeg` call each plus a single batch image read. Cheap insurance.
  70. ### Step 2 — Trim each chosen clip
  71. ```bash
  72. ffmpeg -y -ss "$START" -t "$DURATION" -i "$VIDEO" -c copy /tmp/clipify/clip_$N.mp4
  73. ```
  74. (Use `-c copy` for instant trim. Re-encode only if cuts must be frame-accurate.)
  75. ### Step 3 — Decide the output format
  76. Ask the user (skip if they already specified): "9:16 (TikTok / Reels), 16:9 (YouTube), or 1:1 (Insta feed)?"
  77. ### Step 4 — If 16:9 → 9:16: pan-between-faces vs split-screen
  78. Detect source aspect with `ffprobe`. If source is 16:9 and target is 9:16, ask:
  79. > "Two options: **(a) hard-cut pan** that follows whoever is speaking (single face on screen at a time), or **(b) split-screen** stack with both faces visible. Which do you want?"
  80. Skip the question if there's only one face (single-talker clip). For single-talker, just center-crop.
  81. #### Step 4a — Pan-between-faces (recommended for fast-cut talking-head dialogue)
  82. 1. **Locate the two face ROIs.** Sample one frame: `ffmpeg -ss <middle> -i <clip> -frames:v 1 /tmp/clipify/probe.jpg`. Read it. Eyeball each face's mouth+chin area as `x,y,w,h` in the source's pixel space. (No cv2 needed — camera is static within a clip; one frame is enough.) Verify by drawing boxes:
  83. ```bash
  84. ffmpeg -i probe.jpg -vf "drawbox=x=$LX:y=$LY:w=$LW:h=$LH:color=cyan@0.9:t=4,drawbox=x=$RX:y=$RY:w=$RW:h=$RH:color=magenta@0.9:t=4" verify.jpg
  85. ```
  86. Iterate **at most twice**. Boxes should cover mouth + chin and avoid hands/mics. Don't over-tune — frame differencing is forgiving.
  87. 2. **Extract per-frame motion energy in each ROI:**
  88. ```bash
  89. ffmpeg -y -i clip.mp4 -filter_complex "
  90. [0:v]split=2[a][b];
  91. [a]crop=$LW:$LH:$LX:$LY,format=gray,tblend=all_mode=difference,signalstats,metadata=mode=print:key=lavfi.signalstats.YAVG:file=/tmp/clipify/L.txt[la];
  92. [b]crop=$RW:$RH:$RX:$RY,format=gray,tblend=all_mode=difference,signalstats,metadata=mode=print:key=lavfi.signalstats.YAVG:file=/tmp/clipify/R.txt[ra]
  93. " -map "[la]" -f null - -map "[ra]" -f null -
  94. ```
  95. 3. **Build speaker timeline** (min dwell 1.0s — short interjections merge into the prior speaker):
  96. ```bash
  97. python3 <skill-dir>/scripts/analyze.py /tmp/clipify/L.txt /tmp/clipify/R.txt 1.0 > /tmp/clipify/segments.json
  98. ```
  99. 4. **Pick pan x-coordinates** for a 9:16 vertical strip from the source. With source W=1920 and target W=1080, crop strip width = 608.
  100. - LEFT_X = `face_left_center_x - 304` (clamp ≥ 0)
  101. - RIGHT_X = `face_right_center_x - 304` (clamp ≤ source_W - 608)
  102. 5. **Generate the hard-cut x expression and render:**
  103. ```bash
  104. EXPR=$(python3 <skill-dir>/scripts/build_pan.py /tmp/clipify/segments.json $LEFT_X $RIGHT_X)
  105. ffmpeg -y -hwaccel videotoolbox -i clip.mp4 -filter_complex \
  106. "[0:v]crop=608:1080:x='$EXPR':y=0,scale=1080:1920:flags=lanczos[v]" \
  107. -map "[v]" -map 0:a -c:v libx264 -preset fast -crf 20 -pix_fmt yuv420p \
  108. -c:a aac -b:a 192k /tmp/clipify/clip_panned.mp4
  109. ```
  110. Source 1920×1080 assumed; for 4K source either downscale first or double all coordinates.
  111. #### Step 4b — Split-screen (both faces always visible)
  112. Two stacked tiles, 1080×960 each. The active speaker's tile is on top — overlay flips at speaker changes.
  113. ```
  114. [0:v]split=2[a0][a1];
  115. [a0]crop=Wcrop:Hcrop:LX_tile:LY_tile,scale=1080:960,split=2[lt0][lt1];
  116. [a1]crop=Wcrop:Hcrop:RX_tile:RY_tile,scale=1080:960,split=2[rt0][rt1];
  117. [lt0][rt0]vstack[layoutL];
  118. [rt1][lt1]vstack[layoutR];
  119. [layoutL][layoutR]overlay=0:0:enable='<RIGHT_SPEAKER_ENABLE>'[v]
  120. ```
  121. Build `<RIGHT_SPEAKER_ENABLE>` from `segments.json` as `between(t,a,b)+between(t,a,b)+...` over the right-speaker segments. Tile crops should target ~720×640 around each face (1.125:1 to match 1080×960).
  122. ### Step 4c — Time-warping reveals (optional)
  123. When the user wants a slow scenic / pan / reveal shot tightened ("cut this in half") without losing the arc, speed-ramp instead of trimming. Trimming forces you to drop part of the arc; speed-ramping preserves all the beats at higher tempo.
  124. ```bash
  125. # 2x speed: 12s arc → 6s output, audio pitch preserved via atempo
  126. ffmpeg -y -ss "$START" -i "$CLIP" -t "$ORIG_DUR" \
  127. -vf "setpts=PTS/2,scale=1080:1920:flags=lanczos,fps=30" \
  128. -af "atempo=2.0" \
  129. -c:v libx264 -preset fast -crf 21 -pix_fmt yuv420p \
  130. -c:a aac -b:a 128k /tmp/clipify/clip_2x.mp4
  131. ```
  132. Rules of thumb:
  133. - **1.5x** — human movement that should feel "slightly brisk" without looking sped up
  134. - **2x** — punchier reveal; still reads as natural
  135. - **3x–4x** — time-lapse vibe (chain `atempo=2.0,atempo=2.0` for 4x; `atempo` accepts only 0.5–2.0 per filter instance)
  136. - Drop `-af atempo` and mute the segment if the audio is just ambient/wind and the chipmunking would be distracting
  137. Useful when the rest of the cut is rhythmic (chop montage, chat back-and-forth) and the reveal would otherwise feel like a dead spot.
  138. ### Step 5 — Add subtitles
  139. Skip this step in action mode — the strike sounds are the rhythm and captions just clutter the visual.
  140. Ask once (only if user hasn't already specified a style):
  141. > "Three subtitle styles: **opus** (big bold white, yellow active-word highlight), **karaoke** (4-word chunks, green highlight), **minimal** (clean Helvetica, no highlight). Or paste an example you like."
  142. If they paste a reference image/example: match the font, size, weight, color, position, and animation as closely as possible — write a custom ASS by hand or extend `build_ass.py`.
  143. Else use the preset:
  144. ```bash
  145. # Re-run whisper on the trimmed clip for accurate timestamps relative to clip start
  146. whisper /tmp/clipify/clip_panned.mp4 --model tiny.en --word_timestamps True --output_format json --output_dir /tmp/clipify --language en
  147. python3 <skill-dir>/scripts/build_ass.py /tmp/clipify/clip_panned.json /tmp/clipify/captions.ass opus
  148. ```
  149. Burn captions:
  150. ```bash
  151. ffmpeg -y -i /tmp/clipify/clip_panned.mp4 -vf "subtitles=/tmp/clipify/captions.ass" \
  152. -c:v libx264 -preset fast -crf 20 -c:a copy "$OUTPUT.mp4"
  153. ```
  154. ### Step 6 — Deliver
  155. - Save each output to `<source_dir>/clipify_out/` (mkdir if missing)
  156. - Print one line per clip: name, duration, what was funny, output path
  157. - Open the first output with `open <path>` so the user can check it
  158. - Offer to iterate (different style, different ROI, swap to split-screen, retime captions)
  159. ---
  160. ## Pitfalls (lessons from prior runs — don't repeat)
  161. - **Audio detection ≠ visible event.** Always run Step 1.5 (verify each candidate frame) before rendering. The detector finds the *sound* of a chop, not whether the chopper is in frame. Hits where the subject is bent over, off-camera, or where a thumb is on the lens still trigger the audio detector. Catch them before rendering.
  162. - **Spectral-flux band matters.** Default `--band 1000:6000` covers wood/metal/glass impacts. Heavy low thuds (kick drum, body shots) need `--band 200:2000`. Whistles, clinks, snare cracks need `--band 4000:10000`. If `--min-flux 30` returns nothing, try lowering to 15 first; if it returns thousands, try a different band before raising the threshold.
  163. - **Speed-ramp audio in pairs.** `atempo` accepts only 0.5–2.0 in a single filter; for 4x chain `atempo=2.0,atempo=2.0`. Without `atempo`, `setpts` alone gives chipmunk audio.
  164. - **Don't over-tune ROIs.** Two iterations max. Motion-diff is forgiving — wider ROIs covering mouth+chin work fine even if not perfectly mouth-centered.
  165. - **Watch out for scene cuts inside a clip.** Run `ffmpeg -filter:v "select='gt(scene,0.3)',showinfo" -f null -` to count cuts. If a 16:9→9:16 clip has many cuts, the fixed face ROIs only work for the dominant scene; warn the user, and offer to either pick a single-take clip or accept off-center framing during cuts.
  166. - **Source resolution matters.** If source is 4K, either downscale to 1920×1080 first (faster, fine for 9:16 output) or multiply all ROI/pan coordinates by 2.
  167. - **Burned-in subtitles in source.** Some "raw" clips still have subtitles. If so, find the no-subs master via audio cross-correlation (`audio_align.py`) and trim from there.
  168. - **Don't run whisper on the full feature-length source if a short clip suffices.** Whisper the trimmed clip after Step 2; only whisper the full source in Step 1 if you need a transcript to find funny moments.
  169. - **State the plan in one line, then act.** Don't narrate every iteration.
README.md · README · 83 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Clipify
  2. A [Claude Code](https://claude.com/claude-code) skill that turns long videos into social-ready clips.
  3. ![Clipify turns long videos into 9:16 social clips](assets/preview.png)
  4. Point it at any video file and it will:
  5. 1. **Find clip-worthy segments** — transcribes the video with [Whisper](https://github.com/openai/whisper) and scans the transcript for punchlines, reversals, awkward pauses, and audio peaks to propose 3–5 candidates.
  6. 2. **Create a 9:16 clip** — cuts your chosen moment, then reframes 16:9 → 9:16 with hard-cut pans that follow whoever is speaking (or split-screen if you'd rather see both faces).
  7. 3. **Add subtitles** — burns opus-style word-by-word captions (big bold white, yellow active-word highlight).
  8. No cloud APIs. Runs entirely on your machine. No OpenCV. ~20s of work for a 20s clip on Apple Silicon.
  9. ## Why this exists
  10. Most "auto-clip" tools are either expensive SaaS, slow, or produce slop. This skill is what I actually use to clip my long-form videos for LinkedIn and TikTok. Built for talking-head dialogue (interviews, podcasts, two-person setups).
  11. ## Requirements
  12. - macOS (uses VideoToolbox for hardware-accelerated decode — works on Linux/Windows if you remove `-hwaccel videotoolbox` flags)
  13. - [Claude Code](https://claude.com/claude-code)
  14. - `ffmpeg` with `libx264` (`brew install ffmpeg`)
  15. - [`whisper`](https://github.com/openai/whisper) (`pip install openai-whisper`)
  16. - Python 3 with `numpy` (`pip install numpy`)
  17. ## Install
  18. ```bash
  19. git clone https://github.com/louisedesadeleer/clipify.git ~/.claude/skills/clipify
  20. ```
  21. That's it. Restart Claude Code and `/clipify` is available as a slash command.
  22. ## Usage
  23. In Claude Code:
  24. ```
  25. /clipify
  26. ```
  27. Then paste a video file path when asked. The skill will:
  28. 1. Transcribe → propose 3–5 funny candidate clips with timestamps and titles
  29. 2. Ask which to cut
  30. 3. Ask 9:16 / 16:9 / 1:1
  31. 4. If 9:16 from 16:9 with two faces: ask pan vs split-screen
  32. 5. Ask subtitle style (opus / karaoke / minimal — or paste a reference image to match)
  33. 6. Render and open the result
  34. Final clips land in `<source-video-dir>/clipify_out/`.
  35. ## How the face-pan works
  36. No face detection model. Camera is static within a single clip, so:
  37. 1. Eyeball each face's mouth+chin area as a rectangle on one sample frame.
  38. 2. ffmpeg computes per-frame motion energy in each rectangle using frame differencing.
  39. 3. Whichever rectangle has more motion at a given moment = that's the speaker.
  40. 4. Build a hard-cut x-coordinate expression from the speaker timeline.
  41. 5. Crop a vertical strip from the source that follows whoever's talking.
  42. Total cost: a few seconds of ffmpeg per clip. Works surprisingly well.
  43. ## Repo structure
  44. ```
  45. clipify/
  46. ├── SKILL.md # the skill prompt Claude Code reads
  47. ├── scripts/
  48. │ ├── analyze.py # speaker timeline from two ROI motion files
  49. │ ├── build_pan.py # ffmpeg crop x-expression with hard cuts
  50. │ ├── build_ass.py # opus/karaoke/minimal ASS captions from whisper JSON
  51. │ └── audio_align.py # find offset of a sub-clip in a longer source
  52. └── README.md
  53. ```
  54. ## License
  55. MIT — see [LICENSE](LICENSE).
  56. Built by [Louise de Sadeleer](https://github.com/louisedesadeleer), Growth at [Tella](https://tella.tv).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.