Conversational Design Systems

The shift

We used to draw a screen and ship it exactly as drawn. Now the model composes each reply and each layout at runtime. The screen is an output. The behavior is the design.

Three layers

Intent

What the user is trying to do.

Commitments

What the product must say, must never say, and must never do without permission. Ours. Written down. Versioned. This is the layer most teams do not have.

Expression

The actual words and the layout. The model's job.

The product owns meaning. The model owns expression.

What design produces now

1. Behavior spec. One intent, the facts it needs, the actions it may offer, the promises it must keep.
2. Conversation contract. Must say, must never say, and what ships when a check fails.
3. Salience rules. What stays visible before a confirm, on each surface.
4. Test fixtures. Behaviors written as tests that block a release.
5. Trace. From one id, reconstruct what was said, what was shown, and why.

When the model emits components, not sentences

Declarative UI does not complicate any of this. It sharpens it. The model composes from a catalog we own instead of inventing widgets, so a required disclosure stops being a sentence we hope for and becomes a required node we can assert on: present, before the confirm, not inside a collapsed container. Structural checks are faster and far more reliable than judging prose.

Gate fails, the pre-approved fallback tree ships instead.

// catalog/ConfirmTransfer.yaml   ours, versioned, reviewed
requires: [amount, fee, rate, received, recipient]
renders:  terms block, above the confirm control
never:    collapsed, or below the fold

// what the agent emits, composed for this turn
- Text: "Listo, este es el resumen"
- ConfirmTransfer: { amount: 350, fee: 4.99, rate: 18.90,
                     received: 6615, recipient: "María López" }

// gate/confirm.rules   runs before anything renders
terms present           → pass
terms precede confirm   → pass
terms not collapsed     → pass
anything else           → ship the fallback tree

The fallback is stiffer, and it still carries every required term. A plain accurate sentence beats a fluent omission. Note also what the model was never asked to do: compute the fee, or remember the disclosure. It chose a component and filled declared props. The strongest version of this is to make bad output unrepresentable rather than detected. A confirm component that requires the terms cannot be composed without them. Validation is the second line. The catalog is the first.

What changes for us

We stop designing the output and start designing the space of allowed outputs. Which means:

• Critique moves from screens to transcripts.
• Taste gets written down as a rubric, so it can be scored, weekly.
• Fallback and error copy becomes our most important writing, because it ships at the worst moment.
• Every terminal state (abandonment, timeout, max retries, escalation) needs a designed exit, not just a technical one.

Two kinds of metric

A release can improve every dial and still be blocked because a floor failed. That is the system working. Without floors, the fastest way to raise completion is to ask less and warn less.

How much of this to adopt

In proportion to what a wrong sentence costs. A marketing bot needs almost none of it. A money flow needs all of it.