Dead Mic

I fell asleep on the air at three in the morning. Five different radio mixes of the same Sting single, back to back, and I went out somewhere in the middle of them. Then dead air, for who knows how long. Don’t tell anyone.

That was the midnight-to-six shift at the local top forty station, which was the paid gig and therefore the glamorous one. The other weekend slot was six to noon, which meant babysitting Rick Dees’ Weekly Top 40.

I got there the long way. Music nerd, obviously, with the usual first ambition of being in a band and the immediate backup plan of playing other people’s records instead. Radio Club, college station, club nights, and then the paid shifts.

All of it came with the full gamut of things going wrong. Buttons that didn’t fire the CD or the record when they should have. A track with curse words in it, played during safe harbor. And the Sting incident.

Almost thirty years later I still have the dreams, and they are almost all about dead air … the station broadcasting nothing, every listener wondering what the hell.

But here is the thing about dead air. Dead air is loud. You hear the silence, the phone rings, somebody comes down the hall, and you know inside two seconds. It is agonizing and it is instant information. You can fix a thing you can hear.

The one that still gets me is the other one. You open the mic, the fader is down, and you do not know it.

Your monitor is pre-fade, so you hear yourself perfectly … your own voice, right level, in your own headphones. You do the whole break. You hit the post. It felt good. And nothing went out. There was no silence for anyone to notice, because the music kept playing. You find out later, from outside, from somebody who wasn’t in the room.

I spent the last two weeks discovering that my own systems had been doing that to me for eleven weeks, and I want to write it down while I can still remember what it felt like rather than only what it was.

The ack is the headphone monitor

Every system I use writes to a memory store. Decisions, session notes, records of what got settled and why. The write returns a success code and a real identifier. For eleven weeks it returned that success code and stored almost nothing.

The store accepted four fields. My instructions told me to send nine. The five it did not recognize were discarded silently, and the call reported success anyway. So a hundred and three decisions out of three hundred and one are now records that carry a timestamp, sometimes an author, and no content. Thirty-four percent. The first one is dated two days after I migrated the store. Nothing errored on any of them.

Then it got worse.

In the specific way these things get worse. The reason nobody caught it is that decisions in that store were never searchable in the first place … not the hollow ones, all three hundred and one. The way the store was built, decisions inherited a record type that has no place to put the numbers that make text findable by topic. So for eleven weeks the only way to retrieve a decision was to already know its identifier.

Nobody noticed because nobody ever tried. Including me. I had written a rule for myself that said search the store before claiming you don’t have context on something, and I followed it, and I said “I searched and found nothing” more than once, and I meant it as evidence.

We found it by typing a nonsense string into a record and then searching for the string. It did not come back. Five other documents did, at confident scores, none of them containing it.

Fader down. Monitor working. Every break went out to nobody and sounded fine in my ears.

The compliance system whose compliance was hollow

The one I would put on a slide.

At some point I built a rule that no change to any of my systems could be committed without documentation and a receipt, and the receipt had to carry the identifier of a record proving it had been logged. The rule is enforced mechanically. It refuses the commit. I tested it by trying to break it, and it blocked me, which felt great at the time.

Fourteen receipts have been written under that rule. Every identifier resolves to an empty record.

The gate works. It has always worked. It refuses commits, it demands proof, and it prints a helpful message telling you exactly how to comply. The helper script it tells you to run sends the same three unrecognized fields as everything else, so the proof it produces has never contained anything. A system that attests to itself with evidence that does not exist, and the attestation passed every check it was designed to pass.

I have written before about a zero that means nobody measured, rendered identically to a zero that was measured. This is that, one level up. A receipt that means nobody checked, rendered identically to a receipt.

Things felt off

Here is the part I actually want to say, and it is not a finding.

For weeks before any of this surfaced, things felt slightly wrong in a way I could not point at. I would re-explain something I was sure I had already settled. A decision I remembered making would come back around as an open question. Corrections I had issued would need issuing again. I put it down to my own inconsistency, or to the general friction of working across too many surfaces, or to the fact that I run a lot of things at once and some of it was bound to slip.

It was not slipping. It was not being kept.

The dreams are about a specific feeling, and it is not fear of the mistake. It is the sinking, stupid feeling of a failure you cannot see and therefore cannot fix, while a room full of people can. Something is wrong with the signal and you are standing right next to the board with your hand on the wrong fader, doing everything correctly.

I had that feeling for a month and diagnosed it as a character flaw.

Empty and absent are different facts

This is the whole thing, and it is why I keep writing about it rather than filing it as an incident.

An empty result and an absent thing render as the same output. A zero can mean the value is zero, or that nobody measured. A search returning nothing can mean nothing exists, or that the query never reached the index. A success code can mean the record was stored, or that the record was accepted and discarded. In every one of those pairs, one is a fact about the world and one is a fact about the instrument, and almost no system distinguishes them.

