“Score Frames 1 To 240” Is Eight Seconds And Two Thirds Of A Million Tokens

This card opens with a sentence we have been waiting all month for somebody to print:

“Claude never ‘makes’ a video. It writes code that paints every frame.”

That is exactly right, and it is the distinction most AI-video cards blur. The model is not a renderer. It writes a page, a headless browser screenshots it, and ffmpeg stitches the screenshots into an MP4. Step 1 names the real toolchain — Node, Playwright, FFmpeg — which is more candour than this genre usually manages.

So this piece is not about whether the pipeline works. It is about step 5, which is the clever part and also the expensive part, and about one number printed in its mock-up: “Score frames 1 to 240.”

First, the good news about step 5

Step 5 says Claude “reviews its own stills, flags weak ones and re-renders until every frame scores 8 out of 10 or better”, with the example failure “Frame 87 scored 6/10 (text overlap). Fixed, now 8.5.”

We have taken apart a self-scoring loop on this blog before and found the judge was reading a transcript rather than the work. This one is different, and in the way that matters: the grader is looking at the actual rendered PNG. Claude has vision; a frame is an image; the artefact is genuinely in front of the model. That makes this a materially more honest grading loop than the one we checked last week, where the evaluator could not open the file it was scoring.

Which leaves cost as the real constraint, and cost here is countable.

Diagram: what 240 frames costs to look at

The vision documentation gives the formula outright: “Claude processes images in patches instead of pixels. Each patch is a 28×28-pixel block… An image, therefore, costs ⌈width / 28⌉ × ⌈height / 28⌉ visual tokens.” Opus 5.5 is on the high-resolution tier, where a 1920×1080 frame is not downscaled at all.

And 240 frames is not a long video. At 30 frames a second it is eight seconds. At 24fps, ten. At 60fps, four. The card’s own example number describes a title card, not an explainer — which is the right scope for this technique and worth knowing before you plan a two-minute piece around it.

And there is a hard ceiling the card never mentions

Token cost is a budget question. The image limits are a wall.

The maximum number of images for each message or request is: “20 for each message on claude.ai”, “100 for each request on the API, for models with a 200k-token context window”, and “600 for each request on the API, for all other models”.

“If a single API request contains more than 20 images, a stricter per-image dimension limit applies to every image in that request… To stay under the limit on all platforms, either resize each image so that neither dimension exceeds 2000 px, or keep the request to 20 or fewer image and document blocks.”

Read that first line against the card’s instruction. “Score frames 1 to 240” cannot be one message in a chat window. It is twelve messages at the claude.ai ceiling, or one API request, or — the sane version — a script that batches them.

The second quotation is the trap underneath it. Go past twenty images and every image in that request falls under the stricter dimension rule. 1920×1080 is inside it on both axes. 4K frames are not, so a 3840-pixel-wide still in a 240-image batch is rejected outright rather than quietly downscaled.

That is the useful reframe. The card draws five steps as if they were five prompts. Steps 1 to 4 can be conversations. Step 5 is a program — a loop that renders, batches, scores, filters and re-renders — and the card’s own toolchain is already sitting there to run it.

One caution on what the grader is good at

The example failure is “Frame 87 scored 6/10 (text overlap)”. That is a spatial judgement, and the vision documentation is candid about spatial judgements:

“Spatial reasoning: Claude’s coordinate and localization outputs are approximate.”

“Counting: Claude can give approximate counts of objects in an image but might not always be precisely accurate, especially with large numbers of small objects.”

So the grader will catch gross text overlap, which is the common failure. It is less reliable on two-pixel misalignments and on counting elements in a busy frame. Both of which argue for the same thing: grade a sample, not every frame. Twelve stills at one-second intervals catch the same class of problem for five per cent of the tokens, and you look at the sheet yourself.

The other four steps, which are the cheap half

Four honest caveats

1. We did not build the pipeline. The token arithmetic comes from the documented patch formula and the published per-tier table; we have not run 240 frames through anything.
2. The money figures are API list prices used as a yardstick. If you run this inside a subscription you will never see a bill like that — you will see a usage allowance move. The ratios hold; the dollars are a unit of measurement.
3. 240 is the card’s number, not a requirement. It appears in a mock-up, and “score frames 1 to 240” may well be shorthand rather than a literal batch. Our point is what that instruction costs if taken literally, which is the way a card gets read.
4. This is the most technically literate card we have taken apart. The subtitle is honest, the toolchain is named, the spring-versus-easing point is a genuine craft opinion, and the fine print says “test each step and check the official docs”. The objection is a budget, not a misunderstanding.

The one-line version

Step 5 is the best self-grading loop we have seen on one of these cards, because the judge is genuinely looking at the frame — and that is exactly why it costs 2,691 visual tokens per 1080p still, 646,000 for the 240 the card names, and more than twenty images a message if you try it in a chat window.

Grade a sample, not every frame. Keep stills under 2000 pixels on both sides. And run step 5 as a script, which is what steps 1’s toolchain was installed for.