Saltar al contenido
Programemos.netDecisiones pragmáticas sobre .NET, Azure, arquitectura de software e IA.

Serie: De demo a producción · Parte 8 de 8

Vibe coding con DDD: qué comprobar antes de aceptar el cambio

He visto casos de personas que trabajaban en empresas con microservicios y usaban vibe coding. El sistema estaba diseñado con DDD, pero la aplicación terminó haciendo llamadas e inserciones directas a la base de datos, saltándose el dominio.

¿Funcionaba? Sí. Ese era precisamente el problema: el cambio podía parecer correcto sin respetar las reglas del sistema.

Cuando veo una demo donde un agente crea un backend, un frontend y una base de datos en minutos, pienso en ese caso. La velocidad impresiona. Pero lo que quiero saber es qué ocurre cuando el requerimiento nuevo toca un pedido confirmado, un contrato entre servicios o datos que ya existen y no se pueden romper.

Qué estoy llamando vibe coding

Uso la distinción de Simon Willison: construir software con un LLM sin revisar el código que escribe. Si revisas lo generado, lo pruebas y puedes explicar cómo funciona, estás haciendo desarrollo de software asistido por IA. La herramienta no elimina ese trabajo.

Yo también programo con IA. Mi crítica es a presentar una demo como evidencia suficiente para confiarle cualquier cambio en un sistema existente. Una fábrica que crea una aplicación desde cero todavía tiene que demostrar cómo respeta las decisiones y restricciones de la que ya tenemos.

El INSERT que pasa por debajo del dominio

Para explicar el problema, voy a usar un ejemplo hipotético en .NET. No es el código del caso que mencioné. Tenemos un pedido que solo admite líneas mientras está en borrador y exige cantidades positivas:

La operación del agregado
public void AgregarLinea(Guid productoId, int cantidad, decimal precio)
{
if (Estado != EstadoPedido.Borrador)
throw new InvalidOperationException("El pedido ya está confirmado.");
if (cantidad <= 0)
throw new ArgumentOutOfRangeException(nameof(cantidad));
_lineas.Add(new LineaPedido(productoId, cantidad, precio));
AgregarEvento(new TotalPedidoCambiado(Id, Total));
}

Es un fragmento conceptual de la raíz Pedido, con el resto de la clase omitido. Total se supone calculado a partir de sus líneas. AgregarEvento solo registra el evento de dominio pendiente: no envía por sí mismo un mensaje a otro servicio. En este ejemplo, la aplicación procesa ese evento y publica la notificación de integración después de persistir el cambio. Esa infraestructura también está omitida; la guía de Microsoft distingue los eventos de dominio de los de integración.

Ahora imaginemos que pedimos agregar una línea y aceptamos este atajo:

La escritura que evita la operación
await connection.ExecuteAsync(
"INSERT INTO LineasPedido (PedidoId, ProductoId, Cantidad, Precio) VALUES (@PedidoId, @ProductoId, @Cantidad, @Precio)",
nuevaLinea);

Si la base de datos no impone restricciones equivalentes, ese INSERT permite agregar una línea a un pedido confirmado o con una cantidad inválida. Tampoco registra el evento del agregado. En el flujo que estamos suponiendo, facturación queda sin la notificación que esperaba.

Las dos rutas pueden devolver una respuesta satisfactoria para un pedido en borrador con datos válidos. La diferencia aparece al intentar algo que el negocio prohíbe. Ahí está el boquete que una demo del flujo feliz no muestra.

Comparación del cambio permitido de un pedido, con validación, persistencia e integración, y un INSERT que evita el agregado y no registra el evento
El agregado protege las reglas. Persistir el cambio y entregar la notificación son pasos distintos que también hay que comprobar.

El problema no es usar SQL ni elegir Dapper en lugar de Entity Framework. Es evitar la operación que contiene las reglas sin hacerse cargo de preservarlas. En un modelo con agregados, la raíz controla las invariantes y los cambios sobre sus entidades. Si decidimos saltarnos ese punto, hay que explicar dónde quedan esas garantías.

Hay otro límite distinto: escribir en las tablas de otro microservicio. En ese caso, además de evitar sus reglas, dependemos de su estructura interna de datos. La soberanía de datos por microservicio exige que los demás accedan mediante sus contratos, por API o mensajería. Un atajo dentro del servicio y una invasión de los datos de otro no son exactamente el mismo fallo, aunque ambos puedan empezar con un INSERT que funciona.