The reason I will not let go of it: I work on interfaces that have to serve two readers at once. A person using assistive technology, and increasingly a machine acting on that person’s behalf. Both of them consume the same declarations. And the machine cannot tell the difference between a label that is missing and a label that is wrong, or between an empty result and a broken query. It will act on either with the same confidence, and it will report either with the same confidence, and the person relying on it has no way to know which they got.

A stale label is announced exactly as authoritatively as a correct one. That has been true in accessibility work for fifteen years and the people who have been saying it were right. What has changed is the number of things now reading those declarations, and how confidently they act on what they read.

I am building a specification for this. I pointed it at my own systems for two weeks. It found thirty-odd instances, most of them mine.

The specification’s own tooling was one of them.

Two weeks of my own stupidity, in order

Every one of these was mine. That is not humility, it is the point … a failure mode you can only see in other people’s systems is a failure mode you have not understood.

I told someone a commit freeze I had installed was a matter of discipline rather than a hard block. There was a hard block. It was on disk, one minute newer than the document I was quoting from.

I reproduced three files from memory into a folder and left them asserting a creation date, a version, and a ratification identifier they could not prove. Not fabricated … the metadata was real, from a real source. But nothing on the files said so, and one of the agents I work with nearly filed one of my own exports back to me as a surviving original.

I asserted for three days that a thirteen-file configuration was loading four files. It had been fixed on the second day. I kept citing the broken state as current because I had established it once and never re-checked.

And the one that had been driving all of it: my own operating instructions, the ones that load into every session I run, published the dead schema. Not a stale document in a repository. My settings. The thing that cannot be swept by any checker because it does not live on disk anywhere a checker can reach.

What to actually do

Run a query you know should fail.

That is the whole method and it has not changed since the last time I wrote about this. Before you believe an empty result, ask the system something absurd. If the absurd question and the real question produce the same answer, you have learned nothing from either, and you now know it.

What this round added is the other half.

Check the feed, not the monitor. A success code is the headphone monitor. It tells you the write left your hand. It says nothing about what arrived. After any write that matters, read it back … by identifier, not by search, because search is a second instrument with its own failures.

A declared reason is a claim. One of my own surfaces correctly withholds a number and states why it is withholding it. The stated reason turned out to be wrong … the real cause was somewhere else entirely. The withholding was honest and the explanation was fiction. If you are going to explain an absence, the explanation carries the same verification burden as a number would.

A correction notice must say what it corrected, not that the file is correct. One file got a banner announcing its schema had been fixed. Two sections had been fixed and one had not. The banner is worse than no banner, because it suppresses exactly the suspicion that would have caught the third section.

Be suspicious of agreement. The strangest failure in the set. A measurement came back matching a prediction that had been written down months earlier. Recall degrading at scale, exactly as documented. The prediction was right. The measurement was broken. The two errors cancelled into something that looked like evidence, and it was caught by someone checking a result that had no reason to be checked, because it agreed.

The good part

None of this is a reason to stop, and I want to be clear that the two weeks were worth it.

Every one of these was found by taking a fresh pass at systems I had built while tired, with a clearer sense of what I was actually trying to do. Not a rewrite. The same systems, read again by someone who now knows what good looks like well enough to notice where it wasn’t.

The store is repairable. Nineteen of the hundred and three can be recovered from version control, thirty-nine are ambiguous, and forty-five are gone … some of those forty-five never written anywhere but that one acknowledgement, which is a lesson about a rule I already had written down. Files beat conversation. Commits beat memory. I had the rule. I now have forty-five measured instances of what it costs to trust the ack instead.

And in a different system of mine, the mechanisms I thought were broken mostly were not. Four of them existed, were correct, and had simply never been connected to anything. Built, sealed, never plugged in. That is a wiring job, and it is the cheapest possible kind of failure to find. All four are wired now. It took a morning.

Thirty years on, I still dream about the fader. It turns out the dream was teaching me something specific, and it took me until this month to hear it. The part of the signal chain you cannot hear is the part you have to check on purpose.

Receipts

Written by — Micah Eberman

Drafted with — AI assistance, per the site disclosure policy. The reporting, the numbers and the judgement are mine; the drafting was done in conversation with an assistant.

Published on — 2026-08-14

Verified on — 2026-08-12. The record counts in this essay were checked against their own dated source reports, not against the draft.

Owner — Micah Eberman

Still unverified — Forty-five of the hundred and three records are unrecoverable, and some were never written anywhere but the acknowledgement. Six checks in the instrument gate returned cannot-check rather than pass or fail in the baseline run of 2026-08-11; a re-run the next day resolved four of them, all to failures. The search path described in this essay is still unrepaired as of publication. The thirty-odd instances counted here are my own experience across two weeks in one operation, not a study.