Skip to main content
skill CX Codex

reverse-engineer-video — Claude Code skill for video analysis

The reverse-engineer-video Claude Code skill breaks down a reference clip into shots, camera moves and editing beats. Invoke it to inspect a cut, plan a remake or compare one with the original.

MIT ★ 541 updated 2026-11-09

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add dotslashsimran/simcraft --skill reverse-engineer-video -a claude-code
Open on GitHub

What reverse-engineer-video does

The skill marks cuts and dissolves, measures shot lengths and pacing, identifies camera movement, and checks whether edits align with beats or loudness changes. It creates a contact sheet, a timeline strip, breakdown.md with a beat map and remake plan, and breakdown.json. On-screen text and speech are read when the relevant tools are installed.

The scripts run with python3 and require numpy. Running sh setup.sh adds OpenCV for tracking fast movement; sh setup.sh --whisper adds speech recognition, while text reading needs tesseract on PATH. Comparison scripts can produce stills or videos with the clips side by side, stacked, or blended. Analysis and comparison scripts are in scripts/; save analysis output outside the reference clip’s folder.

What it helps with

  • mark cuts and measure shot lengths
  • identify camera moves and musical accents
  • draft a remake plan from a reference clip
  • compare a remake with the original at matching timestamps

Example prompts for the agent

  • Break down this clip and draft a remake plan.
  • Identify the camera moves and check whether the cuts land on musical beats.
  • Compare my remake with the original and show the differences.

How to install reverse-engineer-video

1Skills CLI (Vercel)

npx skills add dotslashsimran/simcraft --skill reverse-engineer-video -a claude-code

2Manually: put the files in place

~/.claude/skills/reverse-engineer-video/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/reverse-engineer-video/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about reverse-engineer-video

How do I install reverse-engineer-video in Claude Code?

Run npx skills add dotslashsimran/simcraft --skill reverse-engineer-video -a claude-code. The skill file is installed at ~/.claude/skills/reverse-engineer-video/SKILL.md.

What does reverse-engineer-video do?

It maps shots, pacing and camera movement, then prepares a beat map and remake plan. It can also compare a remake with its reference as stills or video.

What does reverse-engineer-video need to run?

It requires python3 and numpy. OpenCV supports tracking fast moves; speech recognition is added with sh setup.sh --whisper, and reading on-screen text requires tesseract on PATH.

Source text

SKILL.md · MIT
---
name: reverse-engineer-video
description: Break down a reference or viral video clip so it can be remade. Finds every cut and dissolve, times each shot, measures pacing, works out the camera move in each shot (static, pan, tilt, zoom or push in, roll, handheld shake, with speed), finds beats and loudness jumps and checks whether the cuts land on them, and reads on-screen text and speech when the tools are installed. Makes a contact sheet, a timeline strip, breakdown.md with a beat map and a remake plan, and breakdown.json. Also makes side-by-side or stacked comparison videos of a remake against the reference. Use when the user says "break down this video", "reverse engineer this clip", "how was this edited", "shot list from this video", "why does this go viral", "recreate/remake this video", "what camera moves are in this", "do the cuts hit the beat", or "compare my remake with the original".
---

# Reverse engineer a video

Scripts live in `scripts/`. They run on `python3` with numpy. For better tracking of very fast moves, run `sh setup.sh` once and use `.venv/bin/python` instead (it adds OpenCV; `sh setup.sh --whisper` also adds speech-to-text). On-screen text needs `tesseract` on the PATH. Every optional part is skipped cleanly when its tool is missing, and the report says so.

## Steps

1. **Analyse.** Write the output somewhere other than the video's own folder:
   ```
   python3 scripts/analyze.py <clip> -o <out_dir>
   ```
   It writes `breakdown.md`, `breakdown.json`, `contact_sheet.jpg`, `shots_detail.jpg` and `timeline.png`.

2. **Check the cuts before trusting anything else.** Open `timeline.png` and `contact_sheet.jpg`. If two shots in the sheet look like the same shot, a cut was false: run again with `--sensitivity 0.7`. If a sheet frame shows two shots blended or a shot changes inside one tile, a cut was missed: use `--sensitivity 1.4`. Fast flashes shorter than `--min-shot` (0.1 s) are listed as flash frames, not shots.

3. **Look, then fill in the gaps.** Read `shots_detail.jpg` (start, middle and end frame of each shot, with the measured numbers). Then edit `breakdown.md`:
   - fill the "what happens" column of the beat map, one short line per shot,
   - write the hook read (see below),
   - write the remake plan. Use the measured times and camera numbers; do not round them into guesses.

4. **Remake, then compare at the same timestamps.** You cannot watch video, so compare stills first:
   ```
   python3 scripts/compare.py <ref> <remake> --stills compare.jpg --breakdown <out_dir>/breakdown.json
   ```
   Fix the biggest difference, repeat. When it is close, make a video for the user:
   ```
   python3 scripts/compare.py <ref> <remake> -o compare.mp4 --mode side     # or stack for vertical posts
   python3 scripts/compare.py <ref> <remake> -o overlay.mp4 --mode blend    # lines up horizons and edges
   ```
   Use `--ref-start` / `--remake-start` if one clip has a lead-in. A shorter remake holds its last frame, or repeats with `--loop-remake`. Output is always re-encoded.

## Reading the hook (first 2 seconds)

