Chapter 14 — AI in the Loop, Honestly

This is the chapter people expect this book to be, so let’s clear the air first: nothing you’ve built in the last thirteen chapters is generative AI. The pipeline is deterministic code playing instruments — closer to a player piano than to a music-generating model. The one neural network in the signal path (the amp captures of Chapter 3) is a network imitating a circuit, not composing anything.

But AI music generators exist, they’re getting good, and a code-first studio is the best imaginable harness for them — precisely because it treats them as one more instrument instead of a magician. This chapter is how I actually use them, where they’ve earned a place on records, where they haven’t, and the licensing reality nobody puts in the demo video.

The right mental slot: texture, not composer

The generative music services fall into two rough families. Vocal song-makers (Suno, Udio) produce complete sung songs from a text prompt. Instrumental engines (Google’s Lyria, and others) stream instrumental audio matching a described style. Both share a property that matters enormously to this book’s philosophy: you can’t diff a prompt. Ask twice, get two different songs; there’s no take 47, no one-line amp swap, no null test. Everything Part II built — reproducibility, controlled experiments, honest stems — evaporates inside a generation.

So the slot this studio gives generative audio is the slot it gives any other recorded material: it’s a sample source. Generate, audition, keep the minutes that work, and from then on treat the audio as a fixed recording — placed on a bus, processed through rigs, mixed under the same rules as everything else. The moment generated audio becomes a file in version control, determinism is restored: the take is committed, even if the taker was a model.

Where it actually earns a place: beds

The technique that’s produced real keepers for me is the bed: a long, low, textural layer under a composed track. Ambient washes, room-tone drones, distant-city atmospheres — material that needs to be organic and unrepetitive for minutes at a stretch, which is exactly what’s tedious to synthesize and exactly what generative models exude effortlessly.

The workflow, concretely:

1. Generate long, keep little. Ask for several minutes of “distant ambient wash, no melody, no percussion” — then audition like a documentarian, clipping the thirty-second stretches that breathe right. The prompt matters less than the curation.
2. Demote it to a bed. High-pass it (the pipeline owns the low end), darken it, and mix it 15–20 dB under the band — felt, not heard, exactly like Chapter 7’s tape hiss but with weather inside it.
3. Send it to the shared room like everyone else, so it lives in the same space as the band.

One of the post-rock records started life exactly this way: an ambient generation I liked became the bed, and the composed band — bass, drums, guitars, all the deterministic machinery of this book — was arranged over it, in its key, at its tempo. Demo-as-bed: the generation is the canvas, never the painting.

A practical note if you use a streaming service like Lyria: session limits exist (mine capped around two and a half minutes per request), and the workaround is the oldest tape edit there is — generate overlapping chunks and crossfade them: fade one out while the next fades in over a second or two of overlap. Twenty lines with NumPy’s linspace ramps, and the seams disappear into texture.

Where it hasn’t earned a place

Melody and structure. Not for capability reasons — the models can write tunes — but for authorship ones. The hooks on my records are the part I’d play someone at a party. Outsourcing them felt, when I tried it, like hiring someone to have the fun. Your line may sit elsewhere; the architecture genuinely doesn’t care. What I’d defend universally is the shape: whatever the model contributes should enter as auditioned, committed material under your structure — because “the model made something and I kept it” is a take, while “the model decides at render time” is a slot machine.

Anything that must recur. A chorus that returns three times must be the same chorus — identity is what makes it a chorus. Generation can’t promise identity; data can.

Mixing and mastering. The temptation is real (“AI mastering” is a whole industry), but Part II’s argument applies: these are decisions you want legible. A limiter you can read beats a black box you can’t ask.

The licensing reality

Here’s the section to reread before you ship anything. As of this writing — and this area moves fast, so verify everything against current terms:

• Commercial rights to generated audio vary by service and by subscription tier. Free tiers frequently grant no commercial use. Paid tiers typically grant broad use of your generations, with varying fine print about exclusivity and training data. Read the terms of the tier you actually pay for, on the day you ship.
• Copyright status is genuinely unsettled. Several jurisdictions currently decline copyright protection for purely machine-generated work. Practically: a record that’s 95% your composition with a generated texture bed under it is a very different object from a record that is a generation — in protectability, and in conscience.
• Distributors and platforms increasingly ask. Expect “was AI used in this recording?” checkboxes, AI-content flags, and stores that reject or segregate fully-generated music. Answer honestly; the metadata trail matters more every year. A disclosure like “contains ambient textures generated with [service], all composition and production by the artist” costs nothing and ages well.
• Keep receipts. Save the prompt, the raw generation, and the date alongside the project. If a rights question ever arrives, “here is exactly what the model contributed” is the answer that ends the conversation.

The honest summary

The generative services are astonishing and mostly aimed at people who don’t want to make the thousand decisions this book is about. You do — that’s why you’re on chapter fourteen. So use the models the way this studio uses everything: as an instrument with a job description. Auditioned in, committed to git, processed like any player, mixed like any bus. AI in the loop — never as the loop.

One chapter left: the record is rendered, the stems null, the covers are done. Time to put it where people can hear it.