How to add a glowing text with Claude

Add glowing text to input.mp4: "GLOW UP" in white (255, 255, 255) Arial Black (or another heavy bold font), at a 92 pixel font size (17% of the frame width), centered horizontally 15% of the way down. Behind the letters put a gold (255, 190, 60) halo: draw the text in white with a 4 pixel stroke onto a grayscale mask, blur one copy by 5 pixels and another by 14 pixels, add the two together and use the result as the alpha of a solid gold layer. Nothing shows before 0.5 seconds; the text and halo fade in linearly from 0.5 to 0.8 seconds. From 0.8 seconds the halo's opacity pulses on a cosine with a 1.5 second period, from full strength down to 25% and back, so it is brightest at 0.8, 2.3, 3.8 and 5.3 seconds and dimmest at 1.55, 3.05 and 4.55 seconds, while the white letters stay fully opaque. 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
"""Glowing text: solid white letters with a soft gold halo that swells and fades like a slow heartbeat.

Usage: python3 glowing-text.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, ImageChops, ImageDraw, ImageFilter, ImageFont

TEXT = "GLOW UP"            # the headline
START = 0.5                 # second the text fades in
FADE_IN = 0.3               # seconds the fade in takes
PERIOD = 1.5                # seconds per glow pulse (bright, dim, bright)
LOW = 0.25                  # glow strength at the dimmest point of a pulse (1 = full)
Y = 0.15                    # text center, 0-1 down the frame
SIZE = 0.17                 # text height as a share of the frame width
COLOR = (255, 255, 255)     # letter color
GLOW = (255, 190, 60)       # halo color
BLUR = 14                   # halo softness in pixels
FONTS = ["/System/Library/Fonts/Supplemental/Arial Black.ttf",    # macOS
         "/System/Library/Fonts/Supplemental/Arial Bold.ttf",
         "/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 layers():
    """The letters and their halo, each on its own transparent frame."""
    font = ImageFont.truetype(FONT_FILE, round(w * SIZE))
    letters = Image.new("RGBA", (w, h))
    ImageDraw.Draw(letters).text((w / 2, h * Y), TEXT, font=font, anchor="mm", fill=COLOR)
    shape = Image.new("L", (w, h))
    ImageDraw.Draw(shape).text((w / 2, h * Y), TEXT, font=font, anchor="mm", fill=255, stroke_width=4)
    # a tight bloom next to the letters plus a wide soft one, added together
    halo = ImageChops.add(shape.filter(ImageFilter.GaussianBlur(BLUR / 3)), shape.filter(ImageFilter.GaussianBlur(BLUR)))
    glow = Image.new("RGBA", (w, h), GLOW)
    glow.putalpha(halo)
    return letters, glow


def strength(t):
    """Glow strength: 1 at START + FADE_IN, down to LOW half a PERIOD later, back up, and so on."""
    return LOW + (1 - LOW) * (0.5 + 0.5 * math.cos(2 * math.pi * (t - START - FADE_IN) / PERIOD))


def overlay(t):
    shown = min(max((t - START) / FADE_IN, 0), 1)
    if shown <= 0:
        return blank
    a = shown * strength(t)
    img = glow.copy()
    img.putalpha(glow.getchannel("A").point(lambda v: round(v * a)))
    text = letters.copy()
    text.putalpha(letters.getchannel("A").point(lambda v: round(v * shown)))
    img.alpha_composite(text)
    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)
letters, glow = layers()
blank = Image.new("RGBA", (w, h))
render(src, out)