Metodología
Creo que el diseñador del mañana escribirá reglas.
El trabajo de diseño se desplaza hacia definir las decisiones que permiten al sistema componer una experiencia: qué mostrar, cuándo, cómo organizarlo y qué debe suceder ante cada situación. Es una tesis sobre el oficio, no una predicción demostrada.
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 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.

Cinco piezas, y solo ésas. El catálogo viaja dentro, y está cerrado. - 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.

Lo que baja es el orden, no la bandeja ya montada. - 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 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 flowchart TB
bff["BFF<br/>datos y capacidades"] --> orq["Orquestación"]
orq --> comp["Compositor"]
comp --> val["Validador"]
val --> desc["Descripción de interfaz<br/>qué piezas y en qué orden"]
desc --> rend["Renderer<br/>con design system y tokens"]
rend --> pantalla["La pantalla"] 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 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.

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
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
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 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
- Elegir una experiencia y sus estados.
- Identificar las piezas necesarias.
- Definir contratos y combinaciones permitidas.
- Escribir las reglas aplicables y su forma de verificación.
- Construir composiciones de ejemplo.
- 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.

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.