Cresium Engineering

12 min de lecturaEquipo de ingeniería

Cómo escalamos la programación con agentes de forma segura en la industria fintech

Cómo estandarizamos nuestras prácticas de código en todos los repos, para que el código de personas y de agentes cumpla la misma vara.

San Jerónimo pasó más de veinte años convirtiendo manuscritos dispersos en la Vulgata, la única Biblia latina de la que leyó toda la Iglesia durante más de mil años. Nuestro cresium-mode hace una versión mucho más chica del mismo trabajo: muchas fuentes, un solo texto del que trabajan todos.
Antonello da Messina, San Jerónimo en su estudio, c. 1475 (detalle). National Gallery, Londres.

Estamos viviendo un momento raro en el desarrollo de software. En los últimos años, los LLMs nos hicieron exponencialmente más productivos, pero también trajeron un problema enorme de escalabilidad, mantenibilidad y slop.

En Cresium tenemos una política que no se negocia, construida sobre tres principios:

  • El código tiene que ser escalable, claro y mantenible.
  • Cada línea que sale a producción la revisó y la entiende por completo la persona que la mandó.
  • La escalabilidad a largo plazo le gana a la velocidad a corto plazo.

Somos una fintech. No podemos faltarle el respeto a nuestro codebase sacando productos sin saber qué hacen por debajo, y no podemos dejar la plata de nuestros clientes librada al criterio de un LLM. Nos auditan instituciones financieras, y todo el negocio corre sobre lo que construye Ingeniería. Todo lo que mergeamos y deployamos a producción exige una atención al detalle meticulosa, obsesiva.

En nuestro caso, el problema se amplifica por cómo está dividido el codebase. No usamos microservicios. Mage, nuestro backend, y Druid, nuestro frontend, se parecen más a un monolito cada uno, con varios servicios adentro, y viven en repositorios separados. Al lado hay dos repos mucho más chicos: Knight, que se encarga del onboarding, y Archer, nuestro servicio de notificaciones.

Aclaremos: correr todo esto en local es un problema resuelto. Cualquier ingeniero levanta el stack completo con un solo comando y lo tiene funcionando de punta a punta. La infraestructura local no es lo que nos frena. El verdadero desafío es mantener estándares consistentes entre repositorios cuando los agentes de IA escriben la mayor parte del código.

Un monorepo puede parecer una salida, y a corto o mediano plazo quizás alivie algo de la fricción. Pero a largo plazo no escala para nosotros: el ownership se vuelve difuso, la responsabilidad se diluye y sacar cosas a producción se vuelve más difícil, no más fácil. Mantener repositorios separados es una decisión deliberada, y aceptamos el trade-off: estandarizar es más difícil hoy a cambio de escalabilidad mañana.

Eso nos puso frente a una pregunta difícil en los últimos meses: ¿cómo nos movemos a una velocidad competitiva de verdad sin bajar los estándares de código que sostenemos en cada servicio?

Descubrimiento

El camino

Este problema no es nuevo para nosotros. Antes de llegar a lo que usamos hoy, pasamos por una serie de soluciones parciales, cada una atrapando un poco más que la anterior.

Dos años y medio escribiendo nuestros comentarios de review. El primer paso tardó 17 meses; los últimos cinco, siete.

El primero fue un hook de pre-commit con husky, que agregamos a Druid, nuestro frontend, en abril de 2024. Antes de cada commit corría el formatter y los autofixes del linter. Eso sacó el formato de la review, pero no atrapaba nada de lo que los reviewers comentaban de verdad. En septiembre de 2025 llegó nuestra primera regla de IA: una regla de Cursor de cinco líneas, escrita en español, sobre cómo envolver los íconos en el frontend. En marzo de 2026 le dimos a Druid un AGENTS.md en serio, con siete archivos de reglas detrás, y una semana después una review agéntica en CI. Cualquiera puede dispararla en un pull request, y revisa el diff contra un prompt con nuestras convenciones. Una de esas líneas era “Usá Decimal.js para montos”, porque la aritmética nativa de JavaScript pierde precisión con los montos, y los reviewers tenían que repetirlo una y otra vez.

Después las reglas empezaron a apilarse. Cada vez que un reviewer encontraba algo nuevo, se convertía en otro párrafo, y las reglas de Druid pasaron de unas 540 líneas en abril a más de 1.500 en octubre, repartidas en 14 archivos. Más reglas no hicieron mejor al agente. Así que dimos un paso atrás y repasamos los comentarios que los reviewers habían dejado en nuestros pull requests anteriores, y sacamos los que aparecían una y otra vez. Muchos no necesitaban ningún criterio. “Usá Decimal para montos” es un patrón que un linter puede encontrar, así que se convirtió en una regla propia de ESLint, money-requires-decimal, junto con otras cinco como no-unnecessary-cast y no-enum-string-literal. En Mage, las reglas mecánicas también pasaron al linter, y las escritas se dividieron en una capa común que cualquier repo de backend puede copiar y una capa que solo aplica a Mage. Cuando activamos las reglas nuevas en Druid, encontraron 776 violaciones existentes en 374 archivos. Lo que antes un reviewer atrapaba en algunos pull requests, ahora el build lo atrapa en todos.

