Saltar al contenido

El problema

Un equipo puede querer que la interfaz cambie según la intención: explorar, comparar, confirmar. Si no se han definido antes las piezas, los contratos, los estados y los límites, cada cambio se improvisará. El resultado suele ser una pantalla distinta cada vez, difícil de mantener y difícil de evaluar.

El ejemplo del viaje en esta página lo hace visible: las mismas seis piezas producen tres composiciones. Sin un catálogo y sin reglas de combinación, un agente —o un equipo— tendría que inventar la interfaz en cada petición.

De diseñar pantallas a especificar comportamientos.

El trabajo de diseño se desplaza hacia definir las decisiones que permiten al sistema componer una experiencia: qué mostrar, cuándo mostrarlo, cómo organizarlo y qué debe suceder ante cada situación. Escribir reglas es el núcleo de esa práctica. La versión más radical —que el diseñador «solo» escribirá reglas— debe discutirse; no se presenta como una certeza.

Qué es una regla

Una regla convierte intención de diseño en condiciones explícitas que pueden interpretarse, aplicarse y comprobarse. Debe expresar la situación en la que se aplica, el comportamiento esperado, las restricciones, las excepciones, la alternativa cuando algo falla y la forma de verificar el resultado.

Cómo se obtiene

Se obtiene investigando, observando, prototipando y evaluando. El documento de reglas recoge ese criterio; no sustituye el trabajo necesario para desarrollarlo. Una regla no nace de nombrar un principio: nace de una decisión tomada sobre una situación concreta.

Relación con componentes y tokens

El design system aporta las piezas y los contratos. Las reglas dicen cuándo esas piezas pueden combinarse, en qué orden, con qué información y con qué límites. Un token o un componente no decide la experiencia; la regla decide cómo se usa.

El desplazamiento, en dos columnas

Antes

Diseñador → pantalla → variantes → entrega → producto

Se diseñan los resultados, uno a uno.

Ahora

Diseñador → reglas y límites → decisión → composición → interfaz

Se diseña lo que decide cuál de todos los resultados toca.

Lo explico como lo entiendo hoy, en tres movimientos. Ninguno es exótico por separado; lo interesante es lo que pasa cuando se juntan.

  1. 1
    El sistema de diseño baja al dispositivo. Los tokens y los componentes viajan dentro de la aplicación. El teléfono sabe dibujar un catálogo corto de piezas, y solo ésas. No recibe estilos por la red ni improvisa formas nuevas.
    Un bloque de roble fresado con un hueco con forma de teléfono; dentro, cinco muestras de material encajadas a ras, cada una en su ranura.
    Cinco piezas, y solo ésas. El catálogo viaja dentro, y está cerrado.
  2. 2
    La composición sube al servidor. Lo que baja no es una pantalla dibujada: es una descripción de qué piezas, en qué orden y con qué datos. La misma versión instalada puede resolver dos pantallas distintas para dos personas distintas, sin publicar nada en la tienda.
    Una bandeja de roble con sus cinco ranuras vacías; al lado, las cinco muestras puestas en fila en un orden concreto, y una tarjeta de papel doblada, en blanco.
    Lo que baja es el orden, no la bandeja ya montada.
  3. 3
    Lo que el diseñador escribe es la regla que decide. En qué situación se aplica, qué debe ocurrir, qué no se permite, qué pasa cuando falta un dato y cómo se comprueba el resultado. Eso es escribir una regla: convertir un criterio en condiciones explícitas.
    Una plantilla de acero cepillado con dos aberturas: por una pasa una pieza azul; sobre la otra descansa una pieza de terracota que no cabe.
    Una regla es esto: qué pasa, qué no, y cómo se comprueba.

Llevado al final, el diseñador deja de entregar pantallas y entrega el criterio que las genera. Creo que ahí vamos. Lo que no desaparece es el trabajo de antes: investigar, observar, prototipar y evaluar siguen decidiendo qué regla merece escribirse. Cambia el entregable, no el oficio.

Cómo queda repartido

Cómo queda repartido

flowchart TB
  subgraph srv["SERVIDOR · decide qué hace falta"]
    bff["BFF<br/>datos y capacidades"] --> orq["Orquestación<br/>agentes y servicios"]
    orq --> comp["Compositor<br/>arma la descripción"]
    comp --> val["Validador<br/>comprueba los límites"]
  end

  val --> desc["Descripción de interfaz<br/>qué piezas y en qué orden"]
  desc --> rend

  subgraph disp["DISPOSITIVO · solo dibuja piezas que ya tiene"]
    ds["Design system<br/>el vocabulario"] --> rend["Renderer<br/>combina las piezas"]
    tok["Tokens<br/>decisiones visuales"] --> rend
    rend --> pantalla["La pantalla"]
  end
Las reglas no viven en una caja: gobiernan la orquestación, la composición y la validación, las tres del lado del servidor. Por eso escribirlas es trabajo de diseño y no una tarea de backend.

