How to add an animated checklist with Claude

Add an animated checklist to input.mp4: a dark (15, 15, 25) rounded card at 75% opacity, 84% of the frame width, centered horizontally with its center 80% of the way down, holding three lines in white bold text 31 px tall: "Brighter in 7 days", "Fragrance free" and "Dermatologist tested". The card fades in over 0.3 seconds at 0.5 seconds. The lines slide 43 px in from the left and fade up over 0.3 seconds, starting at 0.5, 1.3 and 2.1 seconds. To the left of each line, a green (34, 197, 94) circle 44 px across pops in 0.25 seconds after its line starts and a white tick draws itself inside it over 0.25 seconds. Everything stays on to the end. Use Python with Pillow to draw it and ffmpeg to put it on the video (don't rely on ffmpeg's drawtext filter), keep the audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Animated checklist: benefit lines slide in one by one on a dark card, each getting a green tick.

Usage: python3 animated-checklist.py input.mp4 output.mp4
Needs ffmpeg and Pillow (pip install pillow).
"""
import json
import math
import subprocess
import sys
from pathlib import Path

from PIL import Image, ImageDraw, ImageFont

LINES = ["Brighter in 7 days", "Fragrance free", "Dermatologist tested"]
START = 0.5              # second the first line slides in
GAP = 0.8                # seconds between lines
SLIDE = 0.3              # seconds each line takes to slide in
TICK_DELAY = 0.25        # seconds after its line starts that the tick draws itself
TICK = 0.25              # seconds the tick takes to draw
SIZE = 0.058             # text height as a share of the frame width
Y = 0.80                 # where the card's center sits (0 = top, 1 = bottom)
GREEN = (34, 197, 94)    # tick circle color
CARD = (15, 15, 25, 190) # card color and opacity
FONTS = ["/System/Library/Fonts/Supplemental/Arial Bold.ttf",     # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",  # Linux
         "C:/Windows/Fonts/arialbd.ttf"]                          # Windows
FONT_FILE = next((f for f in FONTS if Path(f).exists()), None) or sys.exit("No bold font found: add one to FONTS")


def ease_out(p):
    p = min(max(p, 0), 1)
    return 1 - (1 - p) ** 3


def tick(t, d):
    """A green circle with a white tick drawn stroke by stroke; d is the circle's width."""
    img = Image.new("RGBA", (d, d))
    pop = ease_out(t / 0.15)
    if pop <= 0:
        return img
    r = d / 2 * pop
    draw = ImageDraw.Draw(img)
    draw.ellipse([d / 2 - r, d / 2 - r, d / 2 + r, d / 2 + r], fill=GREEN)
    # the tick runs from a to b (short stroke) then b to c (long stroke)
    a, b, c = (d * 0.27, d * 0.52), (d * 0.43, d * 0.68), (d * 0.74, d * 0.35)
    p = ease_out(t / TICK) * 2
    stroke = max(3, d // 9)
    if p > 0:
        k = min(p, 1)
        draw.line([a, (a[0] + (b[0] - a[0]) * k, a[1] + (b[1] - a[1]) * k)], fill="white", width=stroke, joint="curve")
    if p > 1:
        k = p - 1
        draw.line([b, (b[0] + (c[0] - b[0]) * k, b[1] + (c[1] - b[1]) * k)], fill="white", width=stroke, joint="curve")
    return img


def overlay(t):
    img = Image.new("RGBA", (w, h))
    if t < START:
        return img
    font = ImageFont.truetype(FONT_FILE, round(w * SIZE))
    row = round(w * SIZE * 2)
    d = round(w * SIZE * 1.4)
    pad = round(w * 0.05)
    card_w = round(w * 0.84)
    card_h = row * len(LINES) + pad
    x0, y0 = (w - card_w) // 2, round(h * Y - card_h / 2)
    fade = ease_out((t - START) / SLIDE)
    card = Image.new("RGBA", (w, h))
    ImageDraw.Draw(card).rounded_rectangle([x0, y0, x0 + card_w, y0 + card_h], radius=round(w * 0.04),
                                           fill=CARD[:3] + (round(CARD[3] * fade),))
    img.alpha_composite(card)
    for i, line in enumerate(LINES):
        t0 = START + i * GAP
        if t < t0:
            break
        p = ease_out((t - t0) / SLIDE)
        cy = y0 + pad // 2 + row * i + row // 2
        shift = round((1 - p) * w * 0.08)
        layer = Image.new("RGBA", (w, h))
        layer.alpha_composite(tick(t - t0 - TICK_DELAY, d), (x0 + pad, cy - d // 2))
        ImageDraw.Draw(layer).text((x0 + pad + d + round(w * 0.04), cy), line, font=font, anchor="lm", fill="white")
        layer = layer.transform(layer.size, Image.AFFINE, (1, 0, shift, 0, 1, 0))
        alpha = layer.getchannel("A").point(lambda v: round(v * p))
        layer.putalpha(alpha)
        img.alpha_composite(layer)
    return img


def probe(path):
    info = json.loads(subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
                                               "stream=width,height,r_frame_rate:format=duration", "-of", "json", path]))
    s = info["streams"][0]
    num, den = s["r_frame_rate"].split("/")
    return s["width"], s["height"], s["r_frame_rate"], float(num) / float(den), float(info["format"]["duration"])


def render(src, out):
    """Draw overlay(t) on every frame of src and save to out, keeping the audio."""
    ff = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-i", src,
                           "-f", "rawvideo", "-pix_fmt", "rgba", "-s", f"{w}x{h}", "-r", rate, "-i", "-",
                           "-filter_complex", "[0:v][1:v]overlay=shortest=1,format=yuv420p[v]",
                           "-map", "[v]", "-map", "0:a?", "-c:v", "libx264", "-crf", "18", "-c:a", "copy", out],
                          stdin=subprocess.PIPE)
    for i in range(math.ceil(duration * fps)):
        ff.stdin.write(overlay(i / fps).tobytes())
    ff.stdin.close()
    if ff.wait():
        sys.exit("ffmpeg failed")


src, out = sys.argv[1:3]
w, h, rate, fps, duration = probe(src)
render(src, out)