La misma revisión dejó claro que el codebase en sí era parte del estándar. Los agentes usan el código existente como referencia, incluidos los patrones que ya no queremos que se repitan. Cuando el código y la guía escrita no coinciden, agregar otra instrucción no lo arregla. Mantener buenos ejemplos y sacar los patrones obsoletos pasó a ser parte de cómo trabajamos con agentes, junto con mejorar las reglas que les damos.

Eso dejó una pregunta nueva: ¿cómo mantenés un mismo estándar sincronizado en todos los repos sin copiarlo a mano?

Solución

Movimos los estándares a Cleric, nuestro repositorio de herramientas compartidas, y los dividimos según cómo se aplican. Las convenciones que una máquina puede chequear viven en nuestras configuraciones de ESLint y de formato. La guía que necesita criterio de ingeniería vive en cresium-mode, un plugin que usamos para implementar y revisar en cada repositorio.

El plugin contiene los estándares compartidos, organizados en skills y referencias acotadas. Cada repositorio mantiene su propia arquitectura, sus convenciones de dominio y sus comandos de verificación, más un perfil que dice qué partes del estándar aplican. Una librería no hereda reglas de controllers porque corre en Node, y una tarea de frontend no necesita las convenciones de servicios del backend.

Esto nos da una sola fuente sin volver idéntico a cada repositorio. Un cambio en una convención compartida va en Cleric. Una decisión propia de pagos, de onboarding o de un feature del frontend se queda con el código que describe.

Los mismos criterios para implementar y revisar

La implementación y la review usan las mismas definiciones de reglas. El reviewer en CI carga el plugin compartido junto con la guía local del repositorio, en lugar de mantener otra copia del estándar en su prompt. Un desarrollador trabajando en local y un reviewer chequeando el pull request leen de la misma fuente.

Esto importa más en las decisiones que un linter no puede resolver. Un límite de parámetros puede marcar un tipo de complejidad, pero no puede decir si un método de un servicio es una operación coherente. Tampoco puede decidir si extraer un sub-servicio haría el código más fácil de entender. Esas decisiones necesitan criterios y ejemplos, incluidos los casos en que mantener la lógica junta es la mejor opción.

Cada regla registra de dónde vino. Eso nos ayuda a distinguir una convención acordada de una sugerencia hecha en una sola review. También nos da contexto cuando volvemos sobre la decisión.

La guía relevante para cada tarea

El plugin arranca desde un punto de entrada corto y carga solo la guía relevante para el trabajo. Los perfiles de cada repositorio definen qué aplica, y los flujos de implementación y review eligen el detalle que necesita cada tarea.

Esto sigue el enfoque de la guía de context engineering de Anthropic. Pero las evaluaciones de Vercel muestran por qué empaquetar contenido como skill no alcanza: un agente puede no leer nunca una skill que tiene disponible. Por eso verificamos por separado la instalación, la carga y la selección de reglas. Tener el contenido en el plugin no es lo mismo que meter el contenido correcto en el contexto del agente.

Mantener el estándar

Un estándar compartido necesita una forma de evolucionar sin convertir cada comentario de review en una instrucción nueva. El plugin incluye un flujo de mantenimiento para cambios y huecos concretos: una convención que evoluciona, un alcance que hay que ajustar, o guías que se contradicen.

Antes de agregar guía, el flujo chequea si alguna regla existente ya cubre el problema. También chequea si el cambio pertenece al estándar compartido. Los criterios nuevos o revisados necesitan un alcance claro, una justificación, ejemplos y contraejemplos. Los cambios de política requieren la aprobación de un maintainer; el feedback de los agentes es evidencia para que el equipo la evalúe.

El flujo también chequea cómo funciona la guía en la práctica: si una regla tiene sentido en casos concretos, si llega a las tareas para las que está pensada, y si se aplica de forma consistente al implementar y al revisar. El plugin hace que estos chequeos sean repetibles. Los ingenieros siguen decidiendo qué aprendizajes pasan a ser parte del estándar.

Conclusión

El orden importa. Empezá por el codebase que el agente va a usar como referencia. Dejá clara la estructura que buscás, mantené buenos ejemplos y sacá los patrones que ya no querés que se repitan. Después automatizá los chequeos que se pueden definir con precisión, y documentá las decisiones que todavía necesitan contexto.

El error que nos saltearíamos es tratar cada corrección repetida como un pedido de más instrucciones. Algunas revelan un hueco en las herramientas. Otras apuntan a código inconsistente, o a una decisión que el equipo todavía no acordó. Un archivo de reglas más largo no resuelve todos esos problemas.

Un estándar compartido nos da una forma de mantener esas decisiones entre repositorios y aplicarlas tanto al implementar como al revisar. No reemplaza la responsabilidad del ingeniero sobre el resultado. El objetivo es pasar menos tiempo de review repitiendo convenciones, y más tiempo entendiendo el comportamiento, chequeando decisiones de dominio y decidiendo si el cambio es uno que queremos mantener. Acordate: el slop no es algo que te pasa. Es algo que dejás pasar.