Debugging without ears

Part 1 ended with a mystery: this blog’s read-aloud voice suddenly produced loud white noise, right in the middle of the text. Here one time, there the next, never in the same place. No error in any log, every line green.

What made this case special: the bug was exclusively audible. And the investigator — the AI agent that built the entire narration pipeline — has no ears. It can open an audio file, but it cannot listen to one. To the agent, it is a long sequence of numbers.

What happened next is perhaps the most instructive story of this whole rebuild.

Step 1: If you can’t hear, measure

The agent did what a good engineer without a sense organ does: it built itself a measuring instrument. In the numbers, white noise looks different from speech — it is uniformly loud across all frequencies, while speech has structure, peaks and valleys.

So it sliced the audio file into windows of a tenth of a second and computed two values for each: the energy (how loud?) and the spectral flatness (how structureless?). Together they make a serviceable noise detector: loud and flat — that is no speech sound anymore.

With that, the invisible had coordinates. “There’s noise somewhere” became: from second 214.3 to 219.1, and again from 305.8. Reproducible. Measurable. The first crack in the case.

Step 2: Borrowing ears

For the second look, the agent borrowed ears: a speech recognizer (Whisper, running locally, of course). It translates audio back into text — and along the way delivers a timestamp and a confidence score for every word, a measure of “how sure am I that I understood this”.

Laid over the noisy sections, a precise picture emerged: before the measured noise zone, confidence is high; inside it, confidence collapses; after it, confidence recovers abruptly. Not gradually — abruptly. The noise began and ended at exact cut edges.

And cut edges existed in exactly one kind of place in the system: at the pauses. Where the script inserts artificial silence between sentences and paragraphs.

Step 3: The culprit is an odd byte

Now it was manual work. The agent read up on how the narration tool generates pauses, and found the spot: the silence was written into the data stream as a number of bytes — computed as sample rate times seconds times two, because each audio sample occupies two bytes.

Let’s do the math: 22,050 samples per second, a 0.7-second pause — that should give 15,435 samples, or 30,870 bytes. But computers do not represent 0.7 exactly: the product lands a hair below 30,870, and the formula truncates the decimals instead of rounding. Result: 30,869 bytes. An odd number.

One byte too many or too few, so what? Everything. Because each sample consists of two bytes that belong together like the halves of a zipper. Shift the stream by a single byte, and from then on the player reads the second half of every sample as the first half of the next. Every sample becomes a random number. And a stream of random numbers is, by definition, white noise.

Until the next odd pause — which shifts the zipper back into alignment, and the voice returns as if nothing had happened. That is why the noise came and went. That is why it was never in the same place. That is why there was no error in the log: from the program’s point of view, every byte was written correctly.

A single odd byte, somewhere in a pause. That was the whole case.

The fix and the safeguard

After that, the repair was almost trivial: the script bypasses the tool’s faulty pause logic and builds silence itself — always from whole samples, never from half ones. Plus a guard: after every generation run, the noise detector from step 1 runs automatically. No audio leaves the pipeline that is loud and structureless at the same time.

Since then: silence where silence belongs.

Why this story is here

Not because of the byte. Because of the method: an agent faced a problem for which it literally lacked the sense organ — and built itself the organ out of tools. First a measuring instrument, then a borrowed ear, then the proof.

That is exactly the skill that counts when an agent walks into a company and meets the system nobody can explain anymore: no documentation, no one to ask, only behaviour. You cannot know everything. But you can work out almost anything, if you measure instead of guessing.

And the honest limit to close on: the repaired voice reads cleanly, but it reads like a newsreader, not like a storyteller. Real narrative prosody — tension, pacing, timbre — is beyond this class of model. Maybe that becomes a part 3 with a different engine. For now: the blog reads itself aloud again, error-free.

Listen for yourself — the play button above uses the repaired voice. If there is noise anywhere, this time the author put it there on purpose.