Skip to content
Skills Library
Marketing & content · Testing

verify

/verify

Drive the `splice` video-editing CLI to prove behavior on this repo — build the binary, create an isolated scratch project, and capture JSON, ffprobe facts, frame stills and pixel-diff evidence. Use when verifying a change to splice, reproducing a render or cache bug, or proving a timeline/caption/overlay feature works end to end.

Repository
splice-cli ↗
Licence
MIT
Last repository change
13.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
19
Scripts
3
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 3 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/facts.sh, scripts/make-media.sh, scripts/psnr-ab.sh

What it does and when to use it

Drive the `splice` video-editing CLI to prove behavior on this repo — build the binary, create an isolated scratch project, and capture JSON, ffprobe facts, frame stills and pixel-diff evidence. Use when verifying a change to splice, reproducing a render or cache bug, or proving a timeline/caption/overlay feature works end to end.

Original author description

Drive the `splice` video-editing CLI to prove behavior on this repo — build the binary, create an isolated scratch project, and capture JSON, ffprobe facts, frame stills and pixel-diff evidence. Use when verifying a change to splice, reproducing a render or cache bug, or proving a timeline/caption/overlay feature works end to end.

How it works

  1. Launch
  2. Doctor
  3. Drive
  4. Evidence
  5. Cleanup
  6. Gotchas
  7. Helpers
Original SKILL.md headings · 183 lines, 1,031 words
SKILL.md preview
---
name: verify
description: Drive the `splice` video-editing CLI to prove behavior on this repo — build the binary, create an isolated scratch project, and capture JSON, ffprobe facts, frame stills and pixel-diff evidence. Use when verifying a change to splice, reproducing a render or cache bug, or proving a timeline/caption/overlay feature works end to end.
---

# Verify `splice`

`splice` is a Rust CLI (binary at `target/debug/splice`) that compiles a `splice.json`
project into ffmpeg calls. Everything it prints on stdout is one JSON object.
There is no UI and no server: *driving* it means running commands in a scratch
directory and reading files, exit codes and pixels.

## Launch

There is nothing to keep alive. Launch = build once, then create a fresh
scratch project per drive.

```bash
cd <repo-root>
cargo build                       # ~10s cold, <1s warm
SPLICE="$PWD/target/debug/splice"

SCRATCH=$(mktemp -d /tmp/splice-verify.XXXXXX)
.agents/skills/verify/scripts/make-media.sh "$SCRATCH"
cd "$SCRATCH"
$SPLICE init --size 1280x720 --fps 30
```

Ready when this prints `"ok":true`:

```bash
$SPLICE doctor
```

Ready means more than "the binary exists": `doctor` must report
`"libx264":true`, `"libass":true`, `"drawtext":true` and a non-empty
`ffmpeg` version string. If any is false, stop — renders will fail on a filter,
not on your change.

Each drive gets its own `$SCRATCH`. Two drives never share a `splice.json` or a
`.splice/` cache, so they can run side by side. Never drive in the repo root: `splice`
writes `splice.json`, `.splice/cache/` and `out.mp4` into the current directory.

## Doctor

```bash
$SPLICE doctor                       # ffmpeg filters/encoders, resolved font, keys
ffprobe -v error -show_entries format=duration -of csv=p=0 "$SCRATCH/clip-a.mp4"
```

Run `doctor` first whenever anything looks off. It answers: is ffmpeg capable,
is a font resolvable, are ASR keys present. It never prints a secret value.

## Drive

Every command prints exactly one JSON object to stdout. Read it, do not grep
logs. `jq` is available.

```bash
cd "$SCRATCH"

# timeline
$SPLICE add ./clip-a.mp4 --from 1s --to 6s      # --from/--to are SOURCE times
$SPLICE add ./clip-b.mp4 --speed 1.5
$SPLICE list                                     # {clips:[...],duration:"00:00:08.333"}
$SPLICE trim clip_2 --to 4s
$SPLICE move clip_2 0
$SPLICE rm clip_2
$SPLICE inspect                                  # summary + "warnings"

# layers
$SPLICE text "Ship faster" --from 0.5 --to 3 --pos bottom --size 48
$SPLICE audio ./music.mp3 --gain -14             # negative needs no `--`
$SPLICE caption ./subs.srt                       # {changed:["captions"],cues:2}

# compile and render
$SPLICE plan | jq '.steps[] | {label, cached, argv: .argv[0:6]}'
$SPLICE render -o out.mp4
# {"steps":{"total":4,"ran":4,"reused":0}} on a cold render

# look at the result
$SPLICE frames --at 1,3 --sheet 8 -o .splice/preview
```

Stable handles: command names and the JSON keys (`steps.ran`,
`steps.reused`, `duration`, `warnings[].code`). Do not parse the `argv`
strings for content — use `cached` and `warnings`.

Exit codes are the contract: `0` ok, `2` project/precondition, `3` media, `4`
ffmpeg, `5` usage.

## Evidence

Write proofs to `<repo-root>/verification/<YYYY-MM-DD>-<what>/`. That directory
is outside `$SCRATCH` on purpose: cleanup deletes the scratch dir, never the
evidence.

Capture, per proof:

1. **Command + JSON** — `cmd.txt` with the exact commands, `out.json` with stdout.
2. **Timeline facts** — `scripts/facts.sh out.mp4` (duration, codecs, size, fps).
3. **Pixels** — the stills from `splice frames`, or a crop diff for a specific claim.
4. **Side effects** — `ls .splice/cache` counts, `steps.ran`/`steps.reused`, exit code.

Prove the user path, not an internal one. `splice render` exiting 0 is not proof the
overlay appeared: prove it in pixels.

**Pixel proof for anything layered (text, captions):** render the same project
twice, once with the layer and once without, changing nothing else, then diff
the same timestamp and the same crop. Identical background, so the number is
the layer.

```bash
.agents/skills/verify/scripts/psnr-ab.sh out.mp4 out-bare.mp4 1.5 "1280:120:0:520"
# -> average:15.897  (a burned caption lives here; ~40+ dB means nothing changed)
```

**Audio proof for a music bed:** the residual, not the mean.

```bash
ffmpeg -hide_banner -i out-full.mp4 -i out-bare.mp4 -filter_complex \
 "[0:a][1:a]amix=inputs=2:weights=1 -1:normalize=0,astats=measure_overall=RMS_level:measure_perchannel=none" \
 -f null - 2>&1 | grep 'RMS level'
# -18.4 dB residual means the bed is in the mix; near -inf means it is not
```

**Cache proof:** `steps.reused` is the claim. A cold render reports
`ran == total`; an unchanged re-render reports `reused == total`; a one-field
edit reports `ran == 1` (decorate only) or `ran == 3` (one clip changed:
normalize + concat + decorate).

## Cleanup

```bash
rm -rf "$SCRATCH"        # only what this drive created
```

Never kill by process name and never `rm -rf` a path you did not create. `splice`
leaves no processes behind. Confirm the evidence survived:

```bash
ls <repo-root>/verification/<date>-<what>/
```

## Gotchas

- **`ran: 0` after you changed something is a bug, not a win.** The cache key
  must move when the argv moves. If you edited an overlay or a caption style and
  the render reported `reused: total`, the step's key is not covering its own
  filters — report it, do not accept the fast path.
- **A failed ffmpeg step used to leave a zero-byte cache file that the next run
  trusted.** If a render "succeeds" in 0 steps and the output is 0 bytes or
  silent, check `ls -la .splice/cache` before blaming the encoder.
- **`--from`/`--to` on `add` are positions inside the source file**, not on the
  timeline. `--to 6s` on a 6s clip plus `--from 1s` yields 5s of output.
- **`--to` past the end of the media is clamped**, with a `clip_past_media`
  warning. Mutating commands return their own warnings, so read them there.
- **A source inside the project directory is stored relative to it**; one
  outside is stored absolute. Paths are read back against the project
  directory, so `--project /elsewhere/splice.json` works from any cwd even
  after the directory moves.
- **Paths inside filters must be relative** (`src/paths.rs`). A `C:\` path
  unescaped becomes "No such filter", not a missing-file error. `cargo test`
  covers this; do not bypass `filter_escape`.
- **Text needs a font.** `doctor` prints the resolved `font`; a null there makes
  every `drawtext` fail with `no_font`.
- **The 10-minute ASR cap sits below the 30-minute hard refusal**, so a long
  file hits `asr_over_limit` (confirmable with `--yes`) before `asr_too_long`.
- **`splice frames` renders from the last plan step's cache**, so it needs a render
  first: `nothing rendered yet (run 'splice render')` is expected on a fresh project.

## Helpers

Both scripts are executable and take an explicit target directory.

```bash
.agents/skills/verify/scripts/make-media.sh "$SCRATCH"   # deterministic fixtures
.agents/skills/verify/scripts/facts.sh out.mp4           # ffprobe facts as JSON
.agents/skills/verify/scripts/psnr-ab.sh a.mp4 b.mp4 1.5 "1280:120:0:520"
```

`make-media.sh` writes `clip-a.mp4` (6s, 640x360@30, 440Hz), `clip-b.mp4` (5s,
1280x720@25, 660Hz), `subs.srt` (2 cues) and `music.mp3` (8s sine bed). All
generated by ffmpeg, so no binaries need to live in the repo.

See `features/README.md` for the feature map.
Files in this package (19)
  • SKILL.md 7 KB
  • features/README.md 2 KB
  • features/audio-bed.md 3 KB
  • features/captions.md 1 KB
  • features/compositing.md 3 KB
  • features/config.md 2 KB
  • features/cut.md 2 KB
  • features/history.md 2 KB
  • features/index.md 3 KB
  • features/overlays.md 2 KB
  • features/render-cache.md 3 KB
  • features/review-frames.md 1 KB
  • features/scenes.md 2 KB
  • features/timeline.md 3 KB
  • features/transcribe.md 3 KB
  • features/transitions.md 2 KB
  • scripts/facts.sh 1 KB
  • scripts/make-media.sh 1 KB
  • scripts/psnr-ab.sh 1 KB

Versions

RepositoryScoreLicence
This page · matthew-eth724/splice-cli100MIT
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
NolwennD/gabier100Apache-2.0
ericrisco/rsc-harness100MIT
sentimony/agentic-workflow100MIT
JoDi-27/JoDi-SDD100MIT
marcel-bich/marcel-bich-claude-marketplace100MIT
kdlbs/kandev100AGPL-3.0

Database snapshot: 13.11.2026 · package version f4941f2be884 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100splice
    Drive the `splice` video-editing CLI (init, cut, caption, composite, grade, render) through its one-JSON-object-per-command contract. Use when a task involves editing, retiming, captioning or rendering video on a machine where `splice` is installed, or when deciding between splice and raw ffmpeg.
  • 100frame-inspect
    動画・画像のフレーム抽出、Remotion レンダリング、仕様チェック、目視検証を行う汎用ビデオツールキット。 ffmpeg / ffprobe / remotion still / remotion render を統一シェルスクリプト (video-tool.sh) で操作し、 Read ツール(マルチモーダル対応)で実際の見た目を確認して品質レポートを出す。 Use when: 動画のフレームを確認したい、レンダリング結果を検証したい、 画像の品質を目視チェックしたい、Remotion プロジェクトを MP4 に出力したい、…
  • 100verify-apex-memory
    Drive apex-memory the way an agent does (the MCP stdio server, the apex-memory CLI, on SQLite and on Postgres) and capture evidence that a change works. Use it to prove a store, tool, refusal, CLI or upgrade change end to end, before you call it done, or when asked to "verify",…
  • 100verify-pr-fix
    Manually verify that a bug-fix PR actually works by reproducing the failure before the fix and confirming it is gone after, with captured evidence, then posting findings to the PR (and optionally the linked issue). Use when asked to manually verify a PR/fix, reproduce an issue…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.