Àṣà

There is a move I kept noticing across very different rooms. A conversation about retrieval architecture would arrive at it. A conversation about onboarding flows would arrive at it. A conversation about how to draft a thesis statement would arrive at it. Every time, the same shape: stop letting the system guess what you mean. Tell it. Then let it work inside what you told it.

For a long time I had no name for the move. Just a felt sense that the products and prompts and protocols I trusted most all did this thing, and the ones that frustrated me were doing the opposite.

Then six independent threads in my system surfaced the same move at the same time, in six different vocabularies, and the pattern stopped being subtle.

The principle

Declared > Inferred.

When a system has to choose between what the user has explicitly said and what the system is good at guessing, the explicit thing wins. Always. Not because guessing is bad, guessing is essential, but because the frame inside which the system guesses should belong to the user, not the model.

The declared frame is the sovereignty surface. Inside it, models can be brilliant. Outside of it, they are guessing about your life.

Why it shows up everywhere

Because it isn't a technique. It's a relationship.

A few of the places I've watched it show up:

• Retrieval. Vector search is inferred relationship. A typed link in a knowledge graph is a declared one. The graph compounds; the embeddings drift.
• Onboarding. "Personalization" is the system inferring who you are from clicks. A declared profile, even a tiny one, outperforms it for the rest of the relationship.
• AI interfaces. A chat box is an inferred interface; the model has to guess what action you want. A named action, "summarize," "plan," "critique," is declared, and the quality jump is immediate.
• Consent. A pre-checked box and a long EULA are inferred consent. A toggle you actually set is declared consent. Regulators are beginning to notice the difference. Users have always felt it.
• Identity. When you write down who you are before you talk to a powerful intelligence, you meet it as another power. When you don't, it fills in your shape with its priors.

Different stacks. Same move.

What declaring buys you

Three things, every time:

1. Auditability. A declared frame leaves a trail. You can point to it later and say that is what I meant. You can revoke it. You can version it. Inferred frames evaporate the moment the session ends.
2. Composability. Declared frames travel. Once you have written down your ontology, you can hand it to a different tool and the relationship resumes. Inferred frames are stuck inside the system that inferred them.
3. Sovereignty. The declared frame is the part you own. Everything downstream of it, the model's outputs, the system's recommendations, the platform's defaults, is downstream of you, not the other way around.

How to use it

When you are designing anything that involves an intelligent system and a person, ask:

What is the smallest declaration the user can make that lets the system stop guessing about the things they care about most?

That declaration is your product's spine. Everything else is downstream of it. If your product can't accept a declaration, it is going to spend its life guessing, and the user is going to spend their life correcting.

The craft is in keeping the declaration small. A long declaration is just another EULA. A small one is a contract you can read in a breath. Notion has the page title. Claude has the system prompt. Your product has whatever single act of declaration you respect most.

Why "Àṣà"

There is a Yoruba word, àṣà, that means custom or tradition, but more precisely, declared practice. The way a community has said, out loud, that things will be done. It is what makes ritual ritual and not habit.

I am borrowing it because "declared frame" is correct but bloodless, and because the move is older than the software I keep finding it in. Tradition itself is just a community's standing declaration. The fact that this principle keeps surfacing in AI systems is the same principle finding its way back into a substrate that had stopped using it.

A small commitment

I am going to keep writing about this because the more I sit with it, the more it organizes the rest of what I do. Some pieces will be technical: the schema, the auditing patterns, the way declarations should travel between tools. Some will be small: a single field note about a single declared moment. They will all be downstream of this one move.

If you build with AI and you have not yet asked your users what they would like to declare, you are already designing on top of inferences. It is worth pausing the build long enough to ask.