Motion blur, beat sync and sound design for videos made with Claude

Most videos made with Claude look finished with the sound off. Turn the sound on and the illusion breaks: the click lands after the button, the cut misses the beat, the music ends a second after the logo. And even with the sound off, fast moves look stuttery and digital, because a browser screenshot is a perfectly sharp instant and real film never is.

This tutorial is about the two finishing crafts that fix that: motion blur and sound. They are where several creators who published their methods say they spent the most time, and where the difference between a demo and something that feels like film is largest.

Why code-drawn frames look stuttery

A camera shutter is open for a fraction of each frame, so anything moving smears a little along its path. A frame captured from seek(t) is an instant: a fast object is crisp in one place in one frame and crisp somewhere else in the next. At 30 or 60 frames per second that reads as strobing. The fix is to do what a shutter does: sample several instants inside each frame and average them.

Subframe motion blur

Render N subframes per output frame, spread across the time the shutter would be open, and blend them. Because the film is a pure function of time, a subframe is just seek(t) at a fractional time. Raphael Aubry renders eight subframes per output frame, blends them with ffmpeg's tmix filter and keeps one in eight. His open-source skill describes the blend as a 180 degree shutter, which means sampling only the first half of each frame interval, the convention that matches most filmed footage.

Render subframes, blend with ffmpeg

// N subframes inside the first half of each frame (180 degree shutter)
const fps = 60, N = 8, shutter = 0.5;
for (let f = 0; f < fps * dur; f++) {
  for (let k = 0; k < N; k++) {
    const t = (f + (k / N) * shutter) / fps;
    await page.evaluate((x) => window.seek(x), t);
    await page.screenshot({ path: `sub/s_${String(f * N + k).padStart(6, "0")}.jpg` });
  }
}
// then:
// ffmpeg -framerate 480 -i sub/s_%06d.jpg \
//   -vf "tmix=frames=8,select='eq(mod(n\,8)\,7)',setpts=N/60/TB" \
//   -r 60 -c:v libx264 -crf 14 -pix_fmt yuv420p out/film.mp4

How many subframes

The creators who tested it agree on the failure mode: too few subframes on a fast move leaves ghost copies instead of a smooth smear. zero (@twoclipping) found that four subframes ghost on fast moves and recommends eight, and slowing the move down if it still ghosts. Raphael Aubry learned the same on his first launch film. Finn's space explainer uses only two subframes with a 0.6 shutter at 30 fps, which is fine for a film whose moves are slow and floaty.

So match it to the motion. Slow drifts and gentle camera moves: two to four. Snappy UI, slams and whip moves: eight. And blur is not free: Raphael Aubry measured about one to one and a half minutes of rendering per second of film at eight subframes. Render drafts with none, and turn blur on for the master only.

• Keep text readable: blur should happen during movement and be gone by the reading hold. beamnxw suggests limiting blur to the entrance and checking that the hold is clean.
• Check strips, not stills: twelve consecutive frames around the fastest move show whether the smear is smooth.
• Avoid compositor hints such as will-change on things the camera scales; zero notes they make text render blurry in a different, ugly way.

Pick the clock: voice or music

Before syncing anything, decide what drives time. In a narrated explainer the voice is the clock: visual events fire on words, and music sits underneath. In a product film or lyric video the music is the clock: changes land on beats, and the voice, if any, fits the grid. Everything below works for both, but you must know which one wins when they disagree.

A practical rule for mixed pieces: let the voice decide which words appear and when, and let the beat grid decide only where hard cuts and big transitions go. If a cut falls a few frames from a beat, move the cut to the beat; if a word falls a few frames from a beat, leave the word where it is spoken. Viewers forgive a cut on the beat far more readily than a word that appears before it is said.

Measure the music, then distrust the downbeat

Have Claude analyse the track with Python before any animation: tempo, beats, downbeats, and the drop. Then check the drop separately. Raphael Aubry's beat tracker put the bar two beats off on one track, so the drop landed on nothing. His fix is to find the drop by energy: measure the bass band over time, find the jump, then refine in 20 millisecond windows. Start the song at the drop time in the track minus the drop time in the film, so the key visual moment lands on it.

Jeff Guo's lyric video method adds a simple human step: tell Claude where the important drops are by ear, and let it use librosa to confirm the tempo and the energy at those points. You know the song; use that.

Refine the drop in 20 ms windows

import numpy as np, librosa, scipy.signal as sg
y, sr = librosa.load("track.wav", sr=48000, mono=True)
b, a = sg.butter(4, 150 / (sr / 2), "low"); low = sg.filtfilt(b, a, y)
rough = 31.5                                   # from the bar-level scan
for t in np.arange(rough - 0.3, rough + 0.3, 0.02):
    seg = low[int(t * sr): int((t + 0.02) * sr)]
    print(f"{t:6.2f}  {10 * np.log10((seg ** 2).mean() + 1e-12):6.1f} dB")
# the jump in dB is the drop

Place every sound effect by its peak

