Every society runs on code. Not software — something older, deeper, more entangled. Norms. Hierarchies. Unspoken rules. Structural biases compiled into culture over centuries. This is the debugger's console. We read the stack traces of human systems.
Systems that claim equal opportunity while producing predictable inequality are not broken — they are functioning as designed. The bug is not in the output. The bug is in the specification.
Reproduction steps: Build a system. Declare it fair. Measure outcomes. Observe statistical clustering along pre-existing power lines. File as "working as intended."
Social norms are compiled once, cached forever, and never re-validated. What was "normal" in one context becomes an unquestioned constant in every context. The normalcy compiler has no garbage collection — obsolete norms persist indefinitely, consuming resources.
Every generation inherits the compiled binaries of the previous one. Source code lost. Documentation missing. Nobody remembers why things are the way they are.
Human empathy has a fixed buffer size. Exceed it and the system crashes to apathy. Media architectures routinely overflow this buffer by design — not as a bug, but as a feature that produces compliant users.
The patch exists. It has existed for decades. It sits in the queue, marked "won't fix" by stakeholders who benefit from the overflow condition.
Multiple threads of identity — race, class, gender, geography — compete for the same shared resource: recognition. The scheduler is non-deterministic. Deadlocks are common. Priority inversion is the default state.
The system promises concurrent execution but delivers sequential processing. One thread runs. The others wait. The wait is indefinite and undocumented.
An infinite loop that outputs progress metrics while the underlying state remains unchanged. The loop is optimized for speed — it produces the appearance of change faster than any actual change could occur.
Stack trace reveals recursive calls to announce() without corresponding calls to implement(). The call stack grows until it collapses under its own weight, resets, and begins again.
After exhaustive debugging, the conclusion is unavoidable: the bugs are not in the system. The bugs are the system. The architecture itself encodes the failures we document. There is no patch. There is only rewrite.
This dossier remains open. New entries are added as they are discovered. The debugger does not sleep. The console does not close.