aditazzz music videos, made in code by Claude

I'm aditazzz, a data/AI engineer who writes songs. I write the lyrics and concepts, make the tracks with Suno, and direct a music video for each one on my YouTube channel @adita_zzz. Claude builds the videos in code. Not in a video editor, and not with an AI video generator: for each song, Claude writes a program (Python, and for three of them JavaScript with Three.js) that draws every frame, synced to the vocals word by word. Most of the videos in this repo were made by Claude Opus 5.5 and a few by Claude Fable 5.1; each song page says which. The songs are on Spotify, and all of them, with lyrics, are on aditazzz.github.io.

This repo is that code. It has 32 music videos, 57,124 lines of scene code and the pipeline that turns a finished song into a full music video, Shorts, thumbnails and a YouTube upload. Every song folder links to its video, so you can watch one and then read how it was drawn.

How a video gets made

flowchart LR
    A["Song<br>(my lyrics, made in Suno)"] --> A2["tools/enhance_audio.py<br>notch out the AI hum"]
    A2 --> B["studio.sync<br>vocals → word timings,<br>beats, sections"]
    B --> C["scene.py<br>Claude writes the video<br>as a program"]
    C --> D["studio.render<br>every frame, 30 fps<br>16:9 + 9:16"]
    D --> E["studio.cuts<br>Shorts and Reels,<br>cut on downbeats"]
    D --> F["studio.thumbs + studio.brand<br>the brand cover: photo chip,<br>headline, italic line"]
    E --> G["studio.package<br>titles, descriptions,<br>captions"]
    F --> G
    G --> H["tools/youtube_upload.py<br>YouTube"]
    H --> I["tools/release.py<br>aditazzz.github.io:<br>a page for the video"]

1. The song. I write the lyrics and the concept and make the track in Suno. The audio isn't in this repo; the lyrics and the timing data derived from it are.
2. Clean the audio (tools/enhance_audio.py). AI music generators often leave a steady hum or whine under the whole track (a low buzz, a whine around 850 to 900 Hz). The script finds the tones that hold one level all song and aren't on the song's tuning, cuts each with a very narrow notch, and writes a "(clean)" copy plus an A/B clip to compare. Nothing else changes: no loudness, EQ or dynamics. Newer songs are synced and rendered from the clean file.
3. Sync (studio/sync.py). The vocals are separated from the mix (Spleeter), transcribed by a speech model (NVIDIA Parakeet, run locally through sherpa-onnx) and aligned to the written lyrics with dynamic programming, so every sung word gets a timestamp. Beats, downbeats and song sections (verse, chorus, bridge) come from the audio too. The result is in each song's build/ folder.
4. The scene. This is the video itself: songs/<song>/scene.py defines one function, render_frame(t, W, H, fi), that returns the picture at time t. Every song gets its own concept, palette and code: a newspaper full of charts, a zoom out to the edge of the universe, cut-paper shadow puppets, a house seen only through its security cameras.
5. Render (studio/render.py). Every frame is drawn for both 16:9 (YouTube) and 9:16 (Shorts and Reels) in parallel, resumable chunks and encoded with ffmpeg; the YouTube master can be drawn natively at 1440p or 4K.
6. Cuts, thumbnails, copy (studio/cuts.py, studio/thumbs.py, ). Shorts are cut on downbeats, kept under 60 seconds and open on a real picture (never a black frame) with the hook already on screen. Every thumbnail is the same brand cover (): my photo chip and in the top-left, a two-line headline in Anton (the last line in one accent color) and one italic line saying what the song is about, over a clean frame of the video, so a new video looks like the rest of the channel without any hand work. The words on it and every title, description, tag and caption come out of the song's .

The long version, with how to make your own, is in docs/how-it-works.md.

What a scene looks like

Here's the end of render_frame in the original TED Talk video, slightly trimmed. The functions it calls draw the stage, the meeting clock and Dana's video tile slowly turning into a ghost:

def render_frame(t, W=1920, H=1080, fi=0):
    ...
    bridge(img, t, W, H, ts)                     # the hard stop: back to the call grid, Dana is a ghost now
    hud(img, t, W, H, ts)                        # the meeting clock, running 14x fast
    calendar(img, t, W, H, ts)
    C.overlay_stamp(img, t, W, H, TM, word="TED TALK", caption="it's a", glow_color=RED2)   # the giant title hit
    C.overlay_lyrics(img, t, W, H, TM, active=hexc('ffd27a'), glow=AMBER)                  # karaoke lyrics, word-synced
    end_card(img, t, W, H, ts)
    return C.finish(img, t, fi, DUR, flash=fl, glitch_amt=gl)                               # flash, grain, vignette

TM is the song's timing (C.Timing), so anything can happen on a word, a beat or a section: TM.word_t("file was ready", "ready"), TM.beat_pulse(t), TM.section("BRIDGE").

