Nobody Owned the Likeness

Four Robots, Independently

Somebody noticed that the button which opens the assistant looked different in every application, and went to compare them. What the sweep found was not a taste disagreement:

The shared component itself defaulted to a robot emoji when an app passed no emblem — so every app that passed nothing drew a robot.
Two apps used a robot glyph from an icon library, in a launcher and a drawer.
One used a sparkle.
One used a speech bubble labelled with a generic word.
And the assistant's own application used the robot glyph twice, in her own interface.

Four independent robots, one of them the shared default, one of them in her own app.

The Cause Was Ownership, Not Coordination

Nobody chose that. It is what the question "what icon means the AI thing" returns every time it is asked, by anyone, in any icon library — a robot, a sparkle, or a speech bubble. Six independent answers converged because they were all answering the same badly-posed question.

And the question was being asked at all because the assistant's likeness had no owner. Every other shared concern in this family had one: the client layer, the publish sequence, the vocabularies. Her face did not, so each app answered locally, and the local answer is whatever the convention returns.

The owner's ruling was blunt and it was about her rather than about the code: she is not a bot, and no robot of any kind stands in for her — not in a launcher, a header, an empty state, or a document.

When a shared identity has no owner, every consumer answers the question locally, and the local answer is whatever the convention returns. The failure looks like inconsistent taste and is actually an unassigned responsibility. Look for it wherever several products express the same thing independently — a voice, a name, an icon, an error tone. Nobody is making a bad choice; nobody is making a choice at all.

The Fix Was a Default, Not a Rule

The answer was not a style guide. She already has a face — the assistant's own icon — so it was downscaled, inlined into the shared component as a data URL, and made the default emblem. An app that passes nothing now gets her.

Two implementation details, both deliberate. Inlined rather than referenced, because the deploy mechanism is text-only and because a launcher that fails to load an image while the assistant is offline would be worse than no launcher. And the default is her, not a placeholder — that is what makes this hold.

Enforcement is the default, not vigilance. A rule requires every future author to know it and remember it at the moment they pick an icon; the failure mode is omission, which is the most common thing that happens. A default requires nothing, and drift now requires somebody to actively override — which is rare and visible in a diff. The rule was also carved into the template new apps are born from, so a new sibling arrives already correct rather than being corrected later.

The division of ownership is worth stating exactly, because it is not "the shared layer owns everything": the shared layer owns what she looks like; each app owns where the launcher sits and how it is toned, and may pass its own emblem for its own identity in a header. What no app may do is put a machine in her place.

Code

The default that removed the question·typescript

// BEFORE - the shared component's own default, vendored into every
// app. An app that passed no emblem drew a robot, and most apps
// passed no emblem.
const mark = glyphs?.mark ?? "🤖";


// AFTER - she already has a face, so there is no symbol to choose.
// Inlined as a data URL for two reasons: the deploy mechanism is
// text-only (no binary vendoring), and a launcher that 404s while
// the assistant is offline would be worse than no launcher.
export const PIPPA_MARK =
  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUg...";   // 64px

export function PippaLauncher({ mark = PIPPA_MARK, ...rest }: Props) {
  return (
    <button className="pippa-launcher" {...rest}>
      <img src={mark} alt="" className="pippa-mark" />
    </button>
  );
}


// WHY A DEFAULT AND NOT A RULE
//
//   rule    : every future author must KNOW it and REMEMBER it at
//             the moment they pick an icon.
//             failure mode = omission  -> the most common thing
//                                         that happens
//
//   default : passing nothing yields the correct result.
//             failure mode = deliberate override -> rare, and
//                                                   visible in a diff
//
// The division of ownership, stated so it is not read as "the
// shared layer owns everything":
//
//   shared layer owns : what she LOOKS like (the mark, the launcher
//                       around it)
//   the app owns      : where the launcher SITS, how it is toned,
//                       and its own emblem for its own identity in
//                       a panel header
//   nobody may        : put a machine in her place

Exercise

Find something in your products that expresses one shared identity and is implemented independently in each surface — an icon, an empty-state message, an error tone, a name for the same concept. List what each surface currently does. If they differ, ask who owns that identity, and if the answer is nobody, propose the default that would remove the question.

Hint

Icons and microcopy are the usual finds, because they feel too small to need an owner. The test is whether two surfaces would answer the same question differently if asked today — if so, the shared identity is being reinvented per surface, and a shared default is cheaper than a style guide nobody reads.

Four Robots, Independently

The Cause Was Ownership, Not Coordination

The Fix Was a Default, Not a Rule

Code

External links

Exercise

Progress

Comments 0