Tengo un sistema donde un modelo decide y el dinero se compromete en menos de 60 segundos. Lo que impide un desastre no es el prompt: son seis candados escritos en código, y la lección de una regla que vivía en tres sitios a la vez.
Alexis Dorado Muñoz
Fundador de 24Bytes
17 de noviembre de 2026
7 min de lectura

Opero un sistema donde un modelo de lenguaje evalúa decenas de candidatos cada tarde, decide cuáles merecen publicarse y, en los sesenta segundos siguientes, el dinero queda comprometido. No es un chatbot: es una cadena automática donde una salida del modelo se convierte en una operación real.
La pregunta incómoda de un sistema así no es si el modelo acierta. Es qué pasa cuando no acierta, y cuánto tarda en notarse.
La respuesta corta: eso no se arregla en el prompt. Un modelo "casi siempre" obedece la instrucción, y en seguridad "casi" no es una medida de nada. Lo que de verdad protege son reglas escritas en código: funciones que se pueden probar, interruptores que alguien tiene que accionar, validaciones que corren antes de que el dinero se mueva.
El reparto está escrito y es explícito. El modelo tiene una parcela grande, pero no toca ninguna palanca:
Esa frontera no es filosofía. Es la diferencia entre "le pedí al modelo que no superara cierto límite" y "el límite se comprueba en una función que no puede saltarse", y se nota el día que el modelo devuelve algo inesperado: una categoría que no existe, un número fuera de rango, una respuesta a medias por un error del proveedor.
El episodio que me enseñó esto no lo provocó ninguna alucinación. La regla era correcta. El problema es que estaba escrita en tres sitios distintos.
Había un filtro que degradaba los candidatos fuera de cierto rango. Había una segunda comprobación —la única que se consultaba justo antes de comprometer dinero— que usaba un rango propio, más ancho por los dos lados. Y había una tercera vía, un rescate de casos límite, que directamente no volvía a mirar ese valor.
Ninguna de las tres estaba mal por separado. Juntas se contradecían, y el sistema se contradecía por escrito: en la auditoría aparecían operaciones con una anotación interna que decía textualmente que ese candidato había sido degradado por el filtro… y que aun así habían seguido adelante. No fue un fallo de juicio de nadie: fue una regla duplicada que nadie había conciliado.
Una regla escrita en tres sitios no es una regla. Son tres reglas que todavía no se han peleado.
El arreglo no fue añadir una advertencia al prompt ni un if más. Fue reducirlo a una sola función pura —sin base de datos, sin framework— que resuelve el rango una vez y a la que llaman tanto el filtro como la publicación. Lógica pura significa que se puede probar en milisegundos, sin levantar nada, y que la prueba dice literalmente lo que el negocio necesita:
Ese test no comprueba un detalle de implementación: comprueba que dos caminos distintos siguen de acuerdo. Es la clase de prueba que no se escribe por cobertura, sino porque ya la pagaste una vez.
Ninguno es ingenioso. Todos son aburridos, que es exactamente lo que se quiere:
catch vacío se la tragó durante semanas.A los que hay que sumar uno menos obvio: cada proceso solo acepta las órdenes que le corresponden. Las peticiones llevan un mapa de ruta a rol, y si una llega al proceso equivocado se rechaza. No basta con que el endpoint exista; importa quién lo recibe.
El freno automático me bloqueó un día que acertó cuatro de cuatro. Si hubiera estado abierto, habría sido un buen día.
No lo quité. Un candado que solo actúa cuando te conviene no es un candado: es una sugerencia. El coste de ese día es el precio del seguro, y lo elegí en frío sabiendo que algún día me iba a doler en caliente. Lo mismo vale para el despliegue que se niega a correr si no puede verificar el respaldo previo, del que escribí hace unas semanas: esa negativa descubrió un problema que ningún escáner había visto.
La regla general que saco de ambos: una protección que nunca te ha estorbado probablemente no está mirando nada.
Si estás montando algo con IA dentro, estas cuatro preguntas separan lo que puede vivir en el prompt de lo que no:
Hay una quinta, menos técnica y más incómoda: ¿cuánto tardarías en enterarte? En mi caso, lo que destapó la divergencia de los tres rangos no fue un error en producción —todo "funcionaba"— sino una auditoría que comparó lo que el sistema decía con lo que el sistema hacía. Esa comparación conviene tenerla automatizada, porque a ojo no se ve: el sistema se contradecía en silencio y con total educación.
Casi todo el discurso sobre IA está en la capa visible: qué modelo, qué tan bueno es el prompt, cuánto contexto aguanta. Esa capa cambia cada tres meses y no es donde ocurren los accidentes.
Los accidentes ocurren en la fontanería: un límite escrito en dos sitios, un endpoint interno que alguien supuso inalcanzable, un flujo sin interruptor, una configuración que falla en silencio. Por eso, cuando alguien me enseña su sistema, no empiezo preguntando por el modelo. Pregunto:
Cuando el modelo se equivoque —y se va a equivocar—, ¿qué línea de código impide que ese error llegue al dinero?
Si la respuesta es "le decimos en el prompt que no haga eso", ya tienes tu primer trabajo pendiente.
Si la respuesta es "el modelo sabe que no debe hacer eso", conviene revisarlo antes de que lo demuestre. Montar y operar sistemas así es parte de lo que hago.