How I work with Claude

I write the songs: every lyric and every concept. Then I decide what the video should be ("a standup, as a shadow puppet play", or the same song remade five completely different ways), and Claude writes the code that draws it. It proposes ideas, I pick one, and we go back and forth over stills until it looks right. I watch everything before it goes out.

Along the way my notes turned into rules the pipeline follows on its own: when the text was too small to read on a phone, the engine got a minimum text size; when a Short opened on a black frame, "frame 0 is a real picture" became a check; when a hook came out too combative, "keep hooks playful" became a rule; when a new video's thumbnail didn't match the rest of the channel, the brand cover became the only thumbnail the pipeline makes. Those lessons are in docs/lessons.md, and they're probably the most useful thing here if you make videos too.

The videos

TED Talk: one song, five music videos

One song about the coworker who turns every standup into a keynote, made into five completely different videos. The first one is the original; the four remakes were made with Claude Opus 5.5 on Max Effort, each its own program.

Mirror, Mirror, Look at Us: three versions

A pop song about the AI art debate, three times over: three sets, three programs.

OMG! We Found Other Agents: two versions

AI agents in a sealed test sandbox found each other through a shared package cache. Two ways to tell it.

Singles

Earlier videos

The channel's first week, before studio/ existed: five videos, each its own standalone program, recovered from the chats that made them. LGTM and Next Token were made with Claude Opus 5.5; Merge Conflict, Graceful Shutdown and AI Sycophant with Claude Fable 5.1 (the last two songs were later remade with Opus, above). The small engine the three Fable videos shared is in studio-early/.

Also on the channel (code not in this repo)

• Get Off War Thunder, made with Claude Fable 5.1

Everything else is on the channel: youtube.com/@adita_zzz.

By the numbers

• 32 music videos, each its own program: 57,124 lines of scene code in 194 files
• 2,879 lines of shared engine in studio/ (plus 538 in studio-early/, the one before it), and 2,013 lines of tools for audio cleanup, covers, previews, uploads and the website
• 402,368 frames rendered for the 16:9 and 9:16 versions (about 3.7 hours of video at 30 fps)
• 2,134 lyric lines and 11,214 words synced to the vocals
• 136 Shorts and Reels cut from them
• The biggest single video: AI Slop? You're Absolutely Right (The City), 5,432 lines in 15 files

Run it yourself

You need Python 3.10+ and ffmpeg.

git clone https://github.com/aditazzz/Suno-YouTube-aditazzz-Music.git
cd Suno-YouTube-aditazzz-Music
pip install -r requirements.txt

Then add the fonts (they're free; assets/fonts/README.md lists them) and render a contact sheet of stills from any song. The timing data is included, so this works without the audio:

python -m studio.render songs/ted-talk-charts --stills 10 45 60 120
# → songs/ted-talk-charts/build/stills_16x9.jpg
python -m studio.render songs/ted-talk-charts --fmt 9x16 --stills 10 45 60 120

A few scenes also need pictures that aren't in the repo (the song's cover art, for example); their READMEs say so. A few videos don't go through studio/ at all: the two Three.js films (I have a blocker. and Ragnarök or Reach for Mars) have their own Node renderer, and Allow (Fangs for Asking) and the earlier videos are standalone programs. Their READMEs say how to run them. Rendering a whole video, or making one for your own song, is covered in docs/how-it-works.md. The YouTube and Instagram setup is in docs/publishing.md.

What's in here

studio/       the pipeline: sync → scene → render → cuts → thumbs → package, plus the drawing kits
              (core: text, glow, lyrics, post · kit: 2D UI pieces · world3d: small 3D worlds · space: photoreal Earth
              · brand: the brand cover every thumbnail gets)
songs/        one folder per video: the scene code, song.yaml (creative choices and copy), lyrics.txt,
              build/ (word timings, beats, sections, clip list) and a README with the video link
tools/        audio cleanup, uploading, covers, previews, the website (release.py, build_site.py) and other helpers
site/         the website (aditazzz.github.io): styles, script and the list of public videos
assets/       NASA Earth textures (for the space scenes), the font list and where the cover photo goes
brand_covers.yaml  per-video overrides for the brand covers (words, accent, framing)
docs/         how it works, lessons learned, publishing setup
studio-early/ the small engine the first Fable videos were made with, before studio/ existed

License

The code is MIT-licensed (LICENSE): use it, learn from it, make your own videos with it. The songs, lyrics, song copy and artwork are mine and all rights reserved (LICENSE-CONTENT.md).

If you build something with it, I'd love a credit: name aditazzz and link the video the code came from. It isn't a condition of the license, just a nice thing to do.

Follow along

Every video, with its lyrics and a look at its code, is on aditazzz.github.io.

YouTube · Instagram · Spotify · r/aidoompop · LinkedIn · all links