Applied AI-Powered Music Production Workflows

The Visualizer Content Pipeline

Last reviewed

Advanced

What you'll learn

~40 min
  • Build a Node.js CLI that batch-generates visualizer content for multiple platforms
  • Understand headless browser rendering with Puppeteer for automated video capture
  • Integrate cover art, track metadata, and visualizer themes into a content package
  • Produce platform-ready clips for Spotify Canvas, Instagram Reels, YouTube Shorts, and TikTok

What you’re building

You built an audio-reactive visualizer in Lesson 7. It looks great in a browser. But now you need that visualizer as actual video files — a looping 8-second clip for Spotify Canvas, a 15-second vertical for Instagram Reels, a 60-second Short for YouTube, and a full-length 16:9 background for your YouTube uploads. Four platforms, four aspect ratios, four durations. Normally you’d screen-record each one manually, crop it, trim it, export it. Four times. For every single release.

You’re going to build a CLI that does all of that in one command. Point it at a release config, and it renders every clip headlessly — no screen recording, no manual cropping, no export dialogs. One command, four platform-ready files, a manifest listing everything it produced.

This is the capstone. Every lesson in this module feeds into this one.

💬This pipeline replaces visualizer subscriptions

Rotor Videos, Specterr, Vizzy, Renderforest, and similar services sell visualizer rendering as paid plans for what is fundamentally the same thing: rendering an animation over your audio at specific dimensions. Your pipeline does this for free, uses YOUR visualizer design (not a generic template), and runs locally. Check each vendor’s current pricing and add up what a year of monthly releases would cost you. Over a catalog? It adds up fast.


How the pieces connect

This lesson pulls from almost everything you’ve built:

LessonWhat this pipeline uses
L1Cover art from release-assets/ — composited into the visualizer
L2Track metadata from campaign data — title, artist, album baked into clips
L6Command center integration — visualizer render status on your dashboard
L7The visualizer HTML itself — loaded headlessly by Puppeteer

The pipeline takes a release config file (YAML), loads your L7 visualizer in a headless browser, captures it at multiple resolutions and durations, and outputs platform-ready video files. That’s it. Config in, videos out.

ℹWhat is headless browser rendering?

Puppeteer opens Chrome without showing it on your screen. No window, no UI — just Chrome running invisibly in the background. It loads your visualizer HTML, plays the audio, and records what the browser is rendering into a video file. Think of it as automated screen recording. Same result as if you pointed OBS at your browser, but no human needs to sit there pressing buttons.


The release config

Here’s what a release config looks like. This is the single file that drives the entire pipeline:

REFERENCE CONFIG release.yaml multi-platform visualizer render configuration open reference hide reference Reference example of the YAML configuration your agent generates and reads to batch-render all four platform clips.
track:
title: "JADED"
artist: "moodmixformat"
album: "MIXTAPE FORMAT"
audio: "./audio/jaded.mp3"
cover: "./assets/jaded-cover.jpg"
visualizer:
theme: "tape-deck"
color: "#f97316"
outputs:
- platform: spotify-canvas
width: 576
height: 1024
duration: 8
loop: true
- platform: instagram-reel
width: 1080
height: 1920
duration: 15
- platform: youtube-short
width: 1080
height: 1920
duration: 60
- platform: youtube-background
width: 1920
height: 1080
duration: 0 # full track length

Each output entry defines a platform, dimensions, and duration. Duration 0 means full track length. The loop: true flag on Spotify Canvas tells the renderer to pick the best 8-second loop point (or just grab the first 8 seconds if peak detection isn’t available).


Before you start

First, if your AI tool is still open, leave it: type /exit and press Enter (if you use Antigravity, press Ctrl+D with nothing typed instead), and wait until you see the $ or % prompt. Make a clean folder for this lesson inside ~/producer-workbench:

Terminal window
mkdir -p ~/producer-workbench/08-visualizer-content-pipeline && cd ~/producer-workbench/08-visualizer-content-pipeline

On Windows PowerShell, run mkdir -Force ~/producer-workbench/08-visualizer-content-pipeline; cd ~/producer-workbench/08-visualizer-content-pipeline, or open the folder in your desktop agent app. Then start your agent the way your track’s setup lesson showed.

Switch to plan mode

Once your agent is open, switch to Plan mode inside the session (Shift+Tab, /plan, or your desktop app’s mode picker). In plan mode it asks clarifying questions and shows you a plan before building.

