Nivel inicial7 min de lectura · Publicado el

Flow de desarrollo en diseño ágil: la pantalla, al final

Flow de desarrollo ágil como una obra en orden: requisitos como tests, objetos, tablas y, al final, la pantalla. Flow ágil: pantalla al finalrubentejera.com testsobjetostablaspantalla
Primero, el pliego de condiciones: los requisitos escritos como tests. Luego, la estructura, que son los objetos; las instalaciones, que son las tablas, y al final los acabados: la pantalla.

Es habitual que un proyecto empiece con unas pantallas dibujadas en una herramienta de diseño y un esquema de tablas. Parece lo lógico: así todo el mundo «ve» lo que se va a construir. El problema llega después, cuando el negocio cambia y el código está organizado alrededor de unas pantallas y unas tablas, no de lo que el cliente necesitaba.

La idea de este artículo viene del libro Diseño Ágil con TDD, de Carlos Blé (edición de 2010, apartado 1.7, «Los roles dentro del equipo»): las pantallas no se diseñan al comienzo, sino al final, cuando los requisitos de negocio ya se cumplen.

Encaja con el agilismo, que da prioridad a entregar pronto software que funcione.

Por qué la pantalla va al final

Los requisitos son frases cortas en lenguaje natural que una máquina puede ejecutar automáticamente, porque tienen forma de test. Así se sabe con certeza cuándo se han implementado: cuando el test pasa.

Si las pantallas se diseñan primero, se contamina la lógica de negocio con la interpretación que el diseñador haga de los requisitos. Blé añade la consecuencia: se corre el riesgo de escribir código sujeto a la interfaz en lugar de a los requisitos, y eso lo hace difícil de modificar cuando el negocio cambie.

Piensa en una obra. Primero se escribe el pliego de condiciones (qué tiene que cumplir el edificio), luego se levanta la estructura, después se meten las instalaciones y, al final, se hacen los acabados. Si empiezas por elegir los azulejos, acabas adaptando la casa a unos acabados que no le van. El símil tiene un límite: los acabados no son un detalle menor, porque es lo que ve quien vive allí. Con la interfaz pasa lo mismo: va la última en el orden de trabajo, no en importancia.

La pantalla es la carcasa, no los cimientos.

El flow de desarrollo ágil en 4 pasos

  1. Se piensan los requisitos y se escriben como tests de aceptación: ejemplos concretos de lo que el sistema debe hacer.
  2. Se implementan objetos que hacen pasar esos tests. Aquí vive la lógica de negocio.
  3. Se crean las tablas en una base de datos (o el almacenamiento que toque) cuando los objetos necesitan guardar algo.
  4. Se crea la interfaz gráfica, que solo tiene que llamar a lo que ya funciona.

Blé lo resume así en el libro: «Pensamos en requisitos, implementamos objetos, luego bajamos a tablas en una base de datos relacional y finalmente le ponemos una carcasa a la aplicación que se llama interfaz gráfica de usuario. No al revés».

Los requisitos los define quien conoce el negocio, normalmente el dueño del producto (product owner) con ayuda de un analista. Su papel es decir qué se necesita; el cómo, incluidas las pantallas y las tablas, lo decide el equipo de desarrollo. Cuando alguien entrega al equipo las pantallas ya dibujadas y las tablas ya diseñadas, está decidiendo el cómo sin que le toque.

Un ejemplo: añadir un libro al carrito

Este es uno de los ejemplos del capítulo 3 del libro, el de una tienda de libros. El requisito, en frases cortas:

  • Añadir el libro X en stock produce: «El libro X ha sido añadido al carrito».
  • El libro X está en el carrito.
  • El libro X ya no está en el catálogo.

Paso 1: el requisito como test. Con el corredor de tests que trae Node (node:test), cada frase se convierte en un test que se puede ejecutar:

// tienda.test.mjs
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { Tienda } from './tienda.mjs';

