“The virtue of formal texts is that their manipulations, in order to be legitimate, need to satisfy only a few simple rules; they are, when you come to think of it, an amazingly effective tool for ruling out all sorts of nonsense that, when we use our native tongues, are almost impossible to avoid.”
According to Noam Chomsky there exist 4 types of grammars within the domain of formal language. All types have different levels of complexity and binding constraints depending on the manner in which they are used. For example, a Type 3 grammar has the most binding constraints and can only produce strings through rules of the form A → u or A → uB, where A and B are non-terminal symbols and u is a string of terminal symbols. We can think of this type of framework as a formal system of communicative structure. It is withholding a seemingly infinite amount of possibilities from the space of language and constraining what the agent is free to remark depending on the system’s specification of grammar.
These formal systems are important because they allow you to express valid communicative structure. These systems deliberately constrain expression to remove ambiguity. To illustrate, when people try to write precise specs in plain English, they either accept vagueness (and get bad results) or gradually formalize their language until they’ve reinvented a programming language in worse form. Precision as it is will always be a target within these proxy frameworks (specs), but you will always hit diminishing returns on trying to capture minute details as to be precise.
We can think of formal systems like mathematical notation as maps of the territory. Axiomatically, maps will always be lossy when attempting to capture what it is proxying. Being so, the value of these formal systems comes from what it leaves out, what it negates, what it says no to.
Naturally, we can then think of interfaces (UI/UX) as placing binding constraints on the user so they cannot express non-sense in such a way that would not be useful. Interfaces are formal systems, representations of what the user can do and what the system can accept. Buttons, drop-down menus, sliders, etc all limit what the user can express. Therefore, interfaces should be thought of as formal representational systems that make the domain of interaction legible and navigable for the user.
Come 2026 and we have talks of people abandoning interfaces for natural language navigation. Based on the theory of formal systems to govern binding constraints, this proposition is quite ridiculous. For one to navigate a system using pure natural language, they would require an outsized ability to mobilize and organize a vast amount of knowledge which would naturally end in cognitive overload. A natural language interface places almost no binding constraints on the agent’s action. It does not negate anything. There exists a seemingly infinite amount of options available to the agent. Some might call the chatbox interface one that is simplifying the UI, when in reality it is making the agent’s possibility space of interaction much more complex. The user will stare at the blank space of the chatbox interface and realize there are no contact points available for them to latch onto. No buttons, no options, no suggestions that allow the user’s existing knowledge to be used accordingly. The user is forced to be a genius: effective thinking happens between feedback loops between agent and environment. Without the environment to scaffold the user’s existing priors, how will they mobilize what they need to use? Furthermore, within natural language interfaces, there is no perceived sense of stability. The 1992 Mac HCI guidelines outline that good interfaces provide a stable, knowable environment. The user builds a mental model of what exists and what they can do, and that model persists across sessions. For example, dimming unavailable actions instead of hiding them shows the user that their mental model is still valid despite the actions not being available. Chatbox interfaces go against this because there is no stability. The user can’t build fluency in an environment that doesn’t show up the same way every time.
Circling back to formal systems of communication, there’s a parallel between abandoning specs for code and abandoning Figma as AI tools get better at rapid prototyping. Both of these things, code specs and figma, can be seen as maps to the territory. They are describing how the thing should be expressed using binding constraints so the agent does not ultimately express nonsense. So, it’s not that Figma is bad or that designing in code is bad, it’s about where the map stops being useful. Low-fidelity Figma is a valuable map (fast, abstract, good for exploration). High-fidelity Figma hits diminishing returns because the medium can’t express the things that matter most at that level of detail in code production. Skipping the contemplative phases of these creative processes is essentially skipping the cognitive scaffolding that formal notation systems give. It is essential.
I think this is where the importance of UI/UX laws can be seen: these laws are specific constraints you can use in your formal system to better match human cognition. If interfaces are simply formal systems of communication with binding constraints, these laws tell you what constraints are actually valuable. A dropdown with 7 items isn’t just a formal constraint on expression. It’s a formal constraint tuned to a measured property of human cognition (Miller’s law). The laws are the balancing layer between “constrain the possibility space” and “constrain it this way, this much, for this reason.” They are practical.