The conversation

Each message below is an example. Say it in your own words.

Say what you want

Start with a short plain-English description of what you want to build:

I want to build a batch pipeline tool that reads release.yaml, renders my browser audio visualizer automatically at multiple platform sizes with the track audio, and writes manifest.json. Ask me what you need first.

Answer its questions

Your agent will ask a few questions about CLI flags, video capture, and outputs. Answer each briefly:

If it asksYou might say
Which tools and command-line options should it support?Use whatever headless browser and video tools work best, with options for output folder, —preview, —draft, and —format mp4.
What four platform outputs should the sample release.yaml define?Spotify Canvas (576x1024, 8s), Instagram Reel (1080x1920, 15s), YouTube Short (1080x1920, 60s), and YouTube background (1920x1080, full track).
How should the visualizer page receive track metadata and play audio?Pass the track audio, cover art, title, artist, theme, and color into the visualizer page and start playback automatically.
How should video frames and audio be captured and encoded?Capture 30fps visualizer frames and combine them with the original track audio into platform-ready MP4 video files.
What should happen if ffmpeg is not installed on the machine?Log a clear warning and keep the captured PNG frames in a subfolder with instructions for manual encoding.

Read the plan

Before approving, check the plan for four domain essentials:

  1. Local Express server and autoplay flags let headless Chrome play audio. Puppeteer launches with --autoplay-policy=no-user-gesture-required and loads visualizer.html from a local HTTP server so the Web Audio AnalyserNode and cover art load without CORS or user-gesture blocks.
  2. Each platform output renders at its exact dimensions and duration. Viewport size matches width and height (or half resolution when --draft is set), and filenames follow {platform}_{width}x{height}_{duration}s.mp4.
  3. FFmpeg muxes the original audio into every MP4 (with a PNG fallback). The wrapper checks ffmpeg -version, combines the recorded video or 30fps PNG frames with the source audio (-c:v libx264 -pix_fmt yuv420p -c:a aac -shortest), and falls back cleanly if ffmpeg is absent.
  4. A --preview mode and manifest.json are included. Running --preview opens a visible browser window without recording so you can inspect the visualizer first, and every render writes manifest.json with dimensions, durations, and human-readable file sizes.

If the first plan opens visualizer.html directly from a local file path or doesn’t enable automatic audio playback in the headless browser, say so briefly:

Serve the visualizer page and audio files over a local web server and allow automatic audio playback in the headless browser so frequencies animate without a click.

When the plan covers all four, approve it: pick the option to proceed or say Yes, go ahead and build it (in Codex, press Shift+Tab first to leave plan mode). Once you verify --preview and a --draft render, ask your agent to save a Git checkpoint:

Save a checkpoint with Git so we can roll back if needed.
⚠Puppeteer downloads Chrome

The first time you run npm install in this project, Puppeteer will download a recent Chrome for Testing build plus a chrome-headless-shell binary into ~/.cache/puppeteer (Puppeteer’s install guide lists about 170 to 280 MB, depending on platform, as of 2026-11-07). Some package managers block install scripts by default; if yours does, the download is skipped and you run npx puppeteer browsers install yourself. It’s a one-time download — subsequent installs will use the cached version. If you’re on a slow connection, be patient. If it fails, check the Puppeteer troubleshooting section below.

The audio step and the frame fallback both run ffmpeg. Install it once with sudo apt install ffmpeg on Ubuntu or WSL, or brew install ffmpeg on macOS.


What you get

After your AI CLI tool finishes, you’ll have a project folder structure like this:

content-pipeline/
package.json
release.yaml
README.md
src/
cli.js
renderer.js
config-loader.js
ffmpeg-wrapper.js
manifest.js
templates/
visualizer.html

Set it up and run

Drop your audio file and cover art into audio/jaded.mp3 and assets/jaded-cover.jpg (or update the paths in release.yaml), then ask your agent to install what is needed, open the preview, and render the clips:

Install what the pipeline needs, open the visualizer in --preview mode so I can check it, and then render the MP4 clips.

If you prefer running the steps in a terminal yourself:

Terminal window
cd content-pipeline
npm install
mkdir -p audio assets
# Copy your audio and cover art (or edit release.yaml to point to your files):
cp ~/Music/jaded.mp3 ./audio/jaded.mp3
cp ~/Design/jaded-cover.jpg ./assets/jaded-cover.jpg