Es Server-Driven UI, no Server-Side Rendering. El servidor no dibuja la pantalla ni envía su HTML: envía una descripción de qué piezas, en qué orden y con qué datos. Dibujarla sigue siendo cosa del dispositivo, y solo puede dibujar lo que ya lleva instalado.

Una bandeja con unas pocas muestras de material distintas, cada una en su hueco.
El catálogo cerrado: unas pocas piezas conocidas, cada una en su sitio. Componer es elegir entre éstas, no inventar una nueva.

A qué altura actúa cada regla

Una regla no siempre habla de lo mismo. Conviene saber a qué altura actúa, porque una regla de acabado y una regla de proyecto ni se discuten en la misma reunión ni las firma la misma persona.

propiedad → componente → composición → flujo → proyecto → contexto

En producto: un token, un botón, una pantalla, un recorrido, el producto entero, la persona que lo usa. Fuera de la pantalla la cadena es la misma: un acabado, una luminaria, una estancia, el recorrido de entrar y dejar las cosas, la vivienda, y la orientación y la normativa que nadie eligió.

Esta cadena mide dónde actúa el criterio. No debe confundirse con la madurez del sistema, que mide otra cosa: qué existe, qué puede hacerse con ello y qué toca hacer ahora.

Cómo se aplica y verifica

Las reglas se aplican en varias capas. No deben depender únicamente de que un agente recuerde cumplirlas. La secuencia propuesta es: intención de la persona → contexto disponible → selección de reglas aplicables → orquestación → composición → validación → renderizado → evaluación del resultado.

No todas las reglas deben quedar como instrucciones de lenguaje natural para un modelo. Hay que distinguir principios que orientan decisiones, reglas de experiencia que requieren contexto, restricciones que pueden comprobarse automáticamente, permisos que deben aplicarse mediante código, y criterios que todavía requieren evaluación humana. La metodología explica cómo una decisión pasa de intención a especificación y, cuando es posible, a comprobación ejecutable.

Conflictos y excepciones

Cuando dos reglas entran en tensión, se hace explícita la prioridad, el alcance y la alternativa. Una excepción no es un atajo informal: se documenta, se acota y se verifica. Ocultar un control en la interfaz no constituye un control de permisos; la autorización se aplica también en servidor.

Revisión cuando produce una mala experiencia

Si una regla produce una mala experiencia, se revisa con evidencia: observación, prototipo y evaluación. No se «parchea» la pantalla para eludir el criterio. El aprendizaje vuelve al documento de reglas: se ajusta, se retira o se convierte en una excepción explícita.

Tipos de reglas

Composición
Qué piezas pueden combinarse y en qué orden. Ejemplo: una pantalla de revisión muestra el resumen antes de la acción de confirmación.
Contexto
Qué información cambia según la situación. Ejemplo: si faltan datos necesarios, mostrar cuáles faltan y permitir completarlos antes de continuar.
Interacción
Acciones, estados y transiciones. Ejemplo: mientras una solicitud está en curso, comunicar su estado e impedir un envío duplicado.
Autonomía
Qué puede hacer el sistema y cuándo interviene una persona. Ejemplo: el agente puede preparar una propuesta; enviarla a un tercero requiere confirmación explícita.
Accesibilidad
Requisitos verificables de la experiencia. Ejemplo: un error se identifica mediante texto y está asociado al campo; el color no es la única señal.
Recuperación
Cómo continuar cuando algo falla. Ejemplo: si no se puede completar el envío, conservar los datos introducidos y ofrecer un reintento comprensible.

Pregunta de investigación: ¿qué parte del criterio de diseño podemos expresar como reglas, qué parte podemos ejecutar y qué parte necesita seguir siendo evaluada por personas?

La arquitectura

En el dispositivo permanecen el design system, los tokens y un renderizador. En servidor están el BFF, la orquestación de agentes y el compositor de interfaz. El cliente recibe una descripción estructurada y la representa con componentes conocidos.

Esto es Server-Driven UI: el servidor describe la interfaz. No es SSR: el servidor no entrega el HTML de esa interfaz para que el navegador lo muestre tal cual.

Arquitectura conceptual de la metodología. Los detalles de implementación siguen abiertos.

flowchart TB
  persona(["Persona"]) --> disp["Dispositivo"]
  disp --> bff["BFF"]
  bff --> orq["Orquestación"]
  orq --> comp["Compositor"]
  comp --> val["Validador"]
  val -->|"descripción de interfaz"| disp
Capas. El validador devuelve una descripción de interfaz, no HTML. Pocas piezas en el dispositivo.
sequenceDiagram
  actor Persona
  participant D as Dispositivo
  participant B as BFF
  participant O as Orquestación
  participant C as Compositor
  participant V as Validador
  Persona->>D: Intención
  D->>B: Contexto y petición
  B->>O: Resolver con agentes y servicios
  O->>C: Datos y acciones permitidas
  Note over C: Aplica reglas de composición y contexto
  C->>V: Descripción de interfaz
  V-->>C: Acepta o rechaza
  C->>B: Descripción válida
  B->>D: Descripción de interfaz
  D->>Persona: Piezas conocidas
