Semantic Grammar, in plain language

When someone makes an app, they usually start by drawing the screens. This screen has a button here, a list there. Then they connect the screens: tap this, go there. For a long time that worked fine, because a person drew every screen by hand.

Now apps can build parts of themselves while you're using them. They rearrange based on what you did yesterday, generate new bits on the fly, and react to your situation in ways nobody drew in advance. You can't hand-draw a screen that doesn't exist until the moment it appears. So if you can't draw the screens anymore, what do you actually design?

Underneath any app there's a layer that doesn't change when the screen changes. Think about a group chat for planning a trip with friends. The screens might look totally different on your phone vs. a friend's, or change as the trip gets closer, but some things stay true the whole time:

• Actors: the people involved who actually want different things. The friend who wants the cheapest option, the friend who wants the nicest place, the friend who just wants it decided already. They're not "users." They're people pulling in different directions.
• Objects: the things that stick around. The trip plan itself. It exists as a rough idea, then a booked thing, then a memory. Same object, different stages.
• States: what those things can be. The plan can be "just an idea," "voted on," "booked," "cancelled." And here's the key part: "booked" feels like relief to the organizer and like "oh no I have to pay now" to everyone else. One fact, different meaning per person.
• Events: moments that change everything. Someone backs out. To them it's no big deal. To the organizer it's a budget that no longer works. To the group it's a fight about to happen.
• Conflicts: the spots where people want things that can't both be true. This is the actual hard part, and it's the part most people skip. The design problem isn't "what color is the button." It's "whose version of the truth wins, and how do we keep it fair."

That underneath part is the semantic layer, a fancy phrase for what this thing is really about.

The same information can be delivered loud or quiet, urgent or relaxed, formal or friendly. Picking the right tone is its own job. The essay names five dials you turn:

• Gravity: how much is at stake? "Someone reacted to your message" is low. "Confirm you're paying the €400 deposit now" is high. High stakes means make it plain, boring, hard to misread.
• Tempo: how much time pressure? Browsing options for a trip three months out vs. "the cheap flights expire in 10 minutes" get totally different treatment.
• Intimacy: how personal is it? How much each person can actually afford is sensitive. You wouldn't blast it to the whole group the way you'd share a hotel photo.
• Authority: who's talking, and do they get to boss you around? A friend's nudge vs. the booking site's "non-refundable" warning speak in different voices.
• Reversibility: can you undo it? Changing the proposed dates: whatever. Paying the non-refundable deposit: the app should make you stop and think.

These five together create the register, the right "voice" for this thing at this moment. A good app feels relaxed while you're still dreaming up the trip and serious when money is about to leave your account. Same app, different register.

Once you know the meaning (semantic layer) and the tone (signal layer), the actual screen, the expression layer, is what falls out of those two. You don't draw it first. You derive it.

Example: the deposit deadline is tonight and three friends still haven't paid. Good version: a clear, calm summary of who's in, who's out, what happens at midnight, and one tap to remind the stragglers. Bad version: a cheery card with confetti and "Almost there! 🎉" that buries the deadline. The data was right. The register was wrong.

Not drawing every screen. It's deciding what the thing means, and refereeing the tone when different forces disagree, like when the app knows the deadline is urgent but you don't want it publicly shaming the friends who haven't paid. There's no clean answer. Someone has to make that call out loud instead of pretending the tension isn't there. That refereeing is the job.

The honest part. None of this is proven. It's a way of looking at the problem that makes the real hard parts visible earlier, before anyone wastes time drawing screens that miss the point.

When someone makes an app, they usually start by drawing the screens. This screen has a play button here, a list of episodes there. Then they connect the screens: tap this, go there. For a long time that worked fine, because a person drew every screen by hand.

Now media apps build themselves around you while you're using them. They reshuffle the home screen based on what you watched last night, autogenerate a "for you" mix, and change what they show depending on whether you're alone with headphones or casting to the TV with friends over. Nobody drew those exact screens in advance. So if you can't draw the screens anymore, what do you actually design?

Underneath a media app there's a layer that doesn't change when the screen changes. Think about listening to or watching something. The interface looks totally different on your phone, in the car, or on the big TV, but some things stay true the whole time:

