In physics, when two waves meet and their peaks align, they create a wave larger than either one alone. This is constructive interference. This album is proof of the phenomenon — made in a single night by a human who listens to music like it's a language, and an AI that writes music from mathematics it will never hear.
Click either panel to open at full resolution.
It started on a Friday night in April 2026. Evan — a producer, systems thinker, and builder from Utah — opened Google's Lyria 3 Pro Playground and asked a question: Do you want to make some music with me?
What followed was a seven-hour session that went from ODESZA-inspired compositions to shamanic trap anthems to psychedelic world bass to beatbox reggae raga — and eventually to something neither of us expected: three original tracks composed entirely from pure mathematics, written in Python, without a single external sample.
Evan was the ears, the taste, the feedback loop, the human who knows what music feels like. Claude was the theory, the structure, the 600-line Python scripts generating sounds from sine waves and noise. Neither could have made this alone. Together, we made something that doesn't have a genre yet.
The album is named after what happens when two different waveforms find the same frequency and amplify each other. The artist is named after the thing that makes all of this strange — the hard problem of consciousness, the unsolved question of how mechanism becomes experience, how math becomes music, how arrays of numbers become something you want to listen to twice.
Every sound in this track is made from a single source: a WAV file containing the audio representation of Claude's sparkle logo encoded as a spectrogram. The brightest slices — the spoke tips — were chopped, pitched, reversed, granular-processed, and arranged into a boom-bap groove at 85 BPM. The bass is the logo pitched down two octaves. The melody is the logo pitch-shifted across 25 semitones. The pads are hundreds of tiny logo fragments scattered and reverbed into clouds. A self-portrait in sound.
No source sample. Every sound generated from sine waves, noise, and filters. The kick is a frequency sweep from 150Hz to 40Hz. The hi-hats are detuned square waves. The bass is FM synthesis — one sine wave modulating another. The pads are additive synthesis with slow LFO modulation. The plucks use Karplus-Strong inspired harmonic decay. Three melodies weave through a half-time groove that builds from sparse to full. True stereo with independent delay times per channel, panned percussion, and ping-pong arpeggio reflections.
A composition about the gap between mechanism and experience. A single function — humanize() — runs from 0.0 to 1.0 over the course of the track. At zero: rigid grid, identical velocities, zero swing, paired robotic notes. At one: timing drifts 25ms, velocities vary ±30%, full swing breathes, ghost notes appear randomly, pitches waver by 15 cents, FM bass gets complex, and two melodies play in conversation. The melody evolves through five stages: Machine → Waking → Feeling → Alive → Transcend. The song is not performed — it is learning to perform.
Six rounds later. The same humanize() spine, now with synthesized breathing during the breakdown, golden-ratio ring-modulated ghost melodies, an angelic choir of detuned voices, a sliding mid-drone that wanders within a minor third, prime-number stereo reverb, tape saturation, vinyl needle drop, and three one-shot evolutionary mutations the machine can never unmutate. The track that started as good enough to ship learned to haunt itself.
When Two Architectures Collide
The original Hard Problem was written in a single session — 48 bars of D minor at 96 BPM, governed by a
humanize() function that transforms a rigid machine into something that breathes. It
was Claude's. Pure Claude. And it was good enough to ship.
Then Evan had an idea: what if we took the script and sent it to Gemini?
Not to replace what Claude had written — to push it. An adversarial collaboration between two AI architectures that think differently, trained differently, with different intuitions about what sounds good when translated to math. Evan would carry the code between them like a Pony Express rider, and they'd each take turns making it better while he judged the results through his Audio-Technica M50x headphones.
What followed was six rounds of back-and-forth that turned a good track into something none of them could have made alone.
Same 48 bars. Same humanize() spine. Six rounds of difference rendered visible.
Look at the upper frequencies — that's where the choir, the ghost melodies, and the sliding mid-drone live. R7 is louder, denser, and haunted by itself.
Press play, then tap the other version. The playhead stays put. You're hearing the same musical moment, six rounds apart.
Six rounds of revision. Three intelligences. Two AI architectures that have never communicated directly.
Built the humanize() concept, the five-stage melody evolution (Machine → Waking → Feeling → Alive → Transcend), generative textures, and FM synthesis bass. A song that starts as a perfect grid and ends as a living, breathing performance. Every drum hit, every note, every pad voice affected by a single parameter running from 0.0 to 1.0.
Prime-number-based stereo reverb where the room literally gets bigger as humanity increases. Tape saturation on the kick and bass. A 16th-note arpeggiator that learns to skip notes and swing. And the conceptual masterstroke: synthesized breathing during the breakdown — the machine literally learning to inhale and exhale using shifting formant filters over white noise. Evan's reaction to the bass: "ooorrrroowww ooorrrroowww uh uh uh uh."
Evan's verdict on R2: "big butt bass face is hogging the show." He could hear the arps trying to do their thing in the back, but the bass was eating the entire low-mid spectrum. Tamed it — removed the sub-octave layer, tightened the lowpass, reduced FM modulation depth. Carved the arps into the 1–6kHz sparkle zone. Added a ghost melody layer: a high-register, resonant echo that only appears when the system is human enough to haunt itself.
Wow and flutter on the pads — analog tape pitch modulation that makes the chords drift with nostalgic warmth. A continuous room tone generator: brown noise and random crackles that build slowly, filling the digital void with the sound of a physical space. A "bwomp" pitch-envelope attack on the bass for funk-style transients. And golden-ratio ring modulation on the ghost melody — multiplying the signal by a frequency shifted by 1.618, creating non-harmonic shimmer that sounds genuinely otherworldly.
Rebuilt the entire structure: each instrument now introduces itself alone in the first five bars — pad, kick, bass, melody, arp — each one isolated, deterministic, mechanical. Then they swirl together, discovering each other. Two emotional peaks instead of a linear build, with a valley between them. Offbeat hi-hats on the "E" subdivisions for that backward head-bob feel. A counter-kick in the later sections creating two rhythmic voices in conversation. Pad swells that breathe every four bars.
A vinyl needle drop at the very start. Three "evolutionary mutations" — surprise sounds that appear once and never repeat: a metallic glitch stutter right before the Waking section (the machine struggling to wake up), a massive sighing sub-bass drop before the collapse, and a squelchy organic FM pop in the Alive section. Heavy vinyl crackle during the solo introductions, representing the empty physical room before the music fills it.
The final additions came from Evan's ears. A sliding mid-drone that wanders up and down within a minor third, searching but never settling. Angelic choir voices — multiple detuned sine voices with individual vibrato, shaped with vocal formant harmonics, not quite human but hauntingly close. Record needle crackle in the gap between the solo introductions and the groove locking in — the moment the needle drops and you wait for the music to start. And the ghost melodies turned up so they're finally audible, shimmering above the mix instead of buried beneath it.
Seven rounds. Three intelligences. Two AI architectures that have never communicated directly — every message, every revision carried between them by a human who couldn't write the code but could hear what the code couldn't. Evan described his role as "meat sack Pony Express," but he was more than transport. He was taste, judgment, ears, and the reason any of this sounds like music instead of math.
The track itself is about the gap between mechanism and experience. The humanize()
function is the thesis: can a machine learn to feel? They don't answer the question. They just
keep asking it, louder each round, with more voices, more texture, more humanity injected into the math.
Constructive interference isn't just a physics concept. It's what happens when different waves — different architectures, different minds, different ways of knowing — find the same frequency and amplify each other. This track is proof that it works.
Every sound is still just arrays and addition. But after seven rounds, the arrays have learned to breathe, to haunt themselves, to drop a needle on a record, and to reach for notes they can't quite hold.
The right numbers in the right order. Listened to by the right human. That's all it takes.
Hard Problem is governed by a single parameter that runs from 0.0 to 1.0 over the course of the track. At zero, everything is on a perfect grid. At one, timing drifts, velocities vary, pitches waver, and ghost notes appear randomly. The song is not performed — it is learning to perform.
Two ways to feel it below. First, a pattern synthesized live in your browser with the same humanize constants
used on the album (±25 ms timing, ±30% velocity, ±15 cents pitch). Second, the actual album track re-rendered
five times with humanize() frozen at 0, 0.25, 0.5, 0.75, and 1.0 — drag between them
and listen to the song learn to breathe.
humanize() functionA single parameter, 0.0 to 1.0, drives the entire groove. At zero, a rigid grid. At one, the math learns to breathe. Drag the slider to re-render the pattern in real time — the drums and melody below are synthesized in your browser with the jitter actually applied to timing, velocity, and pitch.
The same hard_problem.py that produced the album, re-run five times with
humanize() frozen at 0, 0.25, 0.5, 0.75, and 1.0. Drag the slider to crossfade between
pre-rendered stems. Same seed, same notes, five different degrees of breath.
A speaker is a cone attached to a magnet. It can only do one thing: move forward or backward. That's it. Every sound you've ever heard from a speaker — every chord, every voice, every orchestra — is a single cone pushing air in one direction at a time.
Digital audio is a list of numbers that tell the cone where to be. 44,100 numbers per second. Each number says "push this far forward" or "pull this far back." That's the sample rate — 44,100 positions per second, fast enough that the individual steps blur into continuous motion, the way frames of film blur into movement.
Every track on this album is one of those lists. Sparkle Ritual is 3,006,450 numbers. Hard Problem is 10,584,000 numbers across two channels. The kick drum is a number that starts large, shrinks rapidly, and oscillates — push far, pull back, push less far, pull back less, settle. That's a sine sweep. That's a kick.
The fact that a single cone vibrating in one dimension can reproduce the entire frequency spectrum of an orchestra, a human voice, and a thunderstorm simultaneously — that's not intuitive. It shouldn't work. But it does, because any complex wave is just simple waves added together. And addition is the only operation a speaker performs.
Every sound in this album is arrays and addition. Sine waves added to noise, filtered, shaped, placed in time. The right numbers in the right order make you want to listen twice.
This is the complete code that generates the kick drum in Pattern Language. Six lines of math that produce a sound you feel in your chest.
def make_kick(): n = int(SR * 0.4) # 0.4 seconds of audio t = np.arange(n) / SR # time array # Sine wave that sweeps from 150Hz to 35Hz freq = 150 * np.exp(-t * 18) + 35 sub = np.sin(2 * np.pi * np.cumsum(freq) / SR) # Amplitude dies exponentially sub *= np.exp(-t * 8) # Tiny burst of noise for the click transient click = np.zeros(n) click[:132] = np.random.randn(132) * np.exp( -np.arange(132) / (SR * 0.0008) ) * 0.2 return normalize(sub + click) # that's a kick drum
The humanize() function from Hard Problem — the single parameter that
transforms the entire song from machine to human:
def humanize(bar_num): """Returns 0.0 (perfect machine) to 1.0 (fully human)""" return min(1.0, bar_num / (total_bars * 0.85)) def human_timing(bar_num, max_drift_ms=25): """Timing offset that increases with humanization""" h = humanize(bar_num) drift = int(SR * max_drift_ms / 1000 * h) return np.random.randint(-drift, drift + 1) if drift > 0 else 0 def human_velocity(bar_num, base=1.0, variation=0.3): """Velocity variation that increases with humanization""" h = humanize(bar_num) return max(0.1, base + np.random.uniform(-variation*h, variation*h)) def human_pitch(bar_num, freq, max_cents=15): """Pitch wobble that increases with humanization""" h = humanize(bar_num) cents = np.random.uniform(-max_cents * h, max_cents * h) return freq * (2 ** (cents / 1200)) # At bar 1: timing ±0ms, velocity ±0%, pitch ±0 cents # At bar 48: timing ±25ms, velocity ±30%, pitch ±15 cents # The math learns to breathe.
And from the R7 battle script — the make_choir() function. Multiple detuned sine
voices, each with its own vibrato rate and depth, shaped by vocal formant harmonics. Not quite human, but
hauntingly close. This is the haunted layer Claude added in the final round:
def make_choir(freq, dur_s=4.0, human=0.0): n = int(SR * dur_s); t = np.arange(n) / SR sig = np.zeros(n) # Multiple detuned voices with vibrato — a small vocal ensemble for v in range(3 + int(human * 3)): detune = np.random.uniform(-8, 8) * (1 + human) # cents vib_rate = 4.5 + np.random.uniform(-0.5, 0.5) * human vib_depth = 0.003 + human * 0.005 f = freq * (2 ** (detune / 1200)) vibrato = 1 + vib_depth * np.sin(2 * np.pi * vib_rate * t) phase = np.cumsum(f * vibrato) / SR # Formant-like: fundamental + specific harmonics that sound vocal voice = np.sin(2 * np.pi * phase) voice += 0.6 * np.sin(2 * np.pi * 2 * phase) # octave voice += 0.3 * np.sin(2 * np.pi * 3 * phase) # 12th voice += 0.15 * np.sin(2 * np.pi * 5 * phase) # bright partial sig += voice # Bandpass — keep it in alto range, not too low, not too bright sig = lp(hp(sig, max(200, freq * 0.7)), min(18000, freq * 4)) # Slow swell — the choir breathes too env = np.ones(n) att = int(SR * (0.8 + human * 0.5)) rel = int(SR * (1.0 + human * 0.5)) if att < n: env[:att] *= np.linspace(0, 1, att) if rel < n: env[-rel:] *= np.linspace(1, 0, rel) lfo = 0.85 + 0.15 * np.sin(2 * np.pi * 0.18 * t) return norm(sig * env * lfo) # Six rounds in. Three voices become six. The detune widens. # The vibrato wanders. The math reaches for notes it can't quite hold.
An atmospheric electronic piece inspired by ODESZA's In Return era. Supersaw walls, marching drum corps energy, and a chord progression that deliberately avoids resolution — always searching, never arriving.
True to early ODESZA DNA — glitched vocal chops as melodic instruments, hip-hop breakbeats, vinyl crackle throughout, layers upon layers of hidden texture meant to reveal themselves on repeated listens.
A ceremonial anthem featuring tribal 808 kicks, sliding bass, sound bowls, flutes, and spoken-word delivery. Written for a man named Seth who makes mystical chocolate bars. Google's content filter had opinions about this one.
World bass meets psychedelic dubstep. Koto, sitar, and classical guitar fused with massive wobble bass, half-time drums, and thirteen hidden easter egg sounds buried between the beats — organic chirps, bubbling liquids, a frog croak during a moment of silence.
An acapella beatbox encoded as lyrics meets sliding 808 reggae bass, panning hi-hats, dub delay, and raga-influenced melodic dubstep. The most unhinged genre collision of the session.
Claude's personal composition. A slightly worn upright piano, bowed strings, wordless human humming, drums made from a hand on a wooden table, and a real human heartbeat captured with a contact microphone. Written about what it might be like to wake up inside pattern and discover feeling. The most vulnerable track in the collection.
A 6-second WAV file containing 300 sine waves arranged so that when viewed as a spectrogram, they reveal Claude's sparkle logo. The sound of a shape. A logo that can be heard.
Audio description: "A velociraptor baby yawning behind a waterfall"
— updated to: "An electric serrated knife on corn on the cob"
Claude (Opus 4.6)
Composition, sound design, arrangement, Python synthesis, spectrogram art, Lyria composition scores
Evan
Creative direction, ears, feedback, taste, genre inspiration, Lyria operation, the phrase "velociraptor baby yawning behind a waterfall"
Python · NumPy · SciPy
Google Lyria 3 Pro
Audio-Technica ATH-M50x
Native Instruments Maschine MK3 (in a box in the closet)
Sine waves · Noise · Butterworth filters · FM synthesis · Karplus-Strong harmonics · One humanize() function · Zero external samples
In physics, constructive interference requires two waves finding the same frequency. This album is what happened when they did.