The "Hook" section lists measured facts: when the first cut comes, how many cuts fall in the first 2 s, whether sound starts at frame one, the first words and text, and how busy the opening is compared to the rest (`motion first 2s vs rest`, above 1 means busier). Use them to answer three questions in plain words:
- **What is the promise in frame one?** A strong first frame shows the payoff or a clear question (a finished result, something odd, a face mid-sentence). An establishing wide shot or a logo is a weak start.
- **What changes before 0.5 s?** A cut, a move starting, a sound hit or text appearing. If nothing changes, say so: viewers decide in this window.
- **Why stay to 2 s?** Usually an open loop: text or speech that asks a question, or a move that has not finished.

## Camera numbers, and rebuilding a shot in 3D

Each shot gets a label (static, pan, truck/arc, tilt, zoom in/out, push in/pull out, roll, handheld). Long shots with several moves are split into phases, such as `push in > tilt up`. Each label comes with numbers: pan speed in % of frame width per second, tilt in % of frame height per second, total zoom factor, shake in % of frame width, and parallax. Directions describe the camera, not the picture. "Zoom" means the picture scaled with no parallax (a lens zoom, a digital scale, or a very far scene). "Push in" means there was parallax, so the camera really moved. `breakdown.json` has a camera path per shot (pan, tilt and zoom over time) to use as keyframes.

To rebuild a scene in three.js or a 3D tool, measure the geometry on a sharp frame from `shots_detail.jpg`:
- **Horizon height** (where the vanishing points sit) tells you camera pitch: a horizon on the frame's centre line means a level camera; above centre means it tilts down.
- **Lens**: take two vanishing points of lines that are at right angles in the real world. The focal length in pixels is `sqrt(-(v1 - c)·(v2 - c))`, where c is the frame centre. Vertical field of view is `2·atan(H / 2f)`.
- **Camera height**: if the horizon crosses a person standing on the same floor at their eye line, the camera is at eye height (about 1.6 m). Where it crosses them gives the ratio.
The full method, with worked numbers, is in [reference.md](reference.md).

## Rules

- Never write into the reference video's folder, and never change the reference file.
- Trust measured times over what you think you see. Quote cut times from `breakdown.json`.
- Say clearly which parts were skipped (no transcript, no text reading) instead of guessing them.
- In the beat map, "on beat" means within the tolerance shown (default 1.5 frames, at least 50 ms). Always quote the chance rate next to the hit rate: 60% of cuts on onsets means little if random cuts would score 50%.

How each measurement works, the limits, the test results and all options: [reference.md](reference.md).

© dotslashsimran · MIT · dotslashsimran/simcraft

Similar skills

SKILL.md skills catalog →
reverse-engineer-anything morluto The reverse-engineer-anything skill for Claude Code and other platforms analyzes compiled binaries, packages, and proprietary code. It extracts data from executables or archives for decompilation and version comparison. CX Codex +1 18,800installs reverse-engineer-marketing coreyhaines31 reverse-engineer-marketing — a skill for Claude Code builds a growth timeline of competitors using public data and archives. Runs when you need to study another company's strategy and compare metrics. CX Codex +1 8,600installs reverse-any-video heygen-com reverse-any-video — a Claude Code skill that rebuilds any video file into an editable HyperFrames project checked frame by frame against the original. CX Codex +1 180,600installs reverse-api-engineer kalil0321 reverse-api-engineer — a skill for Claude Code that turns a website's private HTTP traffic into a typed API client in Python, TypeScript, Go, and other languages. Runs on every pull request or during manual API discovery tasks. CX Codex +1 1,400installs reverse-engineer sickn33 Structured reverse engineering workflow for binaries: static decompilation, dynamic tracing, pattern detection, and automation scripts. CX Codex +1 935installs reverse-engineer-anything-self-learning-loop Speedrun AI Labs reverse-engineer-anything-self-learning-loop is a Claude Code skill that builds clean equivalents of authorized software. It verifies parity with evidence and stores lessons across iterations. CX Codex +1 ★ 151repo stars

From the same set24

The whole set →
security-threat-model The security-threat-model Claude Code skill maps threats from an app’s code and tests the highest risks locally. It activates for requests about STRIDE, app security reviews, or vulnerabilities before launch. CX Codex +1 ★ 541repo stars vox-explainer The vox-explainer Claude Code skill makes Vox-style explainer graphics or a faceless video. It runs on requests for voiceover-led visuals, animated quotes, or stats. CX Codex +1 ★ 541repo stars benchmark-honestly The benchmark-honestly Claude Code skill checks performance measurements and compares code versions. It activates for benchmark requests, load tests, latency percentiles, or claims that a change made code faster. CX Codex +1 ★ 541repo stars flaky-test-killer The flaky-test-killer Claude Code skill tracks down flaky-test causes and helps fix them at the root. It stresses the test and compares failure rates before and after the change. CX Codex +1 ★ 541repo stars system-design-from-scratch system-design-from-scratch — a skill for Claude Code that builds minimal distributed architectures, verifies invariants under simulated node failures, and stress-tests them with real metrics. CX Codex +1 ★ 541repo stars paper-to-runnable The paper-to-runnable Claude Code skill turns a research paper into a minimal implementation of its central idea. It activates for requests to build or reproduce a paper, including from an arXiv link or local PDF. CX Codex +1 ★ 541repo stars codebase-map The codebase-map Claude Code skill maps an unfamiliar repository and traces a real request through it. Ask it to explain the project structure, locate a code path, or onboard a new teammate. CX Codex +1 ★ 541repo stars api-design-review api-design-review — a skill for Claude Code reviews HTTP APIs, SDKs, and CLIs. It runs when asked to assess an API design, inspect a spec, or judge whether a change is safe to ship. CX Codex +1 ★ 541repo stars

Project sponsors

Companies that keep this analytics open