The Selection Is the Sentence

Every interaction should do more than one job without asking the user to do more than one thing. The Egyptian canon worked because the second reading was a rule, not a guess.

Subscribe
Developer ToolsAgentsAI
Listen to this post
AI Summary Egyptian hieroglyphs could be read three ways—as a picture, as a symbol for that thing, or as a symbol for a sound—with the correct reading determined by context through rigid, consistent rules maintained over three thousand years. …
  • Egyptian hieroglyphs could be read three ways—as a picture, as a symbol for that thing, or as a symbol for a sound—with the correct reading determined by context through rigid, consistent rules maintained over three thousand years.
  • The article argues that software interactions should do more than one job without asking the user to do more than one thing, just as Egyptian signs carried multiple functions in a single economical element.
  • AI enables the second function of an interaction to be inferred at runtime rather than enumerated at design time, which is the fundamental change in interface grammar rather than simply adding AI features to software.
  • A true double-functioning interaction is one where the user performs no extra actions (no clicking sparkle icons or opening panels) and where removing the AI leaves the primary function working exactly as before.
  • The article warns that inferring a second function probabilistically from user actions creates a hidden mode that users cannot see or predict, and proposes that applications should publish an interaction manifest declaring what each action does so both users and AI agents can interpret interactions consistently.

An Egyptian sign can be read three ways. As a picture of a thing. As a symbol for that thing. As a symbol for a sound.1 The mark does not change. What changes is which reading the context calls for.

This was not a stylistic flourish. The script field and the image field were built on the same formal principles, and the two fields interpenetrated.9 Words were written with single signs that depicted the object. Determinatives sat at the end of a word to declare the category it belonged to. Signs that related to an image faced the same direction as that image.2

One economical element, carrying more than one job at once.

Applied to software, the principle reads: every interaction should do more than one job without asking the user to do more than one thing.

The old grammar

The dominant GUI paradigm has been one control, one explicit function. A button does a thing. A menu item does a thing. A dialog collects the parameters for the thing.

That grammar exists because the machine needed the human to specify precisely what operation should occur. Menus are a vocabulary list. Dialogs are a form. Settings are a standing instruction filed in advance because the software cannot ask at the moment it matters.

Every one of those constructs is a workaround for a machine that cannot infer intent.

AI removes the requirement. And when the requirement goes, the grammar built on top of it goes with it.

The new grammar

One action, multiple coordinated functions.

Consider selecting text. In conventional software, selection means identify this object. Nothing more. The selection is UI state, and it is inert until the user names an operation to perform on it.

In double-functioning software, the same act also means this is the object I am referring to. The selection is simultaneously UI state and semantic context. The user does not copy it, describe it, attach it, or tell an agent where to look.

The act of pointing is the act of referring.

Stack the jobs a single interaction can carry:

  • accomplish the immediate task
  • teach the system what the user intends
  • teach the user how the system works
  • capture context for the next operation
  • expose capabilities that would otherwise require navigation

The failure mode is obvious and everywhere: cram the functions together and call it integration. A sparkle icon in the corner. A chat panel bolted to the side of an application that was designed for the old grammar and never revised.

Tip

The Egyptian line is the corrective. The functions have to be structurally coincident. The second emerges from the first because they share the same mark.

This is not new, and that matters

Acme shipped in 1994. Rob Pike's editor treated text as both content and command surface — you did not select a command from a menu; you wrote the command in the window and executed it in place, and any text anywhere was a candidate. Acme gave its clients a fixed user interface and simple conventions to encourage uniform use, and exported its own state as files that other programs could read and manipulate.6

Double-functioning predates the transformer by thirty years.

What was true then was that every double function had to be hand-authored. A designer decided, in advance, that this act would also mean that. The pairs were enumerated one at a time, which is why the technique stayed rare and stayed inside programmer tools.

AI does not invent the second function. It makes the second function general.

The pairing can be inferred at runtime instead of enumerated at design time. That is the actual change in the grammar, and it is a bigger claim than "software will contain AI."

The Selection Is the Sentence

The canon is the constraint

Here is what the Egyptian analogy demands that most AI-native design skips.

The double reading worked because the system was rigid. Egyptian art held its conventions for three thousand years: a canon of proportion on a grid, aspective depiction showing each part from its most informative angle, registers and baselines organizing space, scale assigned by status rather than distance.45 The orientation rules were so normative that a scholar can reconstruct a lost figure from a surviving fragment of inscription.2

The second reading was never a guess. It was a rule the viewer had been trained on.

Important

Modern double-functioning proposes the opposite. The second function is inferred, probabilistically, from an act the user may not have intended as instruction.

Larry Tesler spent a career on exactly this hazard. He defined a mode as a state of the interface that persists, attaches to no particular object, and exists only to place an interpretation on operator input.7 He drove with NO MODES on his license plate and told anyone who would listen not to mode him in.8

An act whose meaning depends on hidden state is a mode. Overloading selection with referential meaning, and deciding case by case whether that meaning applies, reinvents the mode with a probabilistic boundary instead of a toggle. The user cannot see the boundary and cannot predict which side of it they are on.

Baines put the reason economy works in Egyptian representation plainly: the outline carries the most information.3 A boundary is efficient because it is unambiguous, not because it is doing double duty.