test('añadir un libro en stock avisa de que se ha añadido al carrito', () => {
  const tienda = new Tienda(['Diseño Ágil con TDD']);

  const mensaje = tienda.anadirAlCarrito('Diseño Ágil con TDD');

  assert.equal(mensaje, 'El libro Diseño Ágil con TDD ha sido añadido al carrito');
});

test('el libro añadido está en el carrito y ya no en el catálogo', () => {
  const tienda = new Tienda(['Diseño Ágil con TDD']);

  tienda.anadirAlCarrito('Diseño Ágil con TDD');

  assert.deepEqual(tienda.carrito, ['Diseño Ágil con TDD']);
  assert.deepEqual(tienda.catalogo, []);
});

Paso 2: el objeto que lo cumple. Lo mínimo para que los dos tests pasen, sin base de datos ni pantalla:

// tienda.mjs
export class Tienda {
  constructor(catalogo) {
    this.catalogo = [...catalogo];
    this.carrito = [];
  }

  anadirAlCarrito(libro) {
    this.catalogo = this.catalogo.filter((titulo) => titulo !== libro);
    this.carrito.push(libro);
    return `El libro ${libro} ha sido añadido al carrito`;
  }
}

Ejecuta node --test y los dos tests pasan. El requisito ya se cumple y todavía no existe ninguna pantalla ni ninguna tabla.

Pasos 3 y 4: datos e interfaz. Cuando haga falta que el carrito sobreviva a un reinicio, se guardará en una base de datos. Y la pantalla, cuando llegue, solo tendrá que llamar a anadirAlCarrito y mostrar el mensaje. Si mañana cambia el diseño de la web, o la tienda pasa a tener también una aplicación móvil, la lógica no se toca.

Cuándo no hace falta seguir este orden

  • Si la aplicación solo guarda y recupera datos, sin reglas de negocio, el propio Blé admite en una nota del libro que es aceptable empezar por los datos.
  • Esbozar una pantalla para hablar con el cliente no es lo mismo que diseñarla primero. Un boceto ayuda a conversar; lo que este flujo evita es que ese boceto decida cómo se organiza el código.

Este recorrido, desde el test de aceptación hasta la capa de datos, encaja con el enfoque outside-in: empezar por lo que pide el negocio e ir bajando hacia los detalles técnicos. Tienes la comparación con el enfoque contrario en Inside-out TDD y outside-in TDD.

Y si programas con IA

Lo que sigue es criterio propio del enfoque IA Limpia, no algo que diga el libro. Pedirle a un agente «hazme la pantalla del carrito» es empezar por el paso 4: el resultado se ve bien, pero la lógica queda mezclada con la interfaz. Funciona mejor seguir el mismo orden:

  1. Escribe tú los requisitos como tests, o revisa con cuidado los que proponga el agente.
  2. Pide al agente el código que los hace pasar, sin interfaz.
  3. Deja la base de datos y la pantalla para el final, cuando los tests ya estén en verde.

Así los tests te dicen si lo que ha generado cumple el requisito, sin depender de que la pantalla «parezca» funcionar.

Fuentes

Comprobado el 7 de noviembre de 2026.

  • Carlos Blé Jurado y colaboradores, Diseño Ágil con TDD, primera edición (2010), con licencia Creative Commons. Leído en la copia archivada del PDF en Internet Archive, porque el enlace original de carlosble.com ya no funciona. Las ideas y la cita salen del apartado 1.7 (páginas 44 y 45, con la nota 19 sobre empezar por los datos) y el ejemplo del carrito, del apartado 3.1 (páginas 60 a 62). Las ediciones actuales del libro están en Savvily.
  • Node.js: documentación de node:test (Node 24). El ejemplo se ha ejecutado con Node 24.21.0 en Linux: los dos tests pasan.
  • El símil de la obra y la sección sobre IA son interpretación nuestra, no del libro.