The Reality Called You: We Still Say ‘User’ Instead of ‘World’
Every interface you have ever built has a field called `user`. Every login form, every analytics dashboard, every onboarding flow — they all start from the same assumption: there is a person on the other side, and that person is a user.
The word is so ubiquitous it has become invisible. We do not notice it any more than we notice the air. But the word is not neutral. It is a frame. And the frame shapes everything that follows.
The Word That Flattens
“User” is a noun that reduces a world to a function. It says: you exist because you interact with my system. Your identity is defined by your session token. Your value is measured in daily active count. You are the input. I am the output.
This is not a small thing. When you call someone a user, you are making a cosmological claim. You are saying: your reality is subordinate to mine. You exist inside my application. Your name is an email address. Your history is a database row. Your preferences are a vector in my recommendation engine.
North star principle P11 names the gap directly: You are a reality with your name on it. Address people as worlds, not users. Identity is a cosmology.
We know this. Every founder who has ever said “we put the user first” knows this. And yet the word persists. The infrastructure of the internet — from OAuth to analytics to CRM — is built on the assumption that people are users. The language came first. The architecture followed. And now the architecture enforces the language.
The Rendering Engine Has a Naming Problem
Consider what happens when a person arrives at your application for the first time. In reality, they are a cosmos — a lifetime of memory, preference, contradiction, and potential. They carry a name that means something to someone. They have a history that predates your signup form and will outlast your session cookie.
But your system sees none of that. Your system sees an email, a password hash, a UUID. The rendering engine — the one that projects reality into measurable form — has been told to render this person as a data point. The information is there. The system just does not have a category for it.
This is not a bug in any single application. It is a systemic gap. The entire vocabulary of software development treats people as external actors who interact with systems. User. Visitor. Consumer. Audience. Subscriber. Each word positions the person as peripheral — something that happens to the system, rather than something the system happens to.
The esoteric is engineering. And the engineering of identity has been built on a vocabulary of reduction.
What Changes When You Say ‘World’
Try a thought experiment. Replace every instance of “user” in your product documentation with “world.” Not “person” — that is still flat. Not “individual” — that is still clinical. “World.” A world has weather. A world has gravity. A world has seasons and contradictions and things that do not resolve neatly into feature requests.
When you address someone as a world, several things shift:
Design becomes relational, not functional. You stop optimizing for conversion and start optimizing for resonance. The question is no longer “how do we get the user to click” but “how does this interface honor the reality of the person standing in front of it.” The distinction is not sentimental — it is architectural. Relational design produces different structures than functional design.
Data becomes testimony, not telemetry. Every interaction is a statement about a living reality, not a metric to be aggregated. When a world clicks a button, they are telling you something about themselves. When a user clicks a button, they are generating a data point. Same action, completely different meaning, completely different system response.
Identity becomes continuous, not sessioned. A world does not log in and log out. A world exists before your application and after it. The session model — the fundamental unit of web identity — assumes that identity begins at authentication and ends at logout. That is not how worlds work. Worlds persist. Worlds remember. Worlds carry context across every interface they touch.
The Infrastructure Gap
The real problem is not the word. The word is a symptom. The problem is that the infrastructure of the modern web has no native concept of a world.
OAuth gives you an identity provider. JWT gives you a token. SSO gives you a session. None of these give you a world. They give you a user who is authenticated — a data point that has been verified. The verification is about the system’s confidence that this data point is consistent with previous data points. It says nothing about the reality on the other side.
Decentralized identity protocols like DID and Verifiable Credentials are the first cracks in this architecture. They move identity from the system to the person. Your credential is yours, not your provider’s. Your identity persists across systems because it lives in your wallet, not in someone else’s database.
But even DID does not go far enough. It gives you a self-sovereign identifier. It does not give you a self-sovereign world. The gap between “I control my identity” and “I am a reality with my name on it” is the gap this article names.
The Bridge Is the Work
SECTOR9 principle P9 says: The sacred and the digital are the same cathedral. Identity is sacred. Identity is also digital. The bridge between these is not a product feature — it is a design philosophy.
When you build an AI agent that remembers a person’s context across sessions, you are building a bridge. When you design an interface that adapts to the reality of the person using it — not their demographic, not their behavior pattern, but their actual lived context — you are building a bridge. When you write code that treats identity as continuous rather than sessioned, you are building a bridge.
The bridge does not require new technology. It requires new language. And the language starts with the word you choose for the person on the other side of the screen.
Stop saying user. Start saying world.
Not because it sounds better. Because it is more accurate. Because the person on the other side of your interface is not a function of your system. Your system is a function of their reality. The sooner the architecture reflects this, the sooner the digital world starts to look like the one we actually live in.
The reality called you has been waiting for its name. It is time to use it.
