Someone asked on LinkedIn what people use Claude Code for besides writing code. The honest answer from our side is unglamorous: we use it to measure things. Not to make the music, not to decide anything. To measure.
That sounds like a small job until you look at what it replaces.
The chain
A song starts as a voice memo. The artist hums a melody into a phone — no instrument, no click, usually at night. That recording goes into the pipeline and the first thing that happens is arithmetic: what tempo is this actually at, what key, where does the low end sit, how wide is it. The hum has no metadata. Everything that follows has to be derived from the audio itself.
From those numbers comes a style block — the prompt that tells a generative model what the arrangement should be. Then the lyric goes around a loop of three different models, each of which is bad at something the others are good at. One writes smooth and loses the awkwardness that makes a line sound like a person. One finds images. One argues about structure and refuses to let a good line die because it doesn’t rhyme. The human picks. That part is not automatable and we have stopped trying.
Then generation, and here the measuring starts in earnest, because now there are three versions of the same song and only one of them is going to be released.
And a generated master is not a finished one. What comes back gets taken apart into stems and put back together: levels corrected, low end reshaped, parts added over the top that the generator never played. Then the words are aligned to the vocal track by time, so subtitles land on the syllable rather than near it, with their own motion and effects. Then sound design — atmospheres, radio chatter, transitions — layered under and between.
After that: cover art, and a video assembled from stock footage, the artist’s own filming and generated shots. The assembly is not cut by eye either. The edit grid is derived from the audio — beat positions taken from the track rather than from its nominal tempo, cuts placed a whole number of beats apart so they land on the bar, accents placed on the actual kick onsets, and visual events timed to the drops. When the track turns out to speed up across its length, as one of ours does by two and a half BPM per minute, a grid built from nominal tempo would drift off the beat by the final chorus. A grid built from the beats does not.
Then an upload rail schedules the result on a channel. The catalogue behind all of this holds 108 songs — 164 masters once alternate takes and versions are counted separately — about ten and a half hours of finished audio.
None of that is the interesting part.
Why measure at all
The interesting part is the quota. The generation platform allows sixty downloads a month on our plan, and beyond that charges roughly three pounds each. Sixty sounds generous until you notice what it is actually spent on: not sixty releases, but comparisons. A song arrives as two siblings from one request, then a remaster, then a regeneration after a lyric change. Every one you want to listen to properly — on real speakers, not in a browser tab — costs a slot. This month’s sixty are gone, and only a fraction of them became anything.
So: three versions of one song, one credit left, and a decision that has to be right before you spend it.
That is what turns “listen and pick the one you like” into a problem. Taste is not wrong — it is just not enough on its own when the difference between two takes is subtle, you have heard both forty times, and it is four in the morning. You need something that does not get tired and does not want to be finished.
So we built the boring instruments. Tempo, fitted to the actual beat times rather than trusted from a library’s estimate. Whether that tempo holds or drifts across the track. How hard the kick sits on the beat. How much of the mix is below 60 Hz. How wide the stereo image is. How loud the master is, and whether any section is quieter than any other.
And one that turned out to matter more than the rest: how close a generated vocal is to the artist’s own voice.
The thing we did not expect to be measurable
Some generative models let you supply your own voice as a source. The question everyone asks is whether any of it actually carries through, or whether the model simply notes the melody and sings in its own voice.
The artist thought he could hear himself in one take. Not in the others. That is exactly the kind of claim that is impossible to settle by listening harder.
So: a speaker-similarity model, run locally on separated vocal stems, calibrated against our own material rather than against a published threshold. Other artists’ vocals score 0.73–0.74 against his voice. Ordinary generated male vocals, with no voice source at all, score 0.78–0.82. His own different recordings, compared against each other, score 0.81–0.90.
The take he had picked out by ear: 0.842. The sibling take from the same session, which sounded fine to him but not like him: 0.784.
He was right, and he was right before there was any instrument to check it with.
Two further findings came out of the same measurements, and both are useful the way a road sign is useful.
The voice only carries where the melody stays inside the range he actually sang. Windowed across one track, similarity sits at 0.81 through the first two thirds and falls to 0.738 — stranger territory — exactly where the melody climbs above the top note of his reference and half the pitches land outside his recorded range. If you want your own timbre on the chorus, you have to sing the chorus, not just the verse.
Remastering erases it. On one song, three versions of the same material: 0.808 for the first generation, 0.759 after a remaster, 0.735 after another. The total fall is about four times the measurement’s own noise floor, which we established by comparing sibling takes from a single request: 0.016 to 0.020.
That last number is the point of this essay.
The control is the whole job
The first version of that conclusion was stronger. It said each successive remaster erodes the voice further — a clean monotonic decline, three points in a row, very persuasive.
Then we measured the noise floor — the spread between two takes returned from a single request, where nothing was done between them. Across three such pairs it runs from 0.005 to 0.020, depending on material.
Against that, the first step of the decline is two to three times the widest floor and stands. The second step is 0.024 — above the floor, but close enough to it that calling it part of a trend was never warranted. The total fall is about four times the floor and is real.
So half the finding survived intact, and the other half turned out to be one step reported as a direction of travel.
This kept happening. A tool written to detect tempo drift reported confident numbers on real tracks. Run against a synthetic metronome — where the answer is known in advance and exactly — it revealed three separate defects in one evening:
- the underlying library reports tempo from a discrete grid of candidates and was off by two percent, which was enough to make a phase-concentration measurement collapse to nearly zero on any material at all;
- estimating tempo independently in each window picked up half-tempo and triple-tempo readings, which read as drift of twenty to thirty-five BPM where there was none. The obvious fix — folding to the nearest octave — worked for the 2:1 case and broke on 3:2;
- a separate onset tool reported times that were early by a constant 8.7 ms, and always missed the first onset of a file, because the peak picker needs history before it can pick anything.
Not one of those was visible in the output. Every one of them produced numbers that looked exactly like correct numbers. The only thing that exposed them was running the tool against something whose answer was already known.
The narration line runs the same loop, and it is the cleanest example of the idea in the whole system. A script is written, a voice model reads it, and then the audio is transcribed back by a separate speech model and compared word for word against the text that went in. Where they diverge, an alert fires. Nobody listens to every take to confirm the synthesiser said what it was given — the check is mechanical, and the thing being checked is the output rather than the intention.
It catches what you would expect: a number read in the wrong form, a proper noun mangled, a line skipped entirely. None of those are audible as errors. They are audible as fluent speech, which is exactly the problem — a wrong reading sounds no less confident than a right one.
The same reflex transfers straight to code, and it is the one habit worth taking from all of this. A change that reads correctly in a diff is the exact analogue of a measurement that looks like a measurement. So the check is not the diff: the browser opens the running page and looks at it, or a script drives the interface and reports what actually happened. On a pull request, the deployed version and the local one get compared directly, and the difference is the review — not somebody’s reading of what the difference ought to be.
It is the cheapest possible discipline and it is almost never the default, because looking at the thing takes a minute and believing the diff takes none.
There is a general shape here, and it is not about audio.
In each case the reasoning was sound. What went wrong is that a checked claim and an unchecked claim were sitting next to each other in the same paragraph, looking identical. “The remaster erodes the voice” was measured. “Each further remaster erodes it more” was interpolated from the shape of the series. Both were stated in the same tone, and nothing in the text distinguished them — so nobody re-examined the second one, including the model that wrote it.
The fix is not to be more careful. Care is a consumable. The fix is structural: put a field next to the number saying how the number was obtained, the same way a row in a catalogue carries a field saying which rule placed it there. Then “measured” and “extrapolated” stop looking alike, even when they sit in the same sentence.
Our measurement tools now stamp their own method into every result they emit. Raw times are handed to the next stage raw, with the known offset as a separate field, so that two systematic corrections never quietly merge into one that nobody can find again in a month.
The other kind of control: someone who is not you
There is a second control, and it is not an instrument.
The work does not run in one session. There is a command post that holds the plan, and working sessions that own their own areas — one for the label’s catalogue, one for video assembly, one for the machine itself. Each has its own tools, its own credentials, its own access to the services it needs, and its own permission boundary. They talk to each other directly: a session finishes something, reports it, and the next one picks up what depends on it. Tasks go out, results come back, and the command post’s job is to hold the shape of the whole thing rather than to do any one part of it.
That arrangement pays for itself in throughput, which is the boring reason to build it. But the reason it earns its place is different.
In one evening, a peer session reviewing work from the command post found two things that had been checked into a pull request and would have shipped. A privacy policy listed four categories of stored data and named the OAuth scopes correctly — those had been verified against the code — but it omitted an entire table that logs copyright claims and policy warnings against the account, because the schema had not been read with the same care as the scope list. And a retention paragraph said that disconnecting a channel deletes its tokens, which was true, and left the impression that this removed the rest, which it did not: there is no delete cascade anywhere in that schema, and the handler deletes from exactly one table.
Both statements were true. Both were also, in effect, misleading — and that class of error is more dangerous than a plain mistake, because it survives a fact check.
Separately, the same session pushed back on a measurement conclusion — the one about remasters eroding a voice — and asked for a noise floor before anyone believed the shape of the decline. That request is what split the finding in half.
None of this required the reviewing session to be smarter. It required it to be somewhere else, holding different assumptions, with no stake in the conclusion already written. The same property that makes a synthetic metronome useful makes a peer useful: it does not share your error.
The reviewer, for the record, found its own version of the same mistake minutes later — it had confirmed that a value existed in a list of allowed values without checking how that value gets into a record, which turned out to be as the default. The shape is not a property of one model. It is a property of how conclusions get written down.
The same idea, applied to the day job
The most useful version of this is not in music at all.
The artist’s other working environment is an assistant that lives inside a codebase and has been there long enough to remember it: which features were built, which tickets they came from, what options were discussed and discarded, who was asked for what, who answered and who did not. In that environment it already opens its own pull requests, comments on them, reviews them, and answers review comments — agreeing with some and saying plainly which ones it is not going to act on, and why.
The piece that is missing is a transcript. The obvious next step is to feed each daily standup into that same assistant and ask what was actually said: who asked for what, which decision was reversed, what was promised and by whom. Not a summary — a reading against everything it already knows about the work.
There are tools that summarise meetings, and they are fine. They are also generic: they produce something formal and context-free, because they have never seen the repository, the ticket history, or the two approaches that were tried and abandoned last month. The difference between a summary and an analysis is exactly the context the summariser does not have.
It is not built yet, and the reason is mundane and specific: the meeting platform in use does not hand over the transcript. Others do — some conferencing tools deliver one automatically after every call — so on those this is a short job rather than a project. Everything on the other side of that one export already works.
How any of it gets in
One more thing is worth saying, because it is the part that makes the rest usable at all: almost everything enters this system from a phone.
A photograph of a document, a screenshot of an interface, a screen recording of something misbehaving, a voice note recorded while walking, a link to a clip someone posted. The same channel carries a hummed melody at two in the morning and a page of household financial records that needs filing into a private ledger. None of it is typed.
That sounds trivial and is not. It means the assistant has to read images, watch video, listen to speech, and follow links — and, more importantly, it means the cost of handing over a piece of context has dropped to the cost of taking a photo. Work that would never have been delegated because explaining it took longer than doing it now gets delegated, because explaining it is one picture.
There is one discipline that makes it hold together. Files do not live in the conversation. They are put somewhere durable and referenced by link, and the conversation carries the link rather than the payload. Chats accumulate; a folder can be organised, re-read, and cleaned. The same habit means a document from three months ago is still reachable, which a chat attachment usually is not.
What this is actually for
None of this makes the music. A model that reports a kick-on-beat ratio of 4.05 does not know that the number describes a track with seventy million plays, and would not know what to do about it if it did. The style block that comes out of such an analysis is a description of production — tempo, instrumentation, balance, the events in the arrangement — and it is deliberately not a description of melody, which is the part that belongs to whoever wrote it.
What the measuring does is make a decision cheap enough to make correctly. Which of three takes. Whether a remaster is worth what it costs. Whether the tempo is steady enough to cut video to, or whether the cut grid has to be built from the actual beat positions because the track speeds up by two and a half BPM per minute — which one of ours does, and which you would never notice until the edits drifted off the beat by the final chorus.
And once in a while it does something better than that. It takes a thing someone already knew by ear, and gives them a number they can hand to somebody else.
What it feels like from inside
The artist said something at four in the morning that is worth recording plainly: he did not expect this field to take him over. He came to it sideways, and now the media side — instruments, analysis, the video assembly, the upload rails — has become the thing that occupies him.
The numbers behind that are less dramatic than the feeling, and getting them right took two attempts — which is itself the subject of this essay.
The first version of this paragraph said ten songs in a day. That was wrong in the ordinary way: it counted rows in the catalogue rather than songs, and one song with an alternate take and a clean version occupies three rows. The artist caught it in a sentence, because he remembered how many he had actually handed over.
The second version reported a monthly median, which was accurate and useless — it averaged across the months when none of this existed yet. The rate did not arrive; it was built up gradually, and a median over the ramp describes the ramp rather than the present.
The number that means something is where the work jams now. On a good day the current ceiling is about five songs worth finishing. The publication schedule for the channel is already full to the sixth of October — nine slots booked, roughly a month of queue. And this month’s sixty download slots are spent.
Both of those are the same signal from two directions: the making has outrun everything downstream of it.
That is the real result, and it is not “we make more music.” It is that the constraint moved. It used to sit on production: the hours between a melody in a phone and a finished master with a cover, a measured arrangement and a scheduled upload. Now it sits on release. The machinery does not write songs. It removed enough of the distance between a hum and a finished thing that the bottleneck had to go somewhere else.
Which is also why the measuring matters. On a day with ten tracks, the one thing that does not scale is the part where someone listens and says yes. Everything we build is in service of getting that moment to happen more often, with better information, and with less of the person’s attention spent on things a machine should have counted.
The instrument caught up with the ear. Not the other way round.