Lo que más me preocupa es que el atajo se convierta en ejemplo. La próxima persona, o el propio agente, encuentra una escritura directa y la toma como una convención del proyecto. Así una excepción que nadie discutió termina guiando los siguientes cambios. Después cuesta distinguir qué parte del sistema todavía respeta el dominio.

El contexto ayuda; la comprobación decide

Unas instrucciones claras pueden evitar buena parte del problema:

No escribas en la base de datos de otro servicio.
Para modificar un pedido, usa las operaciones de su raíz de agregado.
Comprueba que un pedido confirmado rechaza líneas nuevas.
Explica cómo se persiste el cambio y cómo llega la notificación a facturación.

Pero escribir esas líneas exige conocer el sistema. Y tenerlas en un archivo no demuestra que el cambio las haya cumplido. Yo pediría al agente que identifique la operación existente, señale las pruebas que protegen esas reglas y muestre el resultado de ejecutarlas.

Un agente puede descubrir restricciones al explorar el repositorio e incluso señalar huecos que nosotros pasamos por alto. Bienvenido sea. Lo que no daría por hecho es que siempre encontrará todas las reglas relevantes, sobre todo las que solo conoce el equipo o nunca quedaron escritas.

Tampoco convertiría esto en una obligación de aplicar DDD a todo. Un CRUD sencillo puede necesitar una solución mucho más directa. La propia guía de Microsoft contempla ese caso. Aquí hablamos de un sistema que ya tiene un dominio con reglas: cambiarlo exige entender qué protege y decidir explícitamente si esa protección sigue haciendo falta.

Qué probaría antes de confiar en la fábrica

Siguiendo con el pedido, no empezaría levantando todos los microservicios. Separaría lo que necesito comprobar:

  • La regla del pedido: una prueba del agregado debe rechazar una línea nueva cuando ya está confirmado. No necesita facturación ni un broker para demostrarlo.
  • La ruta real de escritura: una prueba del caso de uso debe demostrar que el endpoint también rechaza esa operación y deja las líneas sin cambios. Así podemos detectar un atajo que las pruebas aisladas del agregado no ven.
  • La notificación: una prueba de integración debe comprobar el recorrido acordado desde la persistencia hasta el mensaje para facturación. Registrar un evento en memoria no basta para dar ese recorrido por probado.
  • El contrato entre servicios: comprobaría que el mensaje publicado conserva los campos y el significado que espera su consumidor. Simular facturación puede ser útil, siempre que el simulado represente el contrato real.

La IA puede ayudar a preparar esas pruebas y su infraestructura. Nosotros tenemos que decidir qué confianza necesitamos obtener. Una prueba del agregado protege una regla; una prueba del endpoint comprueba que el cambio no la esquive. Ninguna sustituye a la otra.

Para las pruebas que sí usan base de datos o mensajería hacen falta datos coherentes, configuración y credenciales del entorno de pruebas. Eso también forma parte de la fábrica. Si en el video solo vemos pruebas unitarias en verde, todavía no sabemos qué ocurre al persistir el cambio o entregarlo a otro servicio.

El trabajo que sigue requiriendo criterio

Creo que escribir código va a ocupar una parte cada vez menor del esfuerzo de muchos cambios. Entender qué se puede tocar, qué regla debe mantenerse y qué evidencia permite aprobarlo sigue siendo trabajo de ingeniería. Lo haga alguien llamado programador, desarrollador o arquitecto.

Antes de confiar en una fábrica de IA para este pedido, yo querría respuestas concretas. ¿Qué servicio es dueño de los datos? ¿Qué operación protege el pedido confirmado? ¿Qué prueba fallaría si alguien vuelve a introducir el INSERT? ¿Cómo comprobamos que facturación recibe el cambio permitido?

No necesito que la fábrica tenga más agentes. Necesito poder seguir esas respuestas desde el requerimiento hasta las comprobaciones del cambio.

Ya lo había comentado al hablar de reglas o herramientas en la arquitectura de software: los patrones sirven cuando entendemos qué problema resuelven. Con IA, ese criterio también sirve para reconocer cuándo una solución rápida abrió un camino que el resto del sistema no estaba preparado para aceptar.

Jose Antonio Arias
Jose Antonio Arias

Senior .NET Developer e Ingeniero en Informática con amplia experiencia en backend, Azure, DevOps, arquitectura e IA empresarial. Ayudo a convertir problemas y procesos de negocio en soluciones tecnológicas con valor real.