The test

Strip the aesthetics out and the distinction is mechanical.

  • If the user has to do anything extra — click a sparkle, open a panel, phrase a prompt, attach a file — the second function is bolted on.
  • If removing the AI entirely leaves the first function working exactly as before, the second function was coincident.

Bolt-ons fail the first test. Overloaded modes fail the second, because pulling the AI out breaks the primary act.

The schema worth arguing about

The Egyptian canon was legible because it was published. Not literally in a spec, but in a training regime so consistent that every scribe and every viewer carried the same rule set.

Software has no equivalent. Applications do not declare what their interactions mean. The user infers it from convention, the agent infers it from a DOM, and both are guessing.10

The companion artifact to this argument is a declaration format — an interaction manifest that states, per interaction, what the act does and what else it does:11

{
  "interaction": "text.selection",
  "primary": "identify-range",
  "coincident": [
    { "function": "bind-referent", "target": "agent.context" },
    { "function": "expose-capabilities", "target": "ui.affordances" }
  ],
  "derivation": "declared",
  "disclosure": "visible",
  "reversibility": "single-step",
  "added_user_actions": 0
}

Two fields decide everything.

  • derivation separates a canon from a guess. declared means the second function fires by rule and fires every time. inferred means the software decided, and the user is now inside a mode with an invisible edge.
  • added_user_actions separates coincidence from adjacency. Any value above zero is a bolt-on wearing the vocabulary of integration.

The rest is disclosure and escape.

A double-functioning interaction the user cannot see and cannot undo is not elegant. It is a trap with good ergonomics.

Agents will read these manifests before humans ever benefit from them, and that is the point. The interface stops being the place where a human issues a command. It becomes the boundary where human intent and machine agency meet — and a boundary is only economical when both sides read the same line the same way.

Publish the canon or ship the mode. There is no third option.

Footnotes

  1. Hieroglyphic writing — Britannica — The three readings a single sign carries: as a picture of a thing, as a symbol for that thing, and as a symbol for a sound — the source of the opening claim the whole argument is built on. https://www.britannica.com/topic/hieroglyphic-writing ↩
  2. Egyptian art: orientation — UCL Digital Egypt for Universities — The orientation convention — signs relating to an image face the same direction as that image — and how normative it was: rules consistent enough that a scholar can reconstruct a lost figure from a surviving fragment of inscription. https://www.ucl.ac.uk/museums-static/digitalegypt/art/orientation.html ↩
  3. Why does ancient Egypt's distinctive art style make everything look flat? — Live Science (2022), quoting John Baines, University of Oxford — Baines on why economy works in Egyptian representation: the outline carries the most information — the point this piece turns into an argument about boundaries being efficient because they are unambiguous. https://www.livescience.com/why-ancient-egyptian-art-2d ↩
  4. Egyptian art and architecture — Britannica — The conventions held for three thousand years: the canon of proportion, aspective depiction, registers and baselines, and scale assigned by status rather than distance. https://www.britannica.com/art/Egyptian-art ↩
  5. The Basic Principles of Ancient Egyptian Art — Wonderful Things Art (2025) — A working summary of the same canon, covering the grid of proportion and the organising role of registers. https://www.wonderfulthingsart.com/post/ancient-egyptian-art ↩
  6. Rob Pike, Acme: A User Interface for Programmers — USENIX Winter 1994 — The thirty-year precedent: text as both content and command surface, commands written and executed in place rather than chosen from a menu, a fixed interface with simple conventions to encourage uniform use, and state exported as files other programs can read. https://www.usenix.org/legacy/publications/library/proceedings/sf94/full_papers/pike.pdf ↩
  7. Mode (user interface) — Wikipedia, citing Larry Tesler's definition — Tesler's definition, which the piece applies to probabilistic double-functioning: a state of the interface that persists, attaches to no particular object, and exists only to place an interpretation on operator input. https://en.wikipedia.org/wiki/Mode_(user_interface) ↩
  8. Larry Tesler cut and pasted from this mortal coil — The Register, 19 February 2020 — The obituary carrying the NO MODES license plate and the campaign behind it — a career spent on precisely the hazard this piece argues AI-native design is about to reintroduce. https://www.theregister.com/2020/02/19/larry_tesler/ ↩
  9. Stéphane Polis and Serge Rosmorduc, The Functions and Toposyntax of Ancient Egyptian Hieroglyphs: Exploring the Iconicity and Spatiality of Pictorial Graphemes — The scholarly basis for the claim that the script field and the image field were built on the same formal principles and interpenetrated — iconicity and spatiality treated as properties of the graphemes themselves rather than as decoration around them. https://www.researchgate.net/publication/330022287 ↩
  10. Legibility Is Not Enough — The Agentic Web part 2, on why being findable by machines was the easy part. The gap it names is the one this section reaches from the other side: an agent that can parse a surface still has to guess what the surface means, because nothing on it declares its own semantics. ↩
  11. Why MCP Needs a Manifest: Solving the Configuration Chaos — The same move one layer down — mcp-manifest.json, arguing that configuration should be declared for autodiscovery rather than reconstructed by hand. The interaction manifest proposed here applies that pattern to semantics instead of setup: declare what an act means, rather than leave the machine to infer it. ↩
Back to the Journal

Read next