The first npm install takes a minute because Puppeteer downloads Chrome for Testing.

Preview first

Before rendering, check that the visualizer looks right (either by asking your agent or running the preview command):

Terminal window
node src/cli.js --preview

This opens a browser window with your visualizer running — audio playing, bars reacting, cover art displayed, track title showing. Make sure you like how it looks. Close the browser when you’re done.

Render everything

Ask your agent to render all four platform MP4 clips, or run:

Terminal window
node src/cli.js --format mp4

You should see output like:

REFERENCE OUTPUT Sample batch visualizer render terminal output open reference hide reference Reference example of the terminal output when all four platform clips finish rendering and manifest.json is written.
Loading config: release.yaml
Track: JADED by moodmixformat
Cover: ./assets/jaded-cover.jpg
Theme: tape-deck (#f97316)
Outputs: 4 platforms
Starting local server on port 3456...
Rendering spotify-canvas (576x1024, 8s)... done [12s]
Rendering instagram-reel (1080x1920, 15s)... done [28s]
Rendering youtube-short (1080x1920, 60s)... done [94s]
Rendering youtube-background (1920x1080, full track)... done [187s]
Output directory: ./output/
spotify-canvas_576x1024_8s.mp4 1.1 MB
instagram-reel_1080x1920_15s.mp4 3.8 MB
youtube-short_1080x1920_60s.mp4 12.4 MB
youtube-background_1920x1080_238s.mp4 42.1 MB
manifest.json 0.4 KB
4 clips rendered, manifest written.
💡Use --draft for faster iteration

Full-resolution rendering takes a while — a 60-second clip at 1080x1920 might take 90+ seconds. When you’re tweaking the visualizer theme or testing a new color, use node src/cli.js --draft to render at half resolution. It’s faster and good enough to check if the visual style is right. Save full-res renders for the final export.


A worked example: the full pipeline for a single release

Here’s the end-to-end workflow. You just finished mastering “JADED” and you have your cover art ready.

Step 1: Set up the release config

Edit release.yaml with your track details. Point the audio and cover paths to your actual files.

Step 2: Preview the visualizer

Terminal window
node src/cli.js --preview

The browser opens. Your cover art is centered, the tape deck theme is running, frequency bars are reacting to the audio in your signature orange. The track title “JADED” sits at the bottom in monospace. It looks right.

Step 3: Render all platforms

Terminal window
node src/cli.js --format mp4 -o ./jaded-visuals

Go make coffee. The pipeline renders all four clips.

Step 4: Check the outputs

Terminal window
ls -la ./jaded-visuals/

The command prints output like this:

spotify-canvas_576x1024_8s.mp4 1.1 MB
instagram-reel_1080x1920_15s.mp4 3.8 MB
youtube-short_1080x1920_60s.mp4 12.4 MB
youtube-background_1920x1080_238s.mp4 42.1 MB
manifest.json 0.4 KB

Open each file. Check:

  • Does the Spotify Canvas loop cleanly? (It should be 8 seconds or less)
  • Does the Instagram Reel look good at 9:16 vertical?
  • Does the YouTube Short have enough visual interest for 60 seconds?
  • Does the YouTube background look right at 16:9 for use behind your mix?

Step 5: Upload

  • Spotify Canvas: Upload through Spotify for Artists: go to Music, select the track, click Add Canvas (in the mobile app, tap Canvas). Must be 3-8 seconds, vertical 9:16, as an MP4 or JPG (Spotify’s Canvas guidelines).
  • Instagram Reel: Upload from the Instagram app.
  • YouTube Short: Upload as a Short (vertical, up to 3 minutes; this lesson renders 60 seconds by choice, not because of a limit).
  • YouTube background: Use as the visual layer in your RECORDED LOCATIONS episode or as a standalone visualizer video.

One command. Four platforms. Done.

🔍Platform-specific requirementsclick to expand

Each platform has its own specs, and getting them wrong means rejected uploads or bad quality:

Spotify Canvas

  • Dimensions: vertical 9:16; this sample uses 576x1024, within the 720-1080 px height range Spotify publishes. Confirm in the upload screen.
  • Duration: 3-8 seconds (looping is optional, but a clean loop looks best)
  • File size: Spotify’s Canvas guidelines page lists no size limit; keep clips small and check the upload screen
  • Format: MP4 (H.264) or a single JPG
  • Encoded size depends on duration, bitrate, codec, and visual complexity

Instagram Reels / TikTok

  • Dimensions: 1080x1920 (9:16) preferred (typical; check each platform’s current spec)
  • Duration: Reels now allow longer videos; check Instagram’s current limit (15 or 30 seconds is the sweet spot for music content)
  • File size: check each platform’s current upload limit
  • Format: MP4 (H.264 + AAC)
  • Check each platform’s minimum resolution; 1080p generally looks better

YouTube Shorts

  • Dimensions: 1080x1920 (9:16)
  • Duration: up to 3 minutes (this lesson’s 60-second output is a choice, not a limit)
  • Format: standard YouTube upload formats (MP4 preferred)
  • Must be vertical — YouTube treats short vertical videos as Shorts (check YouTube’s current rules)

YouTube (standard video)

  • Dimensions: 1920x1080 (16:9) minimum for HD
  • Duration: no practical limit for music content
  • Format: MP4 (H.264 + AAC)
  • This is your RECORDED LOCATIONS background or standalone visualizer upload

The pipeline handles all of these dimensions and durations automatically from the release config. You define it once and forget about the specs.


If something is off

ProblemFollow-up prompt
Visualizer has no audio reaction (bars are flat)The visualizer bars aren't reacting to the audio. Make sure the frequency analyzer receives the playing track and the headless browser allows automatic audio playback without waiting for a click.
Colors don’t match the configThe visualizer is using default blue bars instead of my configured orange (#f97316). Make sure the color from release.yaml is passed into the visualizer and applied to the bars and accents.
Cover art doesn’t appearThe cover art image isn't showing in the visualizer. Make sure the local server exposes the assets folder and resolves the cover path from release.yaml correctly.
Rendering produces black framesThe rendered video is all black. Wait for the visualizer page and cover art to finish loading and for audio playback to begin before capturing video frames.

🔧

When Things Go Wrong

Use the Symptom → Evidence → Request pattern: describe what you see, paste the error, then ask for a fix.

Symptom
Puppeteer can't find Chrome or Chromium
Evidence
Error: Could not find Chrome. Set the PUPPETEER_EXECUTABLE_PATH environment variable or install Chrome.
What to ask the AI
"Puppeteer can't find a Chrome binary. Three fixes, try in order: (1) Run 'npx puppeteer browsers install' to download the Chrome for Testing build Puppeteer expects (needed when your package manager blocked the install script). (2) If Chrome is installed but Puppeteer can't find it, set the path manually: export PUPPETEER_EXECUTABLE_PATH=/usr/bin/google-chrome (or wherever Chrome is). On Mac: /Applications/Google Chrome.app/Contents/MacOS/Google Chrome. On Windows/WSL: /mnt/c/Program Files/Google/Chrome/Application/chrome.exe. (3) Install the puppeteer package (not puppeteer-core), which downloads its own Chrome for Testing."
Symptom
Output video has no audio
Evidence
The rendered MP4 plays the visualizer animation but there's no sound -- the video is silent
What to ask the AI
"The rendered MP4 plays the visualizer animation, but the video is completely silent. Make sure the encoding step merges the original audio file from release.yaml into each rendered MP4 and trims the output so video and audio end together."
Symptom
Rendering is extremely slow (minutes per clip)
Evidence
A 15-second clip is taking 5+ minutes to render, and longer clips seem to hang
What to ask the AI
"Rendering is taking several minutes per clip. Add a --draft flag that renders at half resolution and 24fps for quick test runs, and configure the headless browser for fast background frame capture."
Symptom
Spotify Canvas file is too large
Evidence
The spotify-canvas clip is large and the upload fails
What to ask the AI
"The Spotify Canvas MP4 is too large. Compress the 8-second 576x1024 clip more aggressively during encoding and warn in manifest.json if the Spotify Canvas output exceeds a 2 MB target."
Symptom
Colors look washed out or oversaturated in the rendered video
Evidence
The visualizer looks perfect in --preview mode but the rendered video has different, duller colors
What to ask the AI
"The visualizer colors look great in --preview mode, but the rendered MP4 looks washed out. Capture lossless PNG frames rather than compressed JPEGs and encode the video using standard HD color settings so the orange accents match the live preview."

Customize it

Batch-render an entire album

Add a --batch flag taking an album YAML with a tracks array, rendering all platform outputs into per-track subfolders, and writing an album manifest.json.

Auto-upload to YouTube

Add a --upload-youtube flag that connects to my YouTube account and uploads the rendered Short and standard background video with the track metadata.

Highlight reel mode

Add a --highlight flag that analyzes the track's loudness curve and automatically picks the highest-energy drop section for the 8-second and 15-second clips.

Text overlay system

Add support for a textOverlay section in release.yaml that renders timestamped text entries on the visualizer with 0.3-second fade transitions.

KNOWLEDGE CHECK

Your content pipeline uses Puppeteer to render visualizer videos. What does Puppeteer actually do in this workflow?


The complete module: everything you built

This is lesson 8 of 8. Here’s the full system you now have:

#ToolWhat it does
1Release Asset EngineOne cover image in, six platform-sized assets out
2Campaign GeneratorOne metadata file in, captions, hashtags, calendar, and EPK out
3RECORDED LOCATIONS BuilderEpisode notes in, all YouTube publishing metadata out
4Moodmix Control RoomCSV exports in, geographic and business intelligence out
5Royalty ReconcilerDistributor CSVs in, discrepancy flags and revenue report out
6Release Ops Command CenterAll of the above in, one weekly action-plan dashboard out
7Audio Visualizer GeneratorAudio file in, signature tape deck visualizer out
8Visualizer Content PipelineRelease config in, platform-ready video clips out

These tools chain together. The asset engine’s cover art feeds into the visualizer pipeline. The campaign generator’s metadata populates your content clips. The control room and reconciler feed the command center. The visualizer from L7 is the core of the content pipeline in L8. Everything connects.


What you actually built in this module

Eight CLI tools, each built in a single session with AI assistance. What you got:

A complete release operations system. From the moment you finish mastering a track to the moment it’s live on every platform, you have a tool for every step. Cover art resized for 6 platforms. Campaign captions and calendar generated. YouTube episode metadata ready. Analytics dashboard running. Royalties reconciled. Command center showing your weekly priorities. Visualizer content rendered for 4 platforms. All in one pipeline, all running locally, all free.

The dollar math. Add up what this replaces: Canva Pro, Later or Buffer, Chartmetric (from $40/month billed yearly as of November 2026, per chartmetric.com/pricing), a royalty tracking service, Rotor Videos or Specterr, plus the time cost of doing everything manually. Check each vendor’s current pricing and total it for your own stack. Your tools cost nothing to run after they’re built. Your data never leaves your machine. And they work exactly the way you want them to because you directed the AI that built them.

A repeatable pattern. Every tool follows the same structure: define a config, run a command, get outputs. The config-to-output pipeline pattern is the same one used by labels, distributors, and music tech companies — they just have engineering teams building it. You have a CLI and an AI tool. The result is the same.


Key takeaways

  • Automation compounds. Measure the time each tool saves across your own release workflow and use it to prioritize further automation.
  • The pipeline pattern is universal. Config file in, processed outputs out. It’s the same structure whether you’re rendering visualizers, resizing cover art, or generating campaign content. Once you internalize this pattern, you can build a pipeline for anything.
  • Your content pipeline is your competitive advantage. Major labels have teams of people doing content operations — resizing art, scheduling posts, reconciling royalties, rendering promo clips. You have a set of CLI tools that do it all in minutes. The playing field is more level than it’s ever been.
  • Everything runs locally, costs nothing, and is yours forever. No subscriptions to cancel. No platform changes breaking your workflow. No vendor lock-in. The tools live on your machine. You can modify them, extend them, chain them together. They evolve with your workflow.
  • The only thing left is making the music. That was always the point. Every minute spent on release operations is a minute not spent creating. These tools exist so you can stop resizing images, stop copy-pasting captions, stop manually screen-recording visualizers, and go make something.

Try it yourself

  1. Open your AI tool in your lesson folder and switch to plan mode.
  2. Talk your agent through the plan and approve it to build the pipeline.
  3. Ask your agent to install what is needed (or run npm install in your terminal) and wait for the headless browser download.
  4. Drop an audio file and cover art into the project.
  5. Edit release.yaml with your track details.
  6. Ask your agent to run --preview (or run node src/cli.js --preview) to check the visualizer.
  7. Ask your agent to render all four platform clips (or run node src/cli.js --format mp4).
  8. Open the outputs. Upload them. Release your music.

Every new release is now a pipeline. The tools are built. The workflow is yours. Go make music.

intellimetrics · Arlington, VA
© 2026 intellimetrics.net
Search lessons