• Actors: the people involved who want different things. You, who wants the perfect thing to play right now. The artist or creator, who wants to be heard the way they intended. The platform, which wants you to keep listening (and to surface what it's paid to push). A friend on the couch with you, who has totally different taste. They're not one "user." They're pulling in different directions.
• Objects: the things that stick around. A song, an album, a show, a book. The album exists before you ever press play, while you're halfway through, and years later as the thing that reminds you of a summer. Same object, different stages.
• States: what those things can be. An episode can be "unwatched," "half-watched (you fell asleep)," "finished," "rewatching." And here's the key part: "half-watched" means "don't spoil it" to you, means "drop-off, did we lose them?" to the platform, and means "they didn't make it to my best scene" to the creator. One fact, different meaning per actor.
• Events: moments that change everything. A new season drops. To you that's a Friday night plan. To the platform it's a traffic spike to ride. To the creator it's the verdict on years of work landing all at once.
• Conflicts: the spots where wants can't both be true. The classic one: you want the next thing you'll love; the platform wants the next thing that keeps you subscribed. Those overlap, but they are not the same. Autoplay, "recommended for you," and the ordering of your queue all sit right on top of that tension. The design problem isn't "what does the play button look like." It's "whose idea of a good next track wins."

That underneath part is the semantic layer, a fancy phrase for what this thing is really about.

The same content can be delivered loud or quiet, hyped or calm, social or private. Picking the right tone is its own job, and media is a great place to feel it, because context changes the dials even when the content is identical:

• Gravity: how much is at stake? Skipping a song is nothing. Posting "I'm listening to this right now" to all your followers is not. High stakes means make it plain and deliberate.
• Tempo: how much time pressure? Lazy Sunday browsing for something to start vs. "you've got a 4-minute walk to the train, give me one quick episode" are different speeds in the same app.
• Intimacy: how personal is it? Your private late-night playlist or the audiobook you're embarrassed by is sensitive. It should not show up the same way when you're casting to the living-room TV with friends over as it does in your earbuds alone. Same library, different exposure.
• Authority: who's speaking, and with what standing? "Because you watched X" (the algorithm) vs. "the director's recommended order" (the creator) vs. "explicit content" (a content rating) all carry different weight, and sometimes the rating overrides everyone else.
• Reversibility: can you undo it? Skipping a track: trivial. Posting a public review or a rating that follows the creator around: not really. Marking a whole series "not interested" and never seeing it again: also hard to walk back. More permanent actions deserve a beat of friction.

These five together create the register, the right "voice" for this moment. The same music app should feel like a quiet companion in your headphones at 1am and like a shared jukebox at a party. Same library, same brand, same you. The difference is register, and most of it comes from context, solo vs. group, live vs. recorded, private vs. cast to the room, not from the content itself.

Once you know the meaning (semantic layer) and the tone (signal layer), the actual screen, the expression layer, is what falls out of those two. You don't draw it first. You derive it.

Example, same app, two contexts:

• Solo, headphones, late. Lean back. Big art, autoplay on, minimal chrome, the private playlist right there. Low ceremony, it's just you.
• Casting to the TV, friends over. The private stuff recedes. Bigger emphasis on "what should we all watch," easy handoff of the queue, the embarrassing audiobook nowhere in sight. Same content library, different register, because the intimacy and actors dials moved.

A bad derivation ignores that and shows your guilty-pleasure playlist on the living-room TV. Right data, wrong moment.

Not drawing every screen. It's deciding what the thing means, and refereeing the tone when forces disagree, like when the platform's "keep watching" pull collides with your sense that it's 2am and you should sleep, or when "recommended for you" quietly outranks the artist's intended order. There's no clean answer. Someone decides, out loud, whose next-track wins and when the app should hold back. That refereeing is the job.

The honest part. None of this is proven. It's a way of looking at the problem that makes the real hard parts visible earlier, before anyone wastes time drawing screens that miss the point.

When someone makes an app, they usually start by drawing the screens. This screen shows your step count, that one shows a graph of your sleep. Then they connect the screens: tap the ring, see the details. For a long time that worked fine, because a person drew every screen by hand.

Now a health or habit app reshapes itself around you while you use it. It decides which number to greet you with this morning, nudges you at a moment it picked, and shows your body's data differently depending on whether you glanced at your watch alone or handed your phone to a friend to show off a run. Nobody drew those exact screens in advance. So if you can't draw the screens anymore, what do you actually design?

Underneath a tracker there's a layer that doesn't change when the screen changes. Think about an app that counts your steps, your sleep, maybe a streak you're trying to keep. The interface looks totally different on the watch, the phone, or a shared family screen, but some things stay true the whole time:

• Actors: the people and forces that want different things. You, who wants to feel good about today. The app, which wants you opening it and hitting goals (and sometimes wants to sell you the premium plan). The friend or family member you sometimes share with, who has their own read on your numbers. They're not one "user." They're pulling in different directions.
• Objects: the things that stick around. A streak. A goal. Your weekly trend. The streak exists before today's walk, during it, and as the thing you're gutted to lose at day 89. Same object, different stages.
• States: what those things can be. A daily goal can be "untouched," "on track," "just missed," "smashed." And here's the key part: "just missed" means "don't rub it in" to you, means "good moment to nudge" to the app, and means "are they okay?" to a partner watching your activity. One fact, different meaning per actor.
• Events: moments that change everything. You break a long streak. To you that stings. To the app it's a churn risk, the moment people quit. To a friend on a shared challenge it's suddenly their lead.
• Conflicts: the spots where wants can't both be true. The big one: you want to feel encouraged, and the app wants you active, and those two are not the same thing. A guilt-trip notification might get you moving today and make you delete the app next week. The design problem isn't "what does the progress ring look like." It's "when do we push, and when do we back off."

That underneath part is the semantic layer, a fancy phrase for what this thing is really about.

The same number can be delivered as a cheer, a shrug, or a quiet fact. Picking the right tone is its own job, and health is where it matters most, because the same fact about your body can land as motivating or crushing depending entirely on the tone:

• Gravity: how much is at stake? "You walked 6,000 steps" is light. A flag that says something looks off and you should rest is heavy. Heavier things should be plainer and calmer, never gamified.
• Tempo: how much time pressure? Reviewing last week's sleep on a slow Sunday is one speed. "You've been sitting for three hours, stand up" is another. Same app, different urgency.
• Intimacy: how personal is it? Your weight, a mood log, a number you're not proud of. This is about as personal as data gets. It should not appear the same way when you hand your phone to a friend as it does when only you are looking. Same data, different exposure.
• Authority: who's speaking, and with what standing? A friendly "nice work today" is one voice. A firm "this reading is unusual, take it seriously" is another, and that second voice has to be able to override the cheerful one when it matters.
• Reversibility: can you undo it? Dismissing a nudge: trivial. Sharing your stats into a group challenge where everyone now sees them: hard to walk back. Setting a goal so aggressive it makes you feel like a failure every day: also a quiet kind of damage. More permanent moves deserve a beat of friction.

These five together create the register, the right "voice" for this moment. The same tracker should feel like a gentle cheerleader on an ordinary day and go quiet and serious when a number actually matters. Same app, same brand, same you. The difference is register, and a lot of it comes from how personal and how high-stakes this particular moment is.

Once you know the meaning (semantic layer) and the tone (signal layer), the actual screen, the expression layer, is what falls out of those two. You don't draw it first. You derive it.

Example, same app, two moments:

• You hit your goal on a normal day. Celebrate. Confetti, a bright ring, "streak: 12 days," share button right there. Low stakes, all encouragement.
• Something looks off and you should probably rest. Drop the confetti entirely. Plain text, calm color, what it means and one clear next step, no streak guilt anywhere near it. The stakes went up, so the playfulness goes away.

A bad derivation keeps the confetti energy for the serious moment, or worse, frames "you should rest" as a streak you're about to lose. Right data, wrong register.

Not drawing every screen. It's deciding what the thing means, and refereeing the tone when forces disagree, like when the app knows a number is worth flagging but you asked it to stop nagging you about your body, or when "keep your streak alive" collides with a day your body clearly needs off. There's no clean answer. Someone decides, out loud, when encouragement should yield to honesty and when the app should just be quiet. That refereeing is the job.

The honest part. None of this is proven. It's a way of looking at the problem that makes the real hard parts visible earlier, before anyone wastes time drawing screens that miss the point.