Secuencia de una petición. El validador actúa antes de entregar la descripción. El dispositivo no improvisa componentes.
flowchart LR
  reglas["Reglas de diseño"]
  perm["Permisos en código"]
  orq["Orquestación"]
  comp["Compositor"]
  val["Validador"]
  bff["BFF y servidor"]
  reglas --> orq
  reglas --> comp
  reglas --> val
  perm --> bff
  perm --> orq
Las reglas no dependen de que el agente las recuerde. Se aplican en orquestación, composición y validación. Los permisos se ejecutan en servidor.

Las responsabilidades

  • Diseñador: investigar, definir reglas y evaluar sus efectos.
  • Design system: proporcionar componentes, tokens y contratos.
  • Agentes: interpretar la intención y proponer acciones dentro de sus permisos.
  • Compositor: construir una descripción de interfaz respetando contratos y reglas.
  • Validador: comprobar las restricciones verificables antes de entregar la composición.
  • Dispositivo: renderizar componentes conocidos y gestionar su interacción local.

Esta distribución es una propuesta metodológica. No implica que exista una implementación completa.

Preguntas abiertas: quién versiona el contrato entre cliente y servidor, cómo se rechaza un componente desconocido, y qué traza queda de cada composición.

Proceso de trabajo propuesto

  1. Elegir una experiencia y sus estados.
  2. Identificar las piezas necesarias.
  3. Definir contratos y combinaciones permitidas.
  4. Escribir las reglas aplicables y su forma de verificación.
  5. Construir composiciones de ejemplo.
  6. Evaluar comprensión, accesibilidad y recuperación; revisar las reglas que fallen.

Es un proceso en desarrollo. No está validado como método implantado.

Una pantalla que no existe hasta que alguien la pide.

Cambia el escenario y mira las dos mitades a la vez: a la izquierda, lo que acaba viendo la persona; a la derecha, la regla que lo ha decidido y la lista de piezas que el dispositivo ya tenía. Quita el dato que falta y verás qué hace la regla cuando la realidad no viene completa.

Dos bandejas de roble idénticas con las mismas cinco muestras de material, ordenadas de forma distinta. Delante de cada una, la misma regla de acero en otra posición.
Cambia la regla y cambia el resultado. Las piezas son exactamente las mismas.

Composiciones predefinidas, datos ficticios, sin servicios externos.

Demostración conceptual. Datos ficticios. Composiciones predefinidas.

Intención. El viajero quiere ver destinos posibles para un fin de semana.

La pantalla de la izquierda es el resultado. Aquí se explica qué regla la ha compuesto.

Ves tres destinos con la misma pieza. COMP-01 impide destacar un ganador o pedir que reserves: todavía estás explorando.

Qué reglas deciden esta pantalla

Componentes utilizados

Qué recibiría el dispositivo

El servidor no envía el HTML de esta pantalla. Envía una descripción con piezas conocidas, en este orden:

    La misma descripción en JSON
     

    Límites y preguntas abiertas

    Versionado
    Cómo conviven cliente y servidor cuando el contrato cambia. En exploración.
    Componentes desconocidos
    Qué hace el renderizador si llega un tipo que no existe. Pendiente de validar.
    Fallos de red
    Qué interfaz mostrar cuando el BFF no responde. Definido como necesidad; sin implementación aquí.
    Composiciones inválidas
    Quién rechaza un árbol que rompe el contrato. En exploración.
    Coste de deshacer
    Una composición se recalcula en milisegundos; fuera de la pantalla, deshacer cuesta dinero y tiempo. Toda regla que salga del producto debería declarar si se cambia en caliente, si es reversible, si se programa o si hay obra de por medio. Sin implementación aquí.
    Cumplir no es calidad
    Un resultado puede pasar todas las comprobaciones y seguir siendo malo. La validación automática es un guardarraíl, no un certificado: dice que algo es válido, no que merezca existir.
    Accesibilidad
    Cómo se garantiza foco, nombre y estado cuando la interfaz se recompone. Pendiente de validar.
    Trazabilidad
    Qué registro queda de la intención, la composición y la revisión humana. En exploración.
    Intervención humana
    Dónde se inserta una parada obligatoria. Definido como principio; los puntos exactos dependen de cada producto.

    Estado de desarrollo

    • Definido: el núcleo de diseñar mediante reglas, la separación de capas, el uso de SDUI y no de SSR, y los cuatro principios de diseño previo.
    • En exploración: contratos, versionado, trazabilidad y el papel concreto de cada agente.
    • Pendiente de validar: accesibilidad de interfaces recompuestas, recuperación ante error y evaluación con equipos reales.

    Esta metodología no se presenta como implantada en Kutxabank. El cargo describe mi trabajo; la metodología describe una aportación en curso.