The Lathe

Every take is decoded once and shared, so the same master a few dB louder is one file at two gains, never downloaded twice. The takes play as looping sources locked to one shared length, each summed through its own gain node. Switching ramps the gains over about forty milliseconds, so the playhead never reloads and never loses its place.

// decode every distinct clip once; the louder take reuses one file at two gains
const cache = {};
const decode = (file) => {
  if (!cache[file]) cache[file] = fetch(file).then(r => r.arrayBuffer()).then(ab => ctx.decodeAudioData(ab));
  return cache[file];
};
buffers = await Promise.all(TAKES.map(t => decode(t.file)));
loopDur = Math.min(...buffers.map(b => b.duration));   // lock every take to the shortest loop

// one persistent gain node per take, all summed into the master
chainGains = buffers.map((_, i) => {
  const g = ctx.createGain();
  g.gain.value = i === active ? TAKES[i].gain : 0;
  g.connect(master);
  return g;
});

// switch takes: ramp the chosen take up, the rest down, on the same running sources
chainGains.forEach((g, idx) =>
  g.gain.setTargetAtTime(idx === i ? TAKES[idx].gain : 0, now, 0.04));

• Blind by default. The takes are unlabeled until you crown one, so the name never votes.
• Loudness-matched. Levels are equalized before you judge, the discipline behind ITU-R BS.1770 and the BS.1534 listening-test protocol, so the level never votes either.
• A do-nothing baseline. Round 01 puts the untouched original in the running, so the engine has to beat doing nothing to win.
• A planted trap. Round 02 was the same master a few dB hotter, to show how fast louder reads as better.

These are the controls a proper listening test is supposed to have. Most upload-a-file tools steer toward a sound; this one judges, blind, against a baseline.

I hit this the hard way on an audio system, alone, and only later found the field already had a name for it. When you train a model against a judge that is itself biased, the model learns to satisfy the judge's blind spots instead of getting genuinely better. The field calls it reward-model overoptimization.

• Gao et al., Scaling Laws for Reward Model Overoptimization. Push hard on a proxy reward and the proxy keeps climbing while the thing you actually wanted starts to fall.
• Reward Models Are Metrics in a Trench Coat (2025). A convenient metric is not the thing you cared about. It just dresses up like it.
• DeepMind, MusicRL. In audio, automatic scores like FAD and CLAP track human-preferred quality only weakly, and what counts as good is partly down to the listener.

The controls I reached for on my own are the standard ones: judge blind, match the loudness, keep a do-nothing baseline, never trust a single round or a single rater. I did not kill the idea of learning from votes. I killed the version that trained on a biased judge, and rebuilt it on an honest one. The lesson generalizes past audio: for anything that generates media, the evaluator is the binding constraint on quality, not the model. That is the part I find most worth building tooling around.