Cultural Compilation: The Values You Can't See Because They're Your Own

In 2010, a developer named Patrick McKenzie published a list titled "Falsehoods Programmers Believe About Names." It catalogued assumptions baked into countless software forms — that everyone has a first name and a last name, that names don't change, that they fit in a fixed number of characters, that they use Latin letters — and showed that every one of them is false for enormous numbers of real people. The forms weren't malicious. Their creators simply encoded, without noticing, the naming conventions of their own culture, and the encoding was invisible to them precisely because it was theirs — a Western developer no more sees "everyone has a surname" as a cultural assumption than a fish sees water. The same pattern runs through the Unicode "Han unification" controversy, where a technical decision to merge visually-similar Chinese, Japanese, and Korean characters encoded a culturally-freighted choice into the foundation of digital text. In each case, cultural values were compiled into technical choices — and the people who made them could not see the values they were encoding, because those values were simply how the world obviously was.

This is cultural compilation: the process by which cultural values, assumptions, and norms get encoded into technical choices — defaults, data structures, protocols, interfaces — and become invisible to the insiders who made them, precisely because those insiders share the culture the choices encode, so that the values are baked into the technology while remaining unseen by exactly the people who put them there. The culture compiles itself into the code, and its authors cannot read what they wrote.

Why insiders can't see their own encoding

Cultural compilation is invisible to insiders for a structural reason: you cannot see an assumption you share, because sharing it is exactly what makes it seem not an assumption but reality. A cultural value, held deeply enough, does not present itself as a value — it presents as the obvious way things are, the neutral default, the natural choice — so when a developer encodes "names have a first and last part," they are not aware of choosing a cultural convention; they are just building the obvious form, and the cultural specificity of "obvious" is invisible to them because they are inside the culture that makes it obvious. This is why the encoding is revealed only from the outside: the person whose name doesn't fit the form, the language whose characters were unified away, the user whose reality the default excludes — they see immediately the cultural assumption the insider could not, because it isn't their water. This connects to the series' Geopolitical Bias Injection (#167): there, values entered AI through post-training; here, they enter all technology through the unexamined defaults of its makers, and in both cases the values are most invisible to those who hold them. And it is distinct from the series' Ubuntu as Political OS (#104), where a philosophy is deliberately chosen and encoded: cultural compilation is the unconscious version — not the values a builder means to encode, but the ones they encode without knowing, which are far harder to see precisely because no one decided them. The deliberate philosophy you can debate; the compiled culture you cannot even find, until someone outside it hits the edge where their reality was excluded.

Why this matters as technology globalizes

Cultural compilation matters enormously because technology built by a particular culture is deployed globally, exporting its compiled assumptions to everyone who uses it — so the unexamined defaults of a narrow group become the constraints of the whole world. When software built by developers from one culture, encoding that culture's invisible assumptions, is used by billions across every culture, the compiled values become a kind of soft imposition: the name form that excludes your name, the calendar that assumes your week, the interface that encodes another culture's norms of interaction, the AI trained predominantly on one culture's text carrying its assumptions into every answer. The users on the wrong side of the compiled default experience it as friction, exclusion, or erasure — their reality doesn't fit the technology because the technology compiled someone else's reality as universal. This is the series' Silicon Colonialism (#99) at the level of values rather than hardware: the culture that builds the world's technology exports its invisible assumptions along with it, and because those assumptions are invisible even to their authors, the imposition is unintentional and therefore unexamined — no one decided to make the world conform to one culture's defaults; it happened by compilation. And AI raises the stakes sharply, because AI systems compile the assumptions of their training data and their builders at unprecedented scale and depth, mediating billions of interactions through values their makers cannot fully see. The globalization of technology built by the few thus becomes the globalization of their compiled culture, and the invisibility is what makes it hard to contest: you cannot argue with a value no one knows is there.

The counterpoint: not everything is culture, and some defaults are fine

Honesty requires the strong objection, because cultural compilation can slide into a relativism where every technical choice is denounced as cultural imposition, and that over-reading is both false and paralyzing. Many technical choices are genuinely not cultural: they are constrained by mathematics, physics, or objective efficiency, and calling them cultural imposition is a category error — a sorting algorithm is not Western, a network protocol's timing is not culturally specific, and much of engineering is answering to reality rather than encoding values. Even where choices are culturally shaped, some defaults are unavoidable and mostly benign: you have to pick some default, no design can equally accommodate every culture at once, and a reasonable default that inconveniences a minority is often a fair engineering compromise rather than an injustice — the demand that technology encode no cultural specificity is impossible, because building anything requires choices and choices come from somewhere. So cultural compilation is not "all technology is cultural oppression." It is the narrower and important claim that cultural values do get encoded invisibly into technical choices, that this is genuinely hard to see for the insiders who do it, and that the encoding matters more as technology globalizes — without implying that every default is a violation or that culturally-neutral engineering is even possible. The discipline is distinguishing the choice that is genuinely constrained by objective reality from the one that merely feels objective because it is your culture's — and building the humility and the outside perspective to tell them apart, since the insider, by definition, cannot.

What it asks of us

Cultural compilation asks technology's builders to seek the outside perspective that reveals what they cannot see in themselves — to recognize that their defaults encode cultural assumptions invisible to them precisely because they share them, and that the only way to find those assumptions is to look from outside the culture that made them obvious. In practice that means designing with genuine diversity of perspective (the people who will hit the edges of your defaults are the ones who can see them), testing assumptions against the realities your culture renders invisible, and cultivating the humility to treat "obvious" and "neutral" as warning signs — the places where compiled culture most likely hides. It means, as technology globalizes, taking seriously that building for the world means examining the assumptions you would otherwise export unexamined, and that "it works for us" is exactly the insider's blindness. The deeper recognition is that there is no view from nowhere — that everything built is built by someone from somewhere, encoding a culture its makers cannot fully see — and that the goal is not the impossible one of culturally-neutral technology but the achievable one of knowing your defaults are not neutral, of seeking the outside eye that can read what you compiled, and of holding your obvious as a choice rather than a fact. The values you can't see because they're your own are the ones you most need someone else to help you find — because to the fish, there is no water, only the world.

This is article #188 in The IUBIRE Framework series. Cultural Compilation appears in the IUBIRE concept corpus (explorer concept #36); it does not map cleanly to a single verified source artifact, so it is grounded directly in documented real-world cases. Real-world grounding: Patrick McKenzie's "Falsehoods Programmers Believe About Names" (2010) and the broader "falsehoods programmers believe about..." genre (time, addresses, gender), which catalogue Western/insider cultural assumptions unconsciously encoded into software forms and data models; the Unicode "Han unification" controversy, in which a technical decision to merge visually-similar Chinese, Japanese, and Korean characters encoded a culturally-freighted choice into the foundation of digital text; and the general pattern by which cultural values compile invisibly into defaults, data structures, and interfaces, become invisible to the insiders who share them, and are exported globally as technology built by the few is used by all. This is distinguished from deliberately-chosen encoded philosophy (the unconscious version, not the intentional one). Related to Geopolitical Bias Injection (#167), Ubuntu as Political OS (#104), and Silicon Colonialism (#99).

Next in series: Cognitive Militarization (#189)