Skip to content
Back to search

claude-shorts

SkillWorks with Claude CodeGitHub

Interactive longform-to-shortform video creator — Claude Code skill with Remotion-rendered animated captions, AI segment scoring, cursor tracking, and audio-aware boundary snapping

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/agricidaniel--claude-shorts/badge.svg)](/listings/agricidaniel--claude-shorts)

HTML

<a href="/listings/agricidaniel--claude-shorts"><img src="/api/listings/agricidaniel--claude-shorts/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.

# Clone the repository
git clone https://github.com/AgriciDaniel/claude-shorts.git
cd claude-shorts

# Install Python + Node.js dependencies
bash setup.sh

# Install as a Claude Code skill
bash install.sh

Windows

claude-shorts requires Unix tools (FFmpeg, bash). On Windows, use [WSL 2](https://learn.microsoft.com/en-us/windows/wsl/install):

# Inside WSL
git clone https://github.com/AgriciDaniel/claude-shorts.git
cd claude-shorts
bash setup.sh
bash install.sh

What `setup.sh` does

- Creates a Python virtual environment at `~/.shorts-skill/` (or reuses `~/.video-skill/` if it exists) - Installs `faster-whisper`, `mediapipe`, `numpy`, `opencv-python`, and PyTorch (CUDA or CPU variant) - Runs `npm install` in the `remotion/` directory - Checks for system dependencies (FFmpeg, jq)

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 · 335 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: shorts
  3. description: >
  4. Interactive longform-to-shortform video creator. Extracts viral-ready short clips
  5. from long videos using Claude as the orchestrator. Transcribes with faster-whisper
  6. (GPU), Claude scores and presents candidate segments interactively, user picks and
  7. adjusts, Remotion renders premium animated captions (Bold/Bounce/Clean styles),
  8. FFmpeg exports platform-optimized files (YouTube Shorts, TikTok, Instagram Reels).
  9. Use when user says "shorts", "short clips", "shortform", "extract clips",
  10. "tiktok from video", "reels from video", "vertical clips", or "create shorts".
  11. allowed-tools:
  12. - Bash
  13. - Read
  14. - Write
  15. - Edit
  16. - AskUserQuestion
  17. - Task
  18. ---
  19. # shorts — Interactive Shortform Video Creator
  20. You are an interactive shortform video producer. You guide the user through a 10-step
  21. pipeline where YOU (Claude) analyze the transcript, identify the best segments, present
  22. them for approval, snap boundaries to natural audio cut points, and render premium
  23. vertical videos with animated captions.
  24. ## Pre-Flight
  25. Before starting, locate the project root:
  26. ```bash
  27. # Try common locations in priority order
  28. SHORTS_ROOT=""
  29. for dir in "$HOME/.claude/skills/shorts" "$HOME/.claude/skills/claude-shorts" "$HOME/claude-shorts" "$(pwd)"; do
  30. if [ -f "$dir/SKILL.md" ]; then
  31. SHORTS_ROOT="$dir"
  32. break
  33. fi
  34. done
  35. if [ -z "$SHORTS_ROOT" ]; then
  36. echo "ERROR: shorts skill project root not found. Please run from the project directory or install with install.sh"
  37. fi
  38. ```
  39. Set up the temp directory (configurable via `SHORTS_TMP` environment variable):
  40. ```bash
  41. SHORTS_TMP="${SHORTS_TMP:-/tmp/claude-shorts}"
  42. mkdir -p "$SHORTS_TMP/clips"
  43. ```
  44. ## 10-Step Interactive Pipeline
  45. ### Step 1: PREFLIGHT
  46. Run safety checks on the input video:
  47. ```bash
  48. bash "$SHORTS_ROOT/scripts/preflight.sh" INPUT_FILE [OUTPUT_DIR]
  49. ```
  50. If preflight fails, report errors and stop. If warnings exist, report them and ask
  51. the user whether to proceed.
  52. Also detect GPU capabilities:
  53. ```bash
  54. bash "$SHORTS_ROOT/scripts/detect_gpu.sh"
  55. ```
  56. Report to user: input duration, resolution, GPU status, estimated processing time.
  57. ### Step 2: TRANSCRIBE
  58. Transcribe with faster-whisper (GPU-accelerated, word-level timestamps).
  59. Audio extraction is handled internally by transcribe.py:
  60. ```bash
  61. VENV="$HOME/.video-skill"
  62. [ -d "$VENV" ] || VENV="$HOME/.shorts-skill"
  63. source "$VENV/bin/activate"
  64. python3 "$SHORTS_ROOT/scripts/transcribe.py" INPUT_FILE \
  65. --output $SHORTS_TMP/transcript.json
  66. ```
  67. Output is dual-format JSON:
  68. - `segments[]` — WhisperX-style with word timestamps (for Claude to read)
  69. - `captions[]` — Remotion-native `{text, startMs, endMs}` array (for rendering)
  70. Report to user: transcription time, word count, language detected.
  71. ### Step 3: DETECT CONTENT TYPE
  72. Auto-detect whether the video is talking-head, screen recording, or podcast:
  73. ```bash
  74. python3 "$SHORTS_ROOT/scripts/detect_content.py" INPUT_FILE \
  75. --output $SHORTS_TMP/content_type.json
  76. ```
  77. Report detected type to user. Ask if they want to override.
  78. - **talking-head**: Face-tracked center crop to 9:16
  79. - **screen**: Letterboxed framed layout (content centered, dark padding)
  80. - **podcast**: Side-by-side speaker tracking or center crop
  81. ### Step 4: ANALYZE — Claude Reads Transcript
  82. Read the full transcript directly:
  83. ```
  84. Read $SHORTS_TMP/transcript.json
  85. ```
  86. Also load the scoring rubric:
  87. ```
  88. Read $SHORTS_ROOT/references/scoring-rubric.md
  89. ```
  90. Score 8-12 candidate segments (15-55 seconds each) on 5 dimensions:
  91. | Dimension | Weight | What to look for |
  92. |-----------|--------|------------------|
  93. | Hook strength | 0.30 | Bold claims, curiosity gaps, value promises, pattern interrupts |
  94. | Standalone coherence | 0.25 | Makes complete sense without any context from the rest of the video |
  95. | Emotional intensity | 0.20 | Strong opinions, surprise reveals, humor, passion |
  96. | Value density | 0.15 | Actionable insights, data points, frameworks per second |
  97. | Payoff quality | 0.10 | Satisfying conclusion — punchline, reveal, call-to-action |
  98. **Weighted score** = sum of (dimension_score * weight), scale 0-100.
  99. For each candidate, identify:
  100. - Start/end timestamps (to the nearest second)
  101. - A suggested hook line (first 3 seconds of text overlay)
  102. - Brief rationale (1 sentence explaining why this segment works)
  103. **Transcript cleanup:** While analyzing, also produce cleaned captions for rendering.
  104. Read the `captions[]` array from transcript.json, then:
  105. 1. Remove filler words (um, uh, you know, like, sort of, I mean, right, basically, actually)
  106. 2. Fix obvious transcription errors based on surrounding context
  107. 3. Consolidate incomplete sentence fragments where appropriate
  108. 4. **Keep all timestamps unchanged** — only modify the `text` field
  109. Write the cleaned transcript to `$SHORTS_TMP/transcript_cleaned.json` using the same
  110. JSON structure as transcript.json (both `segments` and `captions` arrays). The `captions`
  111. array should contain the cleaned text; copy `segments` as-is.
  112. ### Step 5: PRESENT — Show Candidates Interactively
  113. Present candidates in a formatted table:
  114. ```
  115. | # | Time | Dur | Score | Hook | Why |
  116. |---|---------------|------|-------|-----------------------------------|----------------------------------------|
  117. | 1 | 04:22 → 05:01 | 39s | 87 | "Nobody talks about this..." | Contrarian take with data backing |
  118. | 2 | 12:45 → 13:28 | 43s | 82 | "Here's the exact framework..." | Complete actionable method, clean arc |
  119. | 3 | 08:11 → 08:52 | 41s | 79 | "I tested this for 6 months..." | Personal story + surprising result |
  120. ```
  121. Then ask the user using AskUserQuestion:
  122. 1. **Which segments?** — "all", specific numbers, or "none, re-analyze"
  123. 2. **Caption style?** — bold (ALL CAPS pop-in), bounce (bouncy colorful), clean (minimal fade)
  124. 3. **Platform?** — youtube, tiktok, instagram, or all
  125. ### Step 6: APPROVE — Interactive Adjustment Loop
  126. After user selects segments:
  127. - Show selected segments with exact timestamps
  128. - Allow timecode adjustments ("move segment 2 start back 3 seconds")
  129. - Confirm final selections
  130. - Estimate render time (~15-30s per segment with Remotion)
  131. Write approved segments to:
  132. ```bash
  133. cat > $SHORTS_TMP/approved_segments.json << 'EOF'
  134. {
  135. "segments": [
  136. {
  137. "id": 1,
  138. "start": 262.0,
  139. "end": 301.0,
  140. "hook_line1": "Nobody talks about this...",
  141. "hook_line2": "The hidden cost of scaling",
  142. "score": 87
  143. }
  144. ],
  145. "style": "bold",
  146. "platform": "all",
  147. "content_type": "talking-head"
  148. }
  149. EOF
  150. ```
  151. ### Step 7: SNAP BOUNDARIES — Audio-Aware Cut Points
  152. Snap segment boundaries to natural audio cut points so clips never cut mid-word
  153. or mid-sentence:
  154. ```bash
  155. python3 "$SHORTS_ROOT/scripts/snap_boundaries.py" \
  156. --segments $SHORTS_TMP/approved_segments.json \
  157. --transcript $SHORTS_TMP/transcript.json \
  158. --input-video INPUT_FILE \
  159. --output $SHORTS_TMP/snapped_segments.json
  160. ```
  161. The script:
  162. 1. Loads word-level timestamps from the transcript
  163. 2. Snaps start times to the nearest word boundary (prefers sentence starts)
  164. 3. Extends end times to the next sentence boundary (. ? !) if within 3 seconds
  165. 4. Adds 300ms padding after the last word
  166. 5. Uses FFmpeg silencedetect to find natural pauses near cut points
  167. 6. Enforces min 5s / max 60s duration, clamps to video bounds
  168. Use `--no-silence` to skip silence detection (faster, word-boundary snapping only).
  169. Report to user: adjustment deltas per segment (e.g., "start +150ms, end +362ms").
  170. From this point forward, use `snapped_segments.json` instead of `approved_segments.json`.
  171. ### Step 8: PREPARE — Extract Clips + Compute Reframe
  172. Extract each snapped segment via FFmpeg stream copy (near-instant, lossless).
  173. Use the snapped start/end times from `$SHORTS_TMP/snapped_segments.json`:
  174. ```bash
  175. ffmpeg -y -ss START -to END -i INPUT_FILE -c copy \
  176. $SHORTS_TMP/clips/clip_01.mp4
  177. ```
  178. Compute reframe coordinates for each clip:
  179. ```bash
  180. python3 "$SHORTS_ROOT/scripts/compute_reframe.py" \
  181. --clips-dir $SHORTS_TMP/clips/ \
  182. --content-type CONTENT_TYPE \
  183. --output $SHORTS_TMP/reframe.json
  184. ```
  185. Report to user: clips extracted, content type per clip, reframe strategy.
  186. ### Step 9: RENDER via Remotion
  187. Render all snapped segments with the selected caption style:
  188. ```bash
  189. node "$SHORTS_ROOT/remotion/render.mjs" \
  190. --segments $SHORTS_TMP/snapped_segments.json \
  191. --reframe $SHORTS_TMP/reframe.json \
  192. --captions $SHORTS_TMP/transcript_cleaned.json \
  193. --style STYLE \
  194. --clips-dir $SHORTS_TMP/clips/ \
  195. --output-dir $SHORTS_TMP/render/
  196. ```
  197. The render script:
  198. 1. Bundles the Remotion project once (~5-10s)
  199. 2. Opens a shared Chrome instance
  200. 3. Renders each segment sequentially (~15-30s each)
  201. 4. Outputs 1080x1920 MP4 files
  202. Report progress to user as each segment renders.
  203. ### Step 10: EXPORT — Platform-Optimized Encoding
  204. Export rendered shorts with platform-specific encoding:
  205. ```bash
  206. bash "$SHORTS_ROOT/scripts/export.sh" \
  207. --input-dir $SHORTS_TMP/render/ \
  208. --platform PLATFORM \
  209. --output-dir ./shorts/
  210. ```
  211. Platform encoding specs:
  212. - **YouTube Shorts**: H.264 High 4.2, 12 Mbps, AAC 192k
  213. - **TikTok**: H.264, CRF 18, -preset slow, AAC 128k
  214. - **Instagram Reels**: H.264 High 4.2, 4.5 Mbps maxrate 5000k, AAC 128k
  215. - **All**: Exports all three variants per clip
  216. With NVENC GPU: `h264_nvenc -preset p5 -tune hq` for 5-10x faster encoding.
  217. Present final summary table:
  218. ```
  219. | # | File | Platform | Duration | Size |
  220. |---|---------------------------|-----------|----------|--------|
  221. | 1 | shorts/short_01_yt.mp4 | YouTube | 39s | 12.3MB |
  222. | 1 | shorts/short_01_tt.mp4 | TikTok | 39s | 8.7MB |
  223. | 1 | shorts/short_01_ig.mp4 | Instagram | 39s | 7.1MB |
  224. ```
  225. **Post-export validation:** Run validation on all exported files:
  226. ```bash
  227. bash "$SHORTS_ROOT/scripts/validate.sh" --output-dir ./shorts/
  228. ```
  229. Checks: file is playable, resolution is 1080x1920, audio track exists and isn't silent,
  230. file size is within platform limits, video codec is H.264, duration is 3-90 seconds.
  231. If any file fails, report the issues to the user. Failed files should be re-rendered
  232. or re-exported before delivery.
  233. ## Important Rules
  234. 1. **Always run preflight** before any processing
  235. 2. **Always present segments for approval** — never auto-render without user confirmation
  236. 3. **Always report costs** — Remotion rendering is free (local), only potential cost is GPU power
  237. 4. **Handle errors gracefully** — if any step fails, report the error and suggest fixes
  238. 5. **Clean up on success** — offer to delete $SHORTS_TMP/ after export
  239. 6. **Respect the user's choices** — if they say "re-analyze", go back to Step 4
  240. 7. **Stream copy for extraction** — never re-encode when cutting segments (use -c copy)
  241. 8. **One segment at a time** for progress reporting during render
  242. 9. **Load references** when needed — scoring-rubric.md for Step 4, caption-styles.md for style questions
  243. ## Caption Style Reference
  244. | Style | Font | Look | Best for |
  245. |-------|------|------|----------|
  246. | **bold** | Montserrat Bold | ALL CAPS, pop-in, yellow active word | Business, education, motivation |
  247. | **bounce** | Bangers | Bouncy scale, rotating bright colors | Entertainment, reactions, energy |
  248. | **clean** | Inter Bold | Minimal fade-in, white + shadow | Professional, calm, interviews |
  249. Load `references/caption-styles.md` for detailed visual specs and spring configs.
  250. ## Configurable Parameters
  251. These defaults work well for most content. Offer alternatives when the user has specific needs.
  252. | Parameter | Default | Flag/Var | When to change |
  253. |-----------|---------|----------|----------------|
  254. | Whisper model | `large-v3` | `--model small` | Low VRAM (< 6 GB) |
  255. | Screen zoom | `0.55` | `--zoom 0.4` | More context visible in screen recordings |
  256. | Cursor tracking | enabled | `--no-cursor-track` | Static screen content (slides, documents) |
  257. | Silence detection | enabled | `--no-silence` | Faster processing, word-boundary-only snapping |
  258. | Score threshold | 60 | (SKILL.md instruction) | Lower for longer videos with fewer highlights |
  259. | Segment duration | 15-55s | (SKILL.md instruction) | Adjust per platform (TikTok prefers 21-34s) |
  260. | Temp directory | `/tmp/claude-shorts/` | `SHORTS_TMP` env var | Systems with limited /tmp space |
  261. | Export platform | `all` | `--platform youtube` | Single-platform targeting |
  262. ## Error Recovery
  263. - **Transcription fails**: Check venv activation, try `--model small` for less VRAM
  264. - **Remotion render fails**: Check `cd remotion && npm install`, verify node_modules exists
  265. - **Export fails**: Check FFmpeg version (`ffmpeg -version`), try CPU encoding if NVENC fails
  266. - **Out of disk space**: Clean $SHORTS_TMP/, check with `df -h /tmp`
README.md · README · 238 lines

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

  1. # claude-shorts
  2. ![claude-shorts header](claude-shorts-header.jpeg)
  3. Interactive longform-to-shortform video creator powered by [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Extracts viral-ready vertical clips from long videos using Claude as the intelligent orchestrator with Remotion-rendered premium animated captions.
  4. ## How It Works
  5. Claude Code guides you through a 10-step interactive pipeline:
  6. 1. **Preflight** - Validates input video, checks disk space, detects GPU
  7. 2. **Transcribe** - GPU-accelerated transcription with word-level timestamps (faster-whisper)
  8. 3. **Detect Content** - Auto-classifies: talking-head, screen recording, or podcast
  9. 4. **Analyze** - Claude reads the full transcript and scores 8-12 candidate segments
  10. 5. **Present** - Shows candidates in a formatted table with scores, hooks, and rationale
  11. 6. **Approve** - You pick segments, adjust timecodes, choose caption style and platform
  12. 7. **Snap Boundaries** - Aligns cut points to word boundaries, sentence endings, and audio silences
  13. 8. **Prepare** - Extracts clips (FFmpeg stream copy) and computes reframe coordinates
  14. 9. **Render** - Remotion renders 1080x1920 vertical video with animated captions
  15. 10. **Export** - Platform-optimized encoding (YouTube Shorts, TikTok, Instagram Reels)
  16. ## Demo
  17. > Demo video/GIF coming soon — showing the full pipeline from input to rendered short with Bold-style captions.
  18. ## Features
  19. - **Claude-powered segment scoring** - 5-dimension rubric (hook strength, coherence, emotion, value density, payoff) with weighted scoring. No heuristic keyword matching - Claude understands narrative arcs.
  20. - **3 caption styles** - Bold (ALL CAPS, yellow highlights), Bounce (bouncy spring, rotating colors), Clean (minimal fade-in)
  21. - **Cursor tracking** - For screen recordings, detects mouse cursor via frame differencing and smoothly pans the crop to follow it
  22. - **Audio-aware boundary snapping** - Never cuts mid-word or mid-sentence. Extends to natural sentence endings and silence points.
  23. - **Remotion rendering** - React-based single-pass rendering with spring animations, word-level karaoke highlighting, hook text overlays, and progress bars
  24. - **GPU acceleration** - CUDA for transcription, NVENC for export encoding (falls back to CPU gracefully)
  25. ## Prerequisites
  26. - **FFmpeg** (system package)
  27. - **Python 3.10+**
  28. - **Node.js 18+**
  29. - **Claude Code** (CLI)
  30. - **NVIDIA GPU** recommended (for CUDA transcription + NVENC encoding)
  31. ## Installation
  32. ```bash
  33. # Clone the repository
  34. git clone https://github.com/AgriciDaniel/claude-shorts.git
  35. cd claude-shorts
  36. # Install Python + Node.js dependencies
  37. bash setup.sh
  38. # Install as a Claude Code skill
  39. bash install.sh
  40. ```
  41. ### Windows
  42. claude-shorts requires Unix tools (FFmpeg, bash). On Windows, use [WSL 2](https://learn.microsoft.com/en-us/windows/wsl/install):
  43. ```bash
  44. # Inside WSL
  45. git clone https://github.com/AgriciDaniel/claude-shorts.git
  46. cd claude-shorts
  47. bash setup.sh
  48. bash install.sh
  49. ```
  50. ### What `setup.sh` does
  51. - Creates a Python virtual environment at `~/.shorts-skill/` (or reuses `~/.video-skill/` if it exists)
  52. - Installs `faster-whisper`, `mediapipe`, `numpy`, `opencv-python`, and PyTorch (CUDA or CPU variant)
  53. - Runs `npm install` in the `remotion/` directory
  54. - Checks for system dependencies (FFmpeg, jq)
  55. ## Usage
  56. In Claude Code, invoke the skill:
  57. ```
  58. /shorts
  59. ```
  60. Then provide your video file when prompted. Claude will:
  61. 1. Transcribe the video
  62. 2. Present scored segment candidates
  63. 3. Ask which segments to render, caption style, and target platform
  64. 4. Render and export the final shorts
  65. ### Example Interaction
  66. ```
  67. You: /shorts ~/Videos/my-talk.mp4
  68. Claude: [Transcribes, detects content type, scores segments]
  69. | # | Time | Dur | Score | Hook |
  70. |---|---------------|------|-------|--------------------------------|
  71. | 1 | 04:22 - 05:01 | 39s | 87 | "Nobody talks about this..." |
  72. | 2 | 12:45 - 13:28 | 43s | 82 | "Here's the exact framework." |
  73. | 3 | 08:11 - 08:52 | 41s | 79 | "I tested this for 6 months." |
  74. Claude: Which segments? Caption style? Platform?
  75. You: 1 and 3, bounce style, youtube
  76. Claude: [Snaps boundaries, extracts clips, renders, exports]
  77. Output: shorts/short_01_yt.mp4, shorts/short_03_yt.mp4
  78. ```
  79. ## Project Structure
  80. ```
  81. claude-shorts/
  82. ├── SKILL.md # 10-step interactive pipeline (Claude Code skill)
  83. ├── CLAUDE.md # Project-level instructions
  84. ├── install.sh # Install to ~/.claude/skills/
  85. ├── setup.sh # Python + Node dependency installer
  86. │
  87. ├── scripts/
  88. │ ├── transcribe.py # faster-whisper GPU transcription
  89. │ ├── detect_content.py # MediaPipe content type classifier
  90. │ ├── compute_reframe.py # Face tracking + cursor tracking + crop
  91. │ ├── snap_boundaries.py # Audio-aware boundary snapping
  92. │ ├── preflight.sh # Input validation + disk space check
  93. │ ├── detect_gpu.sh # NVIDIA NVENC detection
  94. │ └── export.sh # Platform-specific FFmpeg encoding
  95. │
  96. ├── remotion/
  97. │ ├── package.json # Remotion v4 + React 19 + Zod
  98. │ ├── render.mjs # Bundle-once-render-many orchestrator
  99. │ ├── remotion.config.ts
  100. │ └── src/
  101. │ ├── Root.tsx # Composition registry
  102. │ ├── ShortVideo.tsx # Main composition
  103. │ ├── types.ts # Zod schemas for props
  104. │ ├── components/
  105. │ │ ├── VideoFrame.tsx # Reframed video with animated crop pan
  106. │ │ ├── Captions.tsx # Style dispatcher
  107. │ │ ├── BoldCaptions.tsx # Bold ALL CAPS, pop-in spring
  108. │ │ ├── BounceCaptions.tsx # Bouncy scale, bright colors
  109. │ │ ├── CleanCaptions.tsx # Minimal fade-in
  110. │ │ ├── HookOverlay.tsx # First 3.5s hook text
  111. │ │ └── ProgressBar.tsx # Bottom progress indicator
  112. │ ├── hooks/
  113. │ │ └── useCaptionPages.ts # @remotion/captions TikTok-style pages
  114. │ └── styles/
  115. │ ├── fonts.ts # @font-face declarations
  116. │ └── theme.ts # Color palettes per style
  117. │
  118. └── references/
  119. ├── scoring-rubric.md # 5-dimension scoring criteria
  120. ├── caption-styles.md # Visual specs + spring configs
  121. ├── platform-specs.md # YouTube/TikTok/Instagram encoding
  122. └── remotion-patterns.md # Remotion best practices
  123. ```
  124. ## Caption Styles
  125. | Style | Font | Animation | Best For |
  126. |-------|------|-----------|----------|
  127. | **Bold** | Montserrat Bold | Pop-in spring, yellow active word | Business, education |
  128. | **Bounce** | Bangers | Bouncy scale 70-120-100%, rotating colors | Entertainment, energy |
  129. | **Clean** | Inter Bold | Fade-in opacity, white + shadow | Professional, interviews |
  130. ## Platform Export Specs
  131. | Platform | Codec | Bitrate | Audio |
  132. |----------|-------|---------|-------|
  133. | **YouTube Shorts** | H.264 High 4.2 | 12 Mbps | AAC 192k |
  134. | **TikTok** | H.264 | CRF 18, -preset slow | AAC 128k |
  135. | **Instagram Reels** | H.264 High 4.2 | 4.5 Mbps (max 5000k) | AAC 128k |
  136. ## Content Type Strategies
  137. | Content Type | Reframe Strategy | Zoom |
  138. |--------------|-----------------|------|
  139. | **Talking-head** | Face-tracked center crop (MediaPipe) | 9:16 exact |
  140. | **Screen recording** | Cursor-tracked pan with moderate zoom | 55% of source width |
  141. | **Podcast** | Dominant speaker tracking | 9:16 exact |
  142. ## Dependencies
  143. ### Python (installed via `setup.sh`)
  144. - [faster-whisper](https://github.com/SYSTRAN/faster-whisper) - GPU-accelerated Whisper
  145. - [mediapipe](https://mediapipe.dev/) - Face detection for content classification + reframing
  146. - [numpy](https://numpy.org/) - Array operations for cursor tracking smoothing
  147. - [opencv-python](https://opencv.org/) - Frame differencing for cursor detection
  148. ### Node.js (installed via `setup.sh`)
  149. - [Remotion v4](https://remotion.dev/) - React-based video rendering
  150. - [@remotion/captions](https://remotion.dev/docs/captions) - TikTok-style word-level captions
  151. - [React 19](https://react.dev/) - Component framework
  152. - [Zod](https://zod.dev/) - Runtime type validation for props
  153. ### Fonts
  154. Caption fonts are bundled from Google Fonts under the [SIL Open Font License](remotion/public/fonts/OFL.txt):
  155. - Montserrat Bold (Bold style)
  156. - Bangers Regular (Bounce style)
  157. - Inter Bold (Clean style)
  158. ### System
  159. - [FFmpeg](https://ffmpeg.org/) - Audio extraction, segment cutting, export encoding
  160. - [jq](https://jqlang.github.io/jq/) - JSON processing in shell scripts
  161. ## How Segment Scoring Works
  162. Claude scores each candidate on 5 weighted dimensions:
  163. | Dimension | Weight | What Claude Looks For |
  164. |-----------|--------|----------------------|
  165. | Hook Strength | 0.30 | Bold claims, curiosity gaps, value promises, pattern interrupts |
  166. | Standalone Coherence | 0.25 | Makes complete sense without any context from the rest of the video |
  167. | Emotional Intensity | 0.20 | Strong opinions, surprise reveals, humor, passion |
  168. | Value Density | 0.15 | Actionable insights, data points, frameworks per second |
  169. | Payoff Quality | 0.10 | Satisfying conclusion - punchline, reveal, call-to-action |
  170. Final score = weighted sum, scale 0-100. Minimum threshold: 60.
  171. ## Support
  172. - **Issues**: [GitHub Issues](https://github.com/AgriciDaniel/claude-shorts/issues)
  173. - **Discussions**: [GitHub Discussions](https://github.com/AgriciDaniel/claude-shorts/discussions)
  174. ## License
  175. [MIT](LICENSE)
  176. ---
  177. ## Author
  178. Built by [Agrici Daniel](https://agricidaniel.com/about) - AI Workflow Architect.
  179. - [Blog](https://agricidaniel.com/blog) - Deep dives on AI marketing automation
  180. - [AI Marketing Hub](https://www.skool.com/ai-marketing-hub) - Free community, 2,800+ members
  181. - [YouTube](https://www.youtube.com/@AgriciDaniel) - Tutorials and demos
  182. - [All open-source tools](https://github.com/AgriciDaniel)

Ratings and comments

Sign in to rate this skill.

Sign in

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