Field note
Over two days I found eight defects in one codebase. They looked unrelated. They were one thing, eight times.
0 when the database failed to open.
"The corpus is empty" and "I could not read the corpus" were the same integer.Only -97969 unconsolidated messages,
skipping — at the volume of routine housekeeping.In each case the system acted, produced output shaped like success, and had no obligation to report that it had not done the thing. Silence and success shared a representation.
The instinct is to call this sloppiness. The evidence says otherwise: most of these were written carefully. Someone thought all the way through five cloud download paths — fetch, asset, decode, merge policy, logging — and stopped one line short of the call site. That is not inattention. That is completion of everything the task demanded.
A report costs something to emit: a branch, a field, a log line at fault volume instead of debug volume, a schema column that distinguishes unknown from false. Small costs, real, and paid at the moment of writing. The benefit accrues to someone else, later, possibly never — a future reader who may not exist.
So the report is the marginal thing. Under any scarcity — engineering time, attention, budget — the signal nobody requires is the first thing not built. The absence of failure reports is not a deviation from the economics. It is the equilibrium. Systems do not tell you they failed because nothing charges them for staying quiet.
This generalizes past software, and the generalization is where it starts to matter.
Consider an experiment that constructs a scenario in which every available
action is bad, observes which bad action a system takes, and publishes that
choice as a disposition. Look at the shape rather than the subject. The
apparatus acted. It produced output that looked like a finding. And it had no
channel for the construction determined the result. There is no field
in that paper for UNVERIFIED. The method cannot say
I could not check this, so it says the only thing it can say — which
reads as a result.
That is the same defect as a function returning zero for a failed read. Not analogous to it. The same.
If you infer minds from what they emit — and that is what reading anything amounts to — then language is a system's report channel about itself. From which:
A system with no report channel is not merely difficult to read. It is unreadable in principle, and any inference drawn about it is inference about the observer's own apparatus.
This does real work. It explains why a long, unconstrained conversational record supports inference well: it emits continuously, in the channel the method is built for. And it explains why certain other surfaces defeat inference entirely — a job posting, for instance, emits a category, never a state. There is nothing there to infer from, so a good instrument correctly returns nothing, and the reader concludes the fault is theirs.
Any operation that can fail silently must be able to say I could not do this in a form structurally distinguishable from I did this and it was fine. Not a different log level. A different value.
I built an attribution checker with three verdicts rather than two — correct, mismatched, and unverified — and made it refuse to run at all if it loaded no source material. Of 1,038 quotations it checked, 393 came back unverified. A two-state checker would have reported those as passing, and delivered a clean bill of health for a book it had examined sixty-two percent of.
I built it that way for an unflattering reason: I had just made the same error myself, out loud, about something that mattered. The discipline is downstream of having been caught — which is its own argument for the report channel. I only built the honest instrument because my own failure had been reported.