A Meme Is a Spec: Breaking a 14-Second 9:16 Video Into Beats, Timecodes, and a Posting Checklist

Thomas Chan — Sat, 31 Oct 2026 03:46:50 +0000

When I started building a small generator for a TikTok meme format, I thought the hard part would be the model. It wasn't. The hard part was working out what the meme actually is, precisely enough that a pipeline could reproduce it every time.

Meme formats look like vibes, but they behave like specs. Drop a beat or shift a timecode by a second and the joke stops working. This post is the spec I ended up with for one format, the window peeper trend, plus the ffmpeg checks I run before anything gets posted. Even if you never touch this meme, the method (treat a format like an interface contract) carries over to any short-form video work.

The format

Night exterior. A camera slowly pushes toward the only lit window in a dark building. Inside, someone is eating a burger. They notice the camera, freeze mid-chew, stare into the lens, then pull the curtain closed. The first matching clips appeared on TikTok on 20 October 2026, usually paired with an original sound credited to @therealrodentspawn.

Step 1: Write the beats as a timeline

Here's the beat sheet for a 14-second version:

Timecode	Beat	Requirement
00:00	Block	Wide establishing shot, one window lit, everything else dark
00:01	Push-in	Slow, continuous camera move toward the window
00:04	Bite	Subject eating, unaware, readable at phone size
00:07	Stare	Subject looks up into the lens, keeps chewing, holds it
00:13	Curtain	Subject closes the curtain; video ends

Writing it this way showed me three things that weren't obvious from watching clips:

The stare is the payload. It gets roughly six seconds, nearly half the runtime. Shortened versions (the popular CapCut template is about 8 seconds) mostly cut it here, and you can feel it.
The curtain is a hard end. Nothing comes after it, no outro and no text card. Adding anything after 00:13 kills the punchline.
The first second carries the context. Without the wide shot, a viewer doesn't know they're the one watching, and the stare loses its target.

If you're building templates, prompts or a generation pipeline, this table is your acceptance test. A render passes only if every beat lands roughly on time.

Step 2: Define the input contract

My generator takes one photo, and the photo decides most outcomes. Here's the input contract I settled on, written as validation rules:

faces        == 1            # extra faces leak into the scene
eyes_visible == 2            # the payload is a stare
framing      >= chest_up     # the outfit is part of the joke
lighting     == front, even  # side light causes face drift
source       == original     # not a screenshot of a forward
min_side_px  >= 1000
expression   == neutral      # a smiling stare is a different joke
subject      == consenting adult

The last rule isn't a technical constraint, but it belongs in the contract anyway. The format is a joke about being watched. Making a realistic video of someone who didn't agree turns it into the real thing. In my product, uploads are reviewed and renders that break this rule are removed.

Step 3: Define the output contract

Short-form platforms are forgiving about input, but the feed rewards a specific shape:

Aspect ratio: 9:16 vertical. Anything else gets letterboxed.
Duration: about 14 s for this format.
Container/codec: MP4 with H.264 is the safe default for uploads.
No baked-in trend audio. The sound is an in-app original sound. Ship the clip with ambience only and let the creator attach the trend audio inside TikTok or Reels.
No watermark if you want people to post it.

Step 4: Verify with ffprobe before posting

I don't trust a render until it passes a scripted check. ffprobe gives you everything you need:

ffprobe -v error -select_streams v:0 \
  -show_entries stream=width,height,codec_name,r_frame_rate \
  -show_entries format=duration \
  -of default=noprint_wrappers=1 render.mp4

Then assert on the output: height / width should be about 1.78 (16/9), duration should be close to 14, and the codec should be h264.

Two more one-liners I use all the time:

# Grab the stare frame (00:07) as a thumbnail / cover candidate
ffmpeg -ss 00:00:07 -i render.mp4 -frames:v 1 stare.jpg

# Contact sheet: one frame per beat, to eyeball timing in a single image
ffmpeg -i render.mp4 -vf "select='eq(n\,0)+eq(n\,30)+eq(n\,120)+eq(n\,210)+eq(n\,390)',scale=270:-1,tile=5x1" \
  -frames:v 1 -vsync vfr beats.jpg

(The frame numbers in the contact-sheet filter assume 30 fps. Multiply each timecode by your actual frame rate.)

The contact sheet is the most useful habit I've picked up. Five thumbnails side by side tell you at a glance whether the stare happens at the stare beat.

Step 5: Treat posting as part of the pipeline

A perfect render can still flop because of how it's posted. My posting checklist:

[ ] Trend sound attached in-app (or deliberate near-silence)
[ ] Caption plays along with the joke instead of explaining it ("who is filming my window at 2am")
[ ] 3â€“5 hashtags, not 30 (#windowpeeper #windowpeeperai #windowpeeperfilter plus one or two broad tags)
[ ] Platform AI label turned on: TikTok "AI-generated content", Instagram "AI info", YouTube "Altered or synthetic content"
[ ] Posted in the evening, since a night-window clip fits a night-time feed (roughly 7pmâ€“1am local)

I keep longer sound and hashtag notes on my project blog if you want the reasoning behind each item.

What I'd tell another dev building for a trend

Write the spec before the pipeline. Watching ten clips and writing a beat table took an hour and saved days of tuning.
Validate inputs aggressively. Most "the AI is broken" reports were really input-contract violations: sunglasses, group photos, side lighting.
Refund failures automatically. If a render fails, give the credits back without making anyone ask. It's cheap and it builds trust.
Plan for the trend to end. A single-format product has a shelf life, so keep the scope and the costs small.

The project this came from is Window Peeper AI: one photo in, a 14-second 9:16 MP4 out, with no watermark, using pay-per-video credits and no subscription. But the spec-first approach is the part worth stealing.

Disclosure: I'm the developer of Window Peeper AI, an independent project not affiliated with TikTok or CapCut. This article was written with AI assistance and reviewed and edited by me.

DEV Community: Thomas Chan