Seems like there's quite a bit more to it: https://outliner.tana.inc/learn
Insightful, to think of a product and its interface as a "language" that the user learns. Some products give you a small and powerful vocabulary, where just a few words can accomplish a lot. Other products are like a badly designed language that lacks coherence and ease of use, where tasks that should be simple require many words, or some words don't fit together well with others.
Small but not too small. Case in point: shell scripts (POSIX shell, bash) where the scripting part was decided to be modelled as commands thus not introducing another bunch of concepts. We all know what the result is (hot, slow mess).
Shell scripting is a victim of its own success: it is _so easy_ to get started that most users get value out of knowing the first one percent and never bother to actually learn the rest.
There aren't many who have read the Bash manual, or know what zsh can do that Bash cannot, etc.
"Shell scripting is a hot, slow mess" is the same hot slow mess that you get wherever the barrier to entry is extremely low (e.g. early PHP, early JavaScript/frontend development, game development with a game engine where you can just click around in the editor, etc).
I wonder, though, if what you're describing as "product primitives" actually maps more closely to what Alexander later called "Centers," rather than the patterns themselves.
From what I understand, while the software world heavily adopted his patterns, Alexander spent his later career arguing that the ultimate building block of a system is actually a Center: localized focal points of utility and coherence, eg a well-lit courtyard, window seat, or fireplace. A strong center is naturally composable; it "resolves local tension," is made of smaller centers, and acts as a building block to generate larger ones.
When a product feels confusing or bloated, it's rarely out of bad design intent. It's just that user needs—while not necessarily glaringly—are empirically discoverable, while the true, underlying "centers" that could elegantly solve them are incredibly subtle and hard to identify. The path of least resistance is almost always to just build a unique, rigid interface for the immediate user need right in front of you. Doing the deep architectural work to discover a core primitive that naturally absorbs those needs is difficult.
So maybe that's why we build so many faster horses.
I've been calling these things product primitives. I can't remember where I heard that term, but it refers to things like...
Blocks in Notion. Messages and conversations in Telegram. Frames and layers in Figma. Tweets in Twitter. Cells and sheets in Excel. Tools and layers in Photoshop. Commands in a CLI.
I think what makes for good product design is having a very small number of primitives. A bad product doesn't know what its primitives are. Or it has a very large number of primitives. It feels like everything in the product is some unique thing that works in its own unique way. So users have to learn a ton of different top-level primitives/concepts. It's confusing and intimidating and hard to teach. Ideally you just want one or two or three main primitives.
The complexity/power in an app comes from choosing powerful primitives that have depth, that are composable, etc. You can do a lot with Notion blocks. You can do a lot with Excel cells. You can do a lot with a CLI command. You can do a lot with a Minecraft block. There's depth there.