A sound effect file rarely starts with its loudest moment. A whoosh builds, a click has a few milliseconds of silence, a crunch has a lead-in. If you place files by their start, every effect lands late by a different amount. Measure each file's peak and offset it so the peak lands on the frame of the action. Raphael Aubry, twoclipping and Dumble's 2.5D course all describe exactly this, and it is the cheapest big improvement in this whole post.

Peak-aligned mixing

def place(mix, sfx, t, gain, sr=48000):
    s = sfx / np.abs(sfx).max() * gain
    peak = int(np.abs(s).sum(axis=1).argmax())     # loudest sample
    start = int(t * sr) - peak                     # peak lands on t
    mix[max(0, start): start + len(s)] += s[max(0, -start):]
    return mix

for cue in cues:          # [{"t": 6.5, "file": "click.wav", "db": -14}, ...]
    mix = place(mix, load(cue["file"]), cue["t"], 10 ** (cue["db"] / 20))

Write the cue list next to the picture events, in the same numbers. If the picture timeline is in frames, the cue list should be in frames too: press at frame 195, reveal hit at 210, music settles at 438.

Real sounds beat synthesised beeps

zero is blunt about this: he let Claude make its own effects at first and they "sounded so cheap", so he switched to downloaded effects from a free library. Finn's prompts insist on downloaded effects, "never synthesized", for the same reason. Raphael Aubry's baguette launch film used four real crunch recordings cut from one file, and that was the detail people commented on.

Synthesised music is a different story. Several creators had Claude compose and synthesise whole scores in code on a BPM grid, which avoids licensing and keeps the music on the same clock as the picture. If you go that route, make the score as deliberate as the picture: named chords, a structure that builds, and an ending that resolves on the final frame.

Voice: word times you can trust

For narrated pieces, every caption and many visual events hang off word times. Two lessons from the published methods. First, if you generate narration as one long take, do not cut it at the character timestamps the TTS service returns, because, as Finn found, they drift and slice words; transcribe the take with faster-whisper to get real word times and cut only in real silences. Second, when you already have the text (a script or lyrics), align rather than transcribe: Jeff Guo used stable-whisper with the lyrics provided, which is far more accurate than free transcription.

Then check the joints: every caption should have voice under it within about a tenth of a second, and no word should be clipped at a cut.

Mixing levels that work on phones

Two-pass loudness normalisation

# pass 1: measure
ffmpeg -i mix.wav -af loudnorm=I=-14:TP=-1:LRA=11:print_format=json -f null -
# pass 2: apply the measured values
ffmpeg -i mix.wav -af "loudnorm=I=-14:TP=-1:LRA=11:measured_I=...:measured_TP=...:measured_LRA=...:measured_thresh=...:offset=...:linear=true" mix_norm.wav

• Voice on top, always. Music beds sit well under it: published prompts use roughly 7 dB under for a calm explainer and 12 to 14 dB under for a tense one.
• Effects between the two, a few dB under the voice, louder for the one big moment.
• A dip in the music just before the reveal makes the reveal land.
• Match the music's ending to the last frame, or let it resolve on the title.
• Normalise to about -14 LUFS integrated with the true peak under -1 dB; Raphael Aubry uses two-pass loudnorm, and platforms normalise to roughly that level anyway.
• Listen on a phone speaker and on headphones. Bass that sounds great on monitors disappears on a phone.

The listening check

Close your eyes and listen to the whole film. seeco calls it the blindfold test: if the audio has no shape without the picture, the sound design is not finished. Then do the opposite: watch with the sound off and check that nothing important depends on audio alone, since many viewers start muted.

If you want Claude to do some of the listening, Dumble's 2.5D course recommends earshot, an open-source tool that lets an agent listen to and review its own mix, with checks like: is the voice always on top, is any whoosh repeated more than twice, does the music resolve on the final frame.

Pitfalls

• Four subframes on fast moves: ghosting.
• Blur on every frame of a reading hold: unreadable text.
• Trusting automatic downbeats: drops that land on nothing.
• Placing effects by file start: everything a little late.
• Synthesised effects that sound like a test tone.
• Cutting TTS at its own character timestamps: sliced words.
• A whoosh on every cut.
• Mixing on studio monitors only.

Cost and time

Everything here is free software: ffmpeg, Python with numpy, scipy and librosa, faster-whisper, and free sound libraries. The cost is render time for subframes (budget a minute or more per second of film at eight subframes) and the time to build a cue list. Once the scripts exist, they carry over to every film, which is why creators who kept one project per brand report later videos coming together much faster.

Doing it in about 3 minutes with WhatToUpload Video Studio

Video Studio does the timing work for you: you type one sentence, Claude writes the script and storyboard, ElevenLabs voices it, and our renderer draws every frame as code with captions, music and sound timed to the voice. A video takes about three minutes. The styles live today are Kinetic type, Ink stickman and Diagram explainer, with more being added.

A 30 second video is 26 to 30 credits, and plans are $19, $49 and $99 a month.