How to add a letter-by-letter reveal with Claude

Add a letter-by-letter reveal to input.mp4: the line "GLOW IN 7 DAYS" in Arial Black (or any heavy bold font) 9% of the frame width tall, deep ink color (25, 15, 50), centered across with its center 86% of the way down. Each letter (spaces included in the count) starts 0.08 seconds after the one before, the first at 0.5 seconds. Over 0.45 seconds with a cubic ease-out, each letter fades from fully transparent to solid while rising 6% of the frame width into its final place; then every letter stays to the end. Nothing shows before 0.5 seconds. Use Python with Pillow to draw the text 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
"""Letter-by-letter reveal: each letter of a headline fades in and rises into place a moment after the one before.

Usage: python3 letter-stagger-reveal.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

TEXT = "GLOW IN 7 DAYS"      # the headline
START = 0.5                  # second the first letter starts to appear
STAGGER = 0.08               # seconds between one letter starting and the next
EASE_IN = 0.45               # seconds each letter takes to fade in and rise
RISE = 0.06                  # how far each letter rises, as a share of the frame width
SIZE = 0.09                  # text height as a share of the frame width
Y = 0.86                     # where the line's center sits (0 = top, 1 = bottom)
COLOR = (25, 15, 50)         # text color, a deep ink
FONTS = ["/System/Library/Fonts/Supplemental/Arial Black.ttf",    # macOS
         "/System/Library/Fonts/Supplemental/Arial Bold.ttf",     # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",  # Linux
         "C:/Windows/Fonts/ariblk.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 letter_tiles():
    """Each letter drawn once on its own tile, plus the x where its tile goes."""
    font = ImageFont.truetype(FONT_FILE, round(w * SIZE))
    pad = round(w * SIZE * 0.2)
    left = (w - font.getlength(TEXT)) / 2
    tiles = []
    for i, ch in enumerate(TEXT):
        if ch == " ":
            continue
        size = (round(font.getlength(ch)) + 2 * pad, round(w * SIZE * 1.4) + 2 * pad)
        tile = Image.new("RGBA", size)
        ImageDraw.Draw(tile).text((pad, size[1] / 2), ch, font=font, anchor="lm", fill=COLOR)
        tiles.append((i, tile, round(left + font.getlength(TEXT[:i]) - pad)))
    return tiles


def overlay(t):
    """Letter i starts at START + i * STAGGER, fading from clear to solid while rising RISE into place."""
    img = Image.new("RGBA", (w, h))
    for i, tile, x in tiles:
        p = ease_out((t - START - i * STAGGER) / EASE_IN)
        if p <= 0:
            continue
        faded = tile.copy()
        faded.putalpha(tile.getchannel("A").point(lambda a: round(a * p)))
        y = round(h * Y - tile.height / 2 + (1 - p) * w * RISE)
        img.alpha_composite(faded, (x, y))
    return img


def ease_out(p):
    """0 -> 1, fast at first and settling softly (cubic ease-out)."""
    p = min(max(p, 0), 1)
    return 1 - (1 - p) ** 3


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)
tiles = letter_tiles()
render(src, out)