<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Julián Cardozo</title>
    <description>The latest articles on DEV Community by Julián Cardozo (@julian_cardozo_dev).</description>
    <link>https://dev.to/julian_cardozo_dev</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4248658%2F8daa8ad1-c559-4043-8478-eaf588306f7f.jpg</url>
      <title>DEV Community: Julián Cardozo</title>
      <link>https://dev.to/julian_cardozo_dev</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/julian_cardozo_dev"/>
    <language>en</language>
    <item>
      <title>Floci: llevar la nube al entorno local sin perder el control arquitectónico</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:32:02 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/floci-llevar-la-nube-al-entorno-local-sin-perder-el-control-arquitectonico-eb0</link>
      <guid>https://dev.to/julian_cardozo_dev/floci-llevar-la-nube-al-entorno-local-sin-perder-el-control-arquitectonico-eb0</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/floci-emulacion-cloud-local-platform-engineering/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Un desarrollador necesita validar un cambio en un servicio que guarda archivos en S3 y publica eventos en SQS. La aplicación levanta en su máquina, pero probarla de verdad requiere credenciales de una cuenta de desarrollo, permisos que gestiona otro equipo, una VPN y un ambiente de integración compartido que a esa hora usan otras tres personas. Cada uno de esos pasos agrega espera y variabilidad a un ciclo que debería durar segundos. Este artículo analiza Floci, un ecosistema open source de emuladores cloud locales, a partir de una tesis: la velocidad del feedback es una propiedad del diseño de la plataforma, no un esfuerzo individual de cada desarrollador. Las capacidades que se mencionan son las declaradas en los repositorios oficiales al 15 de noviembre de 2026; las conclusiones son propias y se señalan como tales.&lt;/p&gt;

&lt;h2&gt;
  
  
  La dependencia invisible de la nube
&lt;/h2&gt;

&lt;p&gt;En un equipo que desarrolla aplicaciones cloud-native, levantar el servicio en local no equivale a poder probarlo. El código arranca, pero cada llamada a almacenamiento, colas, secretos o identidad sale de la máquina hacia una cuenta remota. Esa dependencia rara vez aparece en los diagramas de arquitectura y, sin embargo, determina buena parte de la experiencia de desarrollo.&lt;/p&gt;

&lt;p&gt;Sus efectos se acumulan en cuatro lugares. En el &lt;strong&gt;onboarding&lt;/strong&gt;, porque una persona nueva no puede ejecutar las pruebas de integración hasta tener acceso a la cuenta correcta. En el &lt;strong&gt;debugging&lt;/strong&gt;, porque reproducir un error que depende del estado de un ambiente compartido es difícil y a veces imposible. En el &lt;strong&gt;testing&lt;/strong&gt;, porque las pruebas que tocan servicios reales son lentas, costosas o inestables, y terminan desactivándose. Y en la &lt;strong&gt;autonomía&lt;/strong&gt;, porque cada ajuste de permisos o de infraestructura de desarrollo pasa por la cola de otro equipo.&lt;/p&gt;

&lt;p&gt;Desde Platform Engineering, el problema no es que los desarrolladores tengan que esperar, sino que la plataforma convierte esa espera en el camino por defecto. Si la forma más fácil de probar un cambio es abrir un pull request y esperar al pipeline, el ciclo de feedback se mide en decenas de minutos aunque el cambio sea trivial. El principio de que el camino correcto debe ser el más fácil aplica también acá: probar contra dependencias realistas debería ser más fácil que no probar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué es Floci
&lt;/h2&gt;

&lt;p&gt;Floci es una familia de emuladores open source, publicados bajo licencia MIT, que exponen APIs con la forma de los servicios de cuatro nubes en un entorno local. El repositorio principal, &lt;a href="https://github.com/floci-io/floci" rel="noopener noreferrer"&gt;floci&lt;/a&gt;, emula AWS en el puerto 4566. Lo acompañan &lt;a href="https://github.com/floci-io/floci-az" rel="noopener noreferrer"&gt;floci-az&lt;/a&gt; para Azure (puerto 4577), &lt;a href="https://github.com/floci-io/floci-gcp" rel="noopener noreferrer"&gt;floci-gcp&lt;/a&gt; para GCP (4588) y &lt;a href="https://github.com/floci-io/floci-oci" rel="noopener noreferrer"&gt;floci-oci&lt;/a&gt; para Oracle Cloud (4599). Alrededor de ellos hay una CLI (&lt;a href="https://github.com/floci-io/floci-cli" rel="noopener noreferrer"&gt;floci-cli&lt;/a&gt;), una consola web (&lt;a href="https://github.com/floci-io/floci-ui" rel="noopener noreferrer"&gt;floci-ui&lt;/a&gt;) que muestra solo lo que devuelven los emuladores, y módulos de Testcontainers para Java, Node.js, Python, .NET y Go.&lt;/p&gt;

&lt;p&gt;Emular una API cloud significa implementar el protocolo de red del servicio, de modo que un cliente estándar, como el AWS SDK, la CLI o Terraform, funcione sin cambios salvo la URL de destino. Conviene distinguirlo de otras tres opciones. Un &lt;strong&gt;mock&lt;/strong&gt; reemplaza al cliente dentro del proceso de pruebas y verifica que se lo llamó, pero no ejecuta el protocolo. Un &lt;strong&gt;contenedor con la tecnología real&lt;/strong&gt;, como PostgreSQL detrás de una API con forma de RDS, ejecuta el motor auténtico pero no la capa administrada del proveedor. La &lt;strong&gt;infraestructura de producción&lt;/strong&gt; es la única que reproduce el comportamiento completo, con sus permisos, cuotas y fallas. Floci combina las dos primeras: emula en proceso la mayoría de las APIs y delega en contenedores reales los servicios donde la fidelidad depende del motor.&lt;/p&gt;

&lt;h2&gt;
  
  
  Arquitectura: cómo funciona por dentro
&lt;/h2&gt;

&lt;p&gt;Según el README y el código del repositorio, el emulador de AWS es una aplicación Java construida con Quarkus (versión 3.40.1.1 al momento de esta revisión) y compilada a Java 25, que se distribuye como imagen nativa de GraalVM y como binario independiente. Un enrutador HTTP basado en JAX-RS y Vert.x recibe todas las peticiones en un único puerto y las dirige al servicio correspondiente según el protocolo de AWS de cada llamada.&lt;/p&gt;

&lt;p&gt;Los servicios se dividen en tres grupos. La mayoría, como SQS, SNS, IAM, KMS, Secrets Manager o Step Functions, se emulan en proceso. S3 y DynamoDB también corren en proceso, pero con estado persistible. Un tercer grupo, que incluye Lambda, RDS, ElastiCache, MSK, ECS, EKS y OpenSearch, levanta contenedores Docker reales a través del socket del host: RDS usa &lt;code&gt;postgres:16-alpine&lt;/code&gt; o &lt;code&gt;mysql:8.0&lt;/code&gt;, MSK usa Redpanda y EKS usa k3s. Athena ejecuta SQL real mediante un sidecar basado en DuckDB.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Arquitectura del emulador de AWS, según la documentación del repositorio: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/floci-emulacion-cloud-local-platform-engineering/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;El estado se configura con &lt;code&gt;FLOCI_STORAGE_MODE&lt;/code&gt;: &lt;code&gt;memory&lt;/code&gt; para pruebas efímeras, &lt;code&gt;persistent&lt;/code&gt; con escritura inmediata a disco, &lt;code&gt;hybrid&lt;/code&gt; con volcados asíncronos cada cinco segundos y &lt;code&gt;wal&lt;/code&gt; con un registro previo a cada respuesta. El emulador también aísla recursos por cuenta: si la access key tiene doce dígitos, se usa como ID de cuenta, lo que permite probar flujos entre cuentas en local.&lt;/p&gt;

&lt;h3&gt;
  
  
  Los trade-offs del enfoque
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Un proceso para muchos servicios&lt;/strong&gt; simplifica la configuración, pero concentra el riesgo: un defecto en el enrutamiento afecta a todos los servicios a la vez.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;La emulación en proceso&lt;/strong&gt; es rápida y liviana, pero su fidelidad depende de cuánto del comportamiento real se haya reimplementado. Los contenedores reales mejoran la fidelidad del motor a cambio de más recursos y de requerir el socket de Docker, que otorga privilegios amplios sobre el host.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;La imagen nativa&lt;/strong&gt; reduce el tiempo de arranque y la memoria. El proyecto declara alrededor de 24 ms de arranque y 13 MiB de memoria en reposo, frente a 3,3 s y 143 MiB de LocalStack Community; son cifras del propio proyecto, no mediciones independientes.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Del concepto a la práctica: S3 y SQS con Spring Boot
&lt;/h2&gt;

&lt;p&gt;El ejemplo implementa un caso frecuente: un servicio recibe un documento por HTTP, lo guarda en S3 y publica un evento en SQS para que otro componente lo procese de forma asíncrona. Usa Java 21, Spring Boot 3.5.16, AWS SDK for Java v2 (2.59.1), JUnit 5, Testcontainers 1.21.4 y &lt;code&gt;testcontainers-floci&lt;/code&gt; 1.16.0, la línea compatible con Testcontainers 1.x. Para Spring Boot 4 y Testcontainers 2 corresponde la línea 2.x del módulo, cuyo artefacto es &lt;code&gt;testcontainers-floci-aws&lt;/code&gt;.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Qué se verificó:&lt;/strong&gt; El proyecto del ejemplo compila con esas versiones, resueltas desde Maven Central. La prueba de integración no se ejecutó en el entorno donde se escribió este artículo, porque no tenía Docker disponible; por eso no se informan resultados de ejecución.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;em&gt;El ejemplo en local y en pruebas: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/floci-emulacion-cloud-local-platform-engineering/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  Dependencias
&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;pom.xml (fragmento): el BOM del SDK y las dependencias de prueba&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight xml"&gt;&lt;code&gt;&lt;span class="nt"&gt;&amp;lt;parent&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.springframework.boot&lt;span class="nt"&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;spring-boot-starter-parent&lt;span class="nt"&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;version&amp;gt;&lt;/span&gt;3.5.16&lt;span class="nt"&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class="nt"&gt;&amp;lt;/parent&amp;gt;&lt;/span&gt;

&lt;span class="nt"&gt;&amp;lt;dependencyManagement&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;dependencies&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
      &lt;span class="nt"&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;software.amazon.awssdk&lt;span class="nt"&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
      &lt;span class="nt"&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;bom&lt;span class="nt"&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
      &lt;span class="nt"&gt;&amp;lt;version&amp;gt;&lt;/span&gt;2.59.1&lt;span class="nt"&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
      &lt;span class="nt"&gt;&amp;lt;type&amp;gt;&lt;/span&gt;pom&lt;span class="nt"&gt;&amp;lt;/type&amp;gt;&lt;/span&gt;
      &lt;span class="nt"&gt;&amp;lt;scope&amp;gt;&lt;/span&gt;import&lt;span class="nt"&gt;&amp;lt;/scope&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;/dependencies&amp;gt;&lt;/span&gt;
&lt;span class="nt"&gt;&amp;lt;/dependencyManagement&amp;gt;&lt;/span&gt;

&lt;span class="nt"&gt;&amp;lt;dependencies&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.springframework.boot&lt;span class="nt"&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;spring-boot-starter-web&lt;span class="nt"&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;software.amazon.awssdk&lt;span class="nt"&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;s3&lt;span class="nt"&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;software.amazon.awssdk&lt;span class="nt"&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;sqs&lt;span class="nt"&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.springframework.boot&lt;span class="nt"&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;spring-boot-starter-test&lt;span class="nt"&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;scope&amp;gt;&lt;/span&gt;test&lt;span class="nt"&gt;&amp;lt;/scope&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.testcontainers&lt;span class="nt"&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;junit-jupiter&lt;span class="nt"&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;  &lt;span class="c"&gt;&amp;lt;!-- 1.21.4, gestionada por Spring Boot --&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;scope&amp;gt;&lt;/span&gt;test&lt;span class="nt"&gt;&amp;lt;/scope&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;dependency&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;io.floci&lt;span class="nt"&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;testcontainers-floci&lt;span class="nt"&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;version&amp;gt;&lt;/span&gt;1.16.0&lt;span class="nt"&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
    &lt;span class="nt"&gt;&amp;lt;scope&amp;gt;&lt;/span&gt;test&lt;span class="nt"&gt;&amp;lt;/scope&amp;gt;&lt;/span&gt;
  &lt;span class="nt"&gt;&amp;lt;/dependency&amp;gt;&lt;/span&gt;
&lt;span class="nt"&gt;&amp;lt;/dependencies&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Configuración: el mismo código en local y en la nube
&lt;/h3&gt;

&lt;p&gt;La decisión de diseño más importante del ejemplo es que el código no sabe si habla con Floci o con AWS. La URL del emulador llega por configuración y, cuando está vacía, el SDK usa su resolución estándar de endpoints y credenciales. Así se evita mantener un perfil de código distinto para desarrollo.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;application.yml&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;app&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;aws&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;region&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${AWS_REGION:us-east-1}&lt;/span&gt;
    &lt;span class="na"&gt;endpoint&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${AWS_ENDPOINT_URL:}&lt;/span&gt;   &lt;span class="c1"&gt;# vacío en la nube real
&lt;/span&gt;    &lt;span class="na"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${DOCUMENTS_BUCKET:documents}&lt;/span&gt;
    &lt;span class="na"&gt;queue-name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${DOCUMENTS_QUEUE:document-events}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;AwsConfig.java: clientes del SDK con endpoint opcional&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;&lt;span class="nd"&gt;@ConfigurationProperties&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;prefix&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"app.aws"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="k"&gt;record&lt;/span&gt; &lt;span class="nc"&gt;AwsProperties&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;region&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;endpoint&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;queueName&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kt"&gt;boolean&lt;/span&gt; &lt;span class="nf"&gt;hasEndpointOverride&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;endpoint&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="k"&gt;null&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;endpoint&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;isBlank&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="nd"&gt;@Configuration&lt;/span&gt;
&lt;span class="nd"&gt;@EnableConfigurationProperties&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;AwsProperties&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="k"&gt;class&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;AwsConfig&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;

    &lt;span class="nd"&gt;@Bean&lt;/span&gt;
    &lt;span class="nc"&gt;S3Client&lt;/span&gt; &lt;span class="nf"&gt;s3Client&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;AwsProperties&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nc"&gt;S3ClientBuilder&lt;/span&gt; &lt;span class="n"&gt;builder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;S3Client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;region&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Region&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;of&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;region&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;hasEndpointOverride&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="c1"&gt;// Solo en local o en pruebas: emulador y URLs path-style.&lt;/span&gt;
            &lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;endpointOverride&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;URI&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;endpoint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;forcePathStyle&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;build&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="nd"&gt;@Bean&lt;/span&gt;
    &lt;span class="nc"&gt;SqsClient&lt;/span&gt; &lt;span class="nf"&gt;sqsClient&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;AwsProperties&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nc"&gt;SqsClientBuilder&lt;/span&gt; &lt;span class="n"&gt;builder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;SqsClient&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;region&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Region&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;of&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;region&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;hasEndpointOverride&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;endpointOverride&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;URI&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;endpoint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;build&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;DocumentService.java: guardar y publicar&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;&lt;span class="nd"&gt;@Service&lt;/span&gt;
&lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;DocumentService&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="kd"&gt;final&lt;/span&gt; &lt;span class="nc"&gt;S3Client&lt;/span&gt; &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="kd"&gt;final&lt;/span&gt; &lt;span class="nc"&gt;SqsClient&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="kd"&gt;final&lt;/span&gt; &lt;span class="nc"&gt;AwsProperties&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="nc"&gt;DocumentService&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;S3Client&lt;/span&gt; &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;SqsClient&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;AwsProperties&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;s3&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;sqs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="nf"&gt;store&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;byte&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;content&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;contentType&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;UUID&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;randomUUID&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;toString&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"documents/"&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

        &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;putObject&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;key&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;contentType&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;contentType&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                &lt;span class="nc"&gt;RequestBody&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;fromBytes&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;content&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

        &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;queueUrl&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getQueueUrl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueUrl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;sendMessage&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueUrl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;queueUrl&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;messageBody&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
                &lt;span class="s2"&gt;"{\"documentId\":\"%s\",\"bucket\":\"%s\",\"key\":\"%s\"}"&lt;/span&gt;
                        &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;formatted&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El controlador que expone &lt;code&gt;POST /documents&lt;/code&gt; solo delega en este servicio y responde &lt;code&gt;202 Accepted&lt;/code&gt; con el identificador. En un sistema real, el evento debería publicarse con una garantía explícita, por ejemplo mediante el patrón outbox, porque el código anterior puede guardar el archivo y fallar antes de publicar el mensaje. La emulación local no cambia esa responsabilidad de diseño.&lt;/p&gt;

&lt;h3&gt;
  
  
  Docker Compose para desarrollo
&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;compose.yaml: emulador, inicialización de recursos y aplicación&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;services&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;floci&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;image&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;floci/floci:2.5.0&lt;/span&gt;          &lt;span class="c1"&gt;# versión fija para entornos reproducibles
&lt;/span&gt;    &lt;span class="na"&gt;ports&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s2"&gt;"4566:4566"&lt;/span&gt;
    &lt;span class="na"&gt;environment&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;FLOCI_HOSTNAME&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;floci&lt;/span&gt;           &lt;span class="c1"&gt;# las URLs devueltas (QueueUrl) apuntan al servicio, no a localhost
&lt;/span&gt;      &lt;span class="na"&gt;FLOCI_STORAGE_MODE&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hybrid&lt;/span&gt;      &lt;span class="c1"&gt;# conserva el estado entre reinicios
&lt;/span&gt;
  &lt;span class="na"&gt;init&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;image&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;amazon/aws-cli:2.17.0&lt;/span&gt;
    &lt;span class="na"&gt;depends_on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;floci&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="na"&gt;environment&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;AWS_ENDPOINT_URL&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;http://floci:4566&lt;/span&gt;
      &lt;span class="na"&gt;AWS_REGION&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;us-east-1&lt;/span&gt;
      &lt;span class="na"&gt;AWS_ACCESS_KEY_ID&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;test&lt;/span&gt;
      &lt;span class="na"&gt;AWS_SECRET_ACCESS_KEY&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;test&lt;/span&gt;
    &lt;span class="na"&gt;entrypoint&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"/bin/sh"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"-c"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="na"&gt;command&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
      &lt;span class="s2"&gt;"until aws s3 ls &amp;gt;/dev/null 2&amp;gt;&amp;amp;1; do sleep 1; done;
&lt;/span&gt;       &lt;span class="s"&gt;aws s3 mb s3://documents || true;&lt;/span&gt;
       &lt;span class="s"&gt;aws sqs create-queue --queue-name document-events"&lt;/span&gt;

  &lt;span class="na"&gt;app&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;build&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;.&lt;/span&gt;
    &lt;span class="na"&gt;ports&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s2"&gt;"8080:8080"&lt;/span&gt;
    &lt;span class="na"&gt;depends_on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;init&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;condition&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;service_completed_successfully&lt;/span&gt;
    &lt;span class="na"&gt;environment&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;AWS_ENDPOINT_URL&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;http://floci:4566&lt;/span&gt;
      &lt;span class="na"&gt;AWS_REGION&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;us-east-1&lt;/span&gt;
      &lt;span class="na"&gt;AWS_ACCESS_KEY_ID&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;test&lt;/span&gt;
      &lt;span class="na"&gt;AWS_SECRET_ACCESS_KEY&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;test&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El servicio &lt;code&gt;init&lt;/code&gt; crea los recursos con la AWS CLI estándar. En un equipo que ya define su infraestructura con Terraform u OpenTofu, la alternativa más coherente es aplicar los mismos módulos contra Floci, que el proyecto declara compatible con el proveedor oficial de AWS: así el entorno local se deriva de la misma fuente que producción.&lt;/p&gt;

&lt;h3&gt;
  
  
  Prueba de integración automatizada
&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;DocumentServiceIntegrationTest.java: un emulador aislado por ejecución&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;&lt;span class="nd"&gt;@SpringBootTest&lt;/span&gt;
&lt;span class="nd"&gt;@Testcontainers&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;DocumentServiceIntegrationTest&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;

    &lt;span class="nd"&gt;@Container&lt;/span&gt;
    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="nc"&gt;FlociContainer&lt;/span&gt; &lt;span class="n"&gt;floci&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;FlociContainer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"floci/floci:2.5.0"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;withDockerSocket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kc"&gt;false&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// S3 y SQS corren en proceso: sin socket de Docker&lt;/span&gt;

    &lt;span class="nd"&gt;@DynamicPropertySource&lt;/span&gt;
    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;awsProperties&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;DynamicPropertyRegistry&lt;/span&gt; &lt;span class="n"&gt;registry&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;registry&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"app.aws.endpoint"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;floci&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;getEndpoint&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="n"&gt;registry&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"app.aws.region"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;floci&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;getRegion&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="c1"&gt;// La cadena de credenciales por defecto del SDK lee estas propiedades del sistema.&lt;/span&gt;
        &lt;span class="nc"&gt;System&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;setProperty&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"aws.accessKeyId"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;floci&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getAccessKey&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="nc"&gt;System&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;setProperty&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"aws.secretAccessKey"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;floci&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getSecretKey&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="nd"&gt;@Autowired&lt;/span&gt; &lt;span class="nc"&gt;DocumentService&lt;/span&gt; &lt;span class="n"&gt;documents&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nd"&gt;@Autowired&lt;/span&gt; &lt;span class="nc"&gt;S3Client&lt;/span&gt; &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nd"&gt;@Autowired&lt;/span&gt; &lt;span class="nc"&gt;SqsClient&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nd"&gt;@Autowired&lt;/span&gt; &lt;span class="nc"&gt;AwsProperties&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="nd"&gt;@BeforeAll&lt;/span&gt;
    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;createResources&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nd"&gt;@Autowired&lt;/span&gt; &lt;span class="nc"&gt;S3Client&lt;/span&gt; &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nd"&gt;@Autowired&lt;/span&gt; &lt;span class="nc"&gt;SqsClient&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                                &lt;span class="nd"&gt;@Autowired&lt;/span&gt; &lt;span class="nc"&gt;AwsProperties&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;createBucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;createQueue&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="nd"&gt;@Test&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;storesTheDocumentAndPublishesAnEvent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;documents&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;store&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"hola"&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getBytes&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;StandardCharsets&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;UTF_8&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"text/plain"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

        &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;stored&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getObjectAsBytes&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;key&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"documents/"&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;asUtf8String&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="nf"&gt;assertThat&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;stored&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;isEqualTo&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"hola"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

        &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;queueUrl&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getQueueUrl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueUrl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="n"&gt;messages&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;receiveMessage&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;queueUrl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;queueUrl&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;waitTimeSeconds&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;maxNumberOfMessages&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;messages&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="nf"&gt;assertThat&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;extracting&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Message&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;body&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;singleElement&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;asString&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;contains&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Dos detalles merecen atención. El primero es fijar la versión de la imagen: &lt;code&gt;FlociContainer()&lt;/code&gt; sin argumentos usa &lt;code&gt;floci/floci:latest&lt;/code&gt;, y el proyecto publica versiones estables dos veces por mes, de modo que una prueba sin versión fija puede cambiar de comportamiento sin que cambie el código. El segundo es &lt;code&gt;withDockerSocket(false)&lt;/code&gt;: el módulo monta el socket de Docker de forma automática cuando algún servicio habilitado lo necesita, y todos están habilitados por defecto. Para un servicio que solo usa S3 y SQS, desactivarlo reduce los privilegios que la prueba otorga al contenedor.&lt;/p&gt;

&lt;h3&gt;
  
  
  Ejecución en CI
&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;.github/workflows/ci.yml: Testcontainers en un runner con Docker&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;ci&lt;/span&gt;
&lt;span class="na"&gt;on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;push&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;pull_request&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="na"&gt;jobs&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;test&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;runs-on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;ubuntu-latest&lt;/span&gt;
    &lt;span class="na"&gt;steps&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/checkout@v4&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/setup-java@v4&lt;/span&gt;
        &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;distribution&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;temurin&lt;/span&gt;
          &lt;span class="na"&gt;java-version&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'21'&lt;/span&gt;
          &lt;span class="na"&gt;cache&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;maven&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;./mvnw -B verify&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Los runners de GitHub Actions basados en Ubuntu incluyen Docker, por lo que Testcontainers puede crear el emulador sin pasos adicionales. Cada ejecución obtiene una instancia aislada, sin estado compartido con otras ramas ni con otras personas.&lt;/p&gt;

&lt;h2&gt;
  
  
  Floci como componente de una Internal Developer Platform
&lt;/h2&gt;

&lt;p&gt;El valor de un emulador crece cuando deja de ser una herramienta que cada equipo configura por su cuenta y pasa a formar parte de un golden path. La experiencia deseada se puede describir en una frase: una persona crea un servicio desde una plantilla, ejecuta un comando y obtiene una aplicación funcional con sus dependencias cloud emuladas y sus pruebas de integración en verde.&lt;/p&gt;

&lt;p&gt;Conviene separar lo que existe de lo que es una propuesta. Lo que el ecosistema ofrece hoy, según sus repositorios, incluye la CLI con comandos &lt;code&gt;start&lt;/code&gt;, &lt;code&gt;wait&lt;/code&gt;, &lt;code&gt;env&lt;/code&gt; y &lt;code&gt;stop&lt;/code&gt; pensados para CI; los módulos de Testcontainers en cinco lenguajes; compatibilidad declarada con Terraform, OpenTofu y CDK, respaldada por pruebas automatizadas en el repositorio; un chart de Helm para Kubernetes; compatibilidad con la configuración y los scripts de inicialización de LocalStack; y una skill para agentes de programación. Lo que sigue es una propuesta de arquitectura, no una integración existente.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Plantilla en Backstage&lt;/strong&gt; (u otro portal interno) que genere el servicio con &lt;code&gt;compose.yaml&lt;/code&gt;, la prueba de integración con Testcontainers y la versión de Floci fijada por la plataforma.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Módulos de Terraform u OpenTofu compartidos&lt;/strong&gt; que se apliquen contra Floci en local y contra la cuenta real en los ambientes, de modo que el entorno de desarrollo y el de producción provengan de la misma definición.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Un workflow reutilizable de CI&lt;/strong&gt; que ejecute las pruebas contra el emulador y deje para una etapa posterior las pruebas de humo en la nube.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Una versión de Floci gestionada por la plataforma&lt;/strong&gt;, actualizada de forma deliberada y con pruebas de regresión propias, porque el ritmo de cambios del proyecto es alto.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Onboarding automatizado&lt;/strong&gt;: la primera tarea de una persona nueva es ejecutar las pruebas de integración en su máquina, sin solicitar ningún acceso.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Impacto en Developer Experience
&lt;/h2&gt;

&lt;p&gt;No hay datos públicos e independientes que cuantifiquen el impacto de Floci en la productividad, y este artículo no los inventa. Lo que sí puede hacerse es identificar dónde debería notarse y cómo medirlo antes y después de adoptarlo.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Dónde debería notarse el cambio y cómo medirlo&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Dimensión&lt;/th&gt;
&lt;th&gt;Hipótesis&lt;/th&gt;
&lt;th&gt;Cómo medirla&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo hasta el primer entorno funcional&lt;/td&gt;
&lt;td&gt;Baja, porque no requiere solicitar accesos&lt;/td&gt;
&lt;td&gt;Tiempo desde el alta hasta la primera ejecución verde de las pruebas de integración&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo de feedback&lt;/td&gt;
&lt;td&gt;Baja, porque las pruebas corren en la máquina&lt;/td&gt;
&lt;td&gt;Duración de la suite de integración en local y en CI&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dependencia de ambientes compartidos&lt;/td&gt;
&lt;td&gt;Disminuye&lt;/td&gt;
&lt;td&gt;Cantidad de reservas o conflictos en el ambiente de integración&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Reproducibilidad&lt;/td&gt;
&lt;td&gt;Mejora, con versiones fijas&lt;/td&gt;
&lt;td&gt;Tasa de pruebas inestables (flaky) en CI&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Autonomía&lt;/td&gt;
&lt;td&gt;Aumenta&lt;/td&gt;
&lt;td&gt;Tickets a plataforma por accesos o recursos de desarrollo&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Costo cloud de desarrollo y testing&lt;/td&gt;
&lt;td&gt;Puede bajar&lt;/td&gt;
&lt;td&gt;Gasto de las cuentas de desarrollo y CI, por servicio&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Estas métricas se conectan con las de &lt;a href="https://dora.dev/" rel="noopener noreferrer"&gt;DORA&lt;/a&gt;: el tiempo de entrega de cambios incluye el tiempo que un cambio espera a ser validado, y la tasa de fallas de cambio es la contracara que hay que vigilar. Si la emulación acelera el feedback pero deja pasar más errores a producción, el resultado neto es negativo. Por eso conviene medir las dos cosas a la vez, junto con una encuesta breve de experiencia de desarrollo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Floci frente a LocalStack y otras alternativas
&lt;/h2&gt;

&lt;p&gt;La comparación más inmediata es con LocalStack, el emulador de AWS más difundido. En marzo de 2026, LocalStack &lt;a href="https://blog.localstack.cloud/the-road-ahead-for-localstack/" rel="noopener noreferrer"&gt;anunció&lt;/a&gt; que su emulador pasaba a distribuirse como una imagen unificada que requiere un token de autenticación, y que ya no podía comprometerse a actualizar con regularidad la edición Community. Floci se presenta explícitamente como reemplazo directo de esa edición: usa el mismo puerto, traduce variables de entorno de LocalStack y ejecuta sus scripts de inicialización sin cambios.&lt;/p&gt;

&lt;p&gt;Ese origen explica parte de su crecimiento, pero también obliga a leer sus comparaciones con cuidado. La tabla de su README contrasta Floci con LocalStack Community, no con las ediciones comerciales, y las cifras de arranque y memoria son del propio proyecto. Además del emulador de AWS, existen alternativas consolidadas para otros contextos.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Alternativas de emulación local, sin un ganador universal&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Criterio&lt;/th&gt;
&lt;th&gt;Floci&lt;/th&gt;
&lt;th&gt;LocalStack&lt;/th&gt;
&lt;th&gt;Moto&lt;/th&gt;
&lt;th&gt;Azurite&lt;/th&gt;
&lt;th&gt;Emuladores de gcloud&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Alcance&lt;/td&gt;
&lt;td&gt;AWS, Azure, GCP y OCI; más de cien servicios de AWS declarados&lt;/td&gt;
&lt;td&gt;AWS, con una larga trayectoria&lt;/td&gt;
&lt;td&gt;AWS, como biblioteca de Python o servidor&lt;/td&gt;
&lt;td&gt;Azure Storage: Blob, Queue y Table&lt;/td&gt;
&lt;td&gt;Pub/Sub, Firestore, Datastore, Bigtable, Spanner&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fidelidad&lt;/td&gt;
&lt;td&gt;Protocolo en proceso y contenedores reales para motores&lt;/td&gt;
&lt;td&gt;A evaluar por servicio&lt;/td&gt;
&lt;td&gt;Mocks del protocolo; menor fidelidad en servicios complejos&lt;/td&gt;
&lt;td&gt;Alta para el alcance que cubre&lt;/td&gt;
&lt;td&gt;Oficial, para cada servicio&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Licencia&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;Imagen unificada que requiere token desde marzo de 2026&lt;/td&gt;
&lt;td&gt;Apache 2.0&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;Parte del SDK de Google Cloud&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Integración con SDK&lt;/td&gt;
&lt;td&gt;SDK estándar con endpoint configurable&lt;/td&gt;
&lt;td&gt;SDK estándar con endpoint configurable&lt;/td&gt;
&lt;td&gt;Decoradores en Python o modo servidor&lt;/td&gt;
&lt;td&gt;Connection strings de Azure&lt;/td&gt;
&lt;td&gt;Variables de entorno del emulador&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CI y Testcontainers&lt;/td&gt;
&lt;td&gt;Módulos propios en cinco lenguajes&lt;/td&gt;
&lt;td&gt;Módulo oficial de Testcontainers&lt;/td&gt;
&lt;td&gt;Sin contenedor en modo biblioteca&lt;/td&gt;
&lt;td&gt;Módulo de Testcontainers&lt;/td&gt;
&lt;td&gt;Módulos de Testcontainers para varios servicios&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Madurez&lt;/td&gt;
&lt;td&gt;Proyecto de nueve meses, con ritmo de cambios muy alto&lt;/td&gt;
&lt;td&gt;Producto establecido&lt;/td&gt;
&lt;td&gt;Proyecto maduro&lt;/td&gt;
&lt;td&gt;Mantenido por Microsoft&lt;/td&gt;
&lt;td&gt;Mantenidos por Google&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Los indicadores de madurez de Floci son llamativos y ambiguos a la vez. El repositorio principal se creó el 18 de febrero de 2026 y, al 15 de noviembre, tenía más de 31.000 estrellas, unos 170 contribuidores, más de 5.300 pull requests fusionados, más de 2.400 issues cerrados y alrededor de 170 abiertos, con 63 versiones publicadas y un tren de releases los días 15 y último de cada mes. El directorio de compatibilidad declara 2.576 pruebas automatizadas sobre cinco SDKs y tres herramientas de infraestructura como código. Es evidencia de actividad y de una comunidad amplia, pero un proyecto de nueve meses no tiene todavía un historial de estabilidad a largo plazo, y la cadencia de cambios exige fijar versiones.&lt;/p&gt;

&lt;h2&gt;
  
  
  Los límites de la emulación
&lt;/h2&gt;

&lt;p&gt;La emulación local reduce dependencias, pero no reproduce la nube. Algunas diferencias son de diseño y la propia documentación las declara; otras son inherentes a cualquier emulador.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;IAM y seguridad.&lt;/strong&gt; Por defecto, Floci no verifica firmas SigV4 y acepta cualquier credencial no vacía. La evaluación de políticas IAM existe, pero se activa de forma explícita con &lt;code&gt;FLOCI_SERVICES_IAM_ENFORCEMENT_ENABLED&lt;/code&gt;, y la documentación recomienda dejarla desactivada en la mayoría de los escenarios locales. Una prueba verde en local no demuestra que los permisos de producción sean correctos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Networking.&lt;/strong&gt; VPC, grupos de seguridad, endpoints privados, DNS y TLS de producción no se reproducen con fidelidad. En el emulador de Azure, la mayoría de los servicios corre por HTTP plano salvo que se habilite TLS.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Latencia, cuotas y límites.&lt;/strong&gt; El emulador responde en milisegundos y su catálogo de cuotas usa valores estáticos generosos. Un sistema que funciona en local puede encontrar throttling, límites de tamaño o latencias reales que cambian su comportamiento.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Consistencia y fallas.&lt;/strong&gt; Las fallas parciales, los reintentos del lado del proveedor y los comportamientos de consistencia de un servicio distribuido no aparecen en un proceso local. Incluso la emulación de AWS FIS es, según su documentación, una simulación del plano de control que no inyecta fallas en otros servicios.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Servicios administrados y stubs.&lt;/strong&gt; Varios servicios están implementados como stubs: Bedrock Runtime devuelve respuestas ficticias y Textract o Transcribe completan trabajos sin procesar contenido real. Sirven para probar el flujo de integración, no el resultado.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Performance.&lt;/strong&gt; Ninguna medición hecha contra un emulador local es representativa del rendimiento en la nube.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Una estrategia de pruebas por capas
&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;Qué valida cada capa y dónde conviene ejecutarla&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Capa&lt;/th&gt;
&lt;th&gt;Qué valida&lt;/th&gt;
&lt;th&gt;Dónde corre&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Unit tests&lt;/td&gt;
&lt;td&gt;Lógica de negocio sin dependencias externas&lt;/td&gt;
&lt;td&gt;Local y CI, en cada cambio&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Integración con emulación local&lt;/td&gt;
&lt;td&gt;Uso correcto del SDK, serialización, flujos entre servicios&lt;/td&gt;
&lt;td&gt;Local y CI, en cada cambio, contra Floci&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Contrato y compatibilidad&lt;/td&gt;
&lt;td&gt;Formato de eventos y APIs entre productores y consumidores&lt;/td&gt;
&lt;td&gt;CI, en cada cambio&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Smoke tests en la nube real&lt;/td&gt;
&lt;td&gt;Permisos IAM, networking, configuración real&lt;/td&gt;
&lt;td&gt;Ambiente de staging, en cada despliegue&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Resiliencia y performance&lt;/td&gt;
&lt;td&gt;Cuotas, latencias, comportamiento ante fallas&lt;/td&gt;
&lt;td&gt;Ambientes dedicados, de forma periódica&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La emulación mueve hacia la izquierda la mayor parte de las pruebas de integración, que son las más frecuentes, y deja en la nube real las que dependen de lo que solo la nube real tiene. El error de adopción más probable no es técnico: es eliminar las pruebas en la nube porque las pruebas locales pasan.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cloud local y desarrollo asistido por agentes
&lt;/h2&gt;

&lt;p&gt;Los agentes de programación necesitan lo mismo que las personas para trabajar con autonomía: un entorno aislado, reproducible y con feedback automático. En términos de &lt;a href="https://juliancardozo.github.io/blog/harness-engineering-agentes-codigo-guias-sensores/" rel="noopener noreferrer"&gt;harness engineering&lt;/a&gt;, una suite de integración contra un emulador local es un sensor computacional: determinista, barato y ejecutable en cada cambio. En términos de &lt;a href="https://juliancardozo.github.io/blog/loop-engineering-agentic-loops/" rel="noopener noreferrer"&gt;Loop Engineering&lt;/a&gt;, es el verificador que cierra cada iteración del ciclo.&lt;/p&gt;

&lt;p&gt;Un flujo posible: el agente recibe una especificación, implementa la funcionalidad, ejecuta las pruebas contra Floci, lee los errores, corrige el código y repite hasta que las pruebas pasan o se agota un límite de iteraciones; recién entonces propone un pull request para revisión humana. El aislamiento tiene además un beneficio de seguridad: el agente trabaja sin credenciales reales, de modo que un error no puede crear ni borrar recursos de una cuenta. La CLI de Floci incluye una skill para agentes, compatible con herramientas como Claude Code, Codex o Cursor, que les indica cómo configurar los clientes contra los emuladores en lugar de la nube real.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;El límite de este ciclo:&lt;/strong&gt; Un agente que valida contra un emulador comprueba que su código usa bien las APIs, no que el sistema funcione en la nube. Los permisos, la red, las cuotas y las fallas reales quedan fuera de su verificación, y por eso la revisión humana y las pruebas en un ambiente real siguen siendo parte del ciclo.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Conclusión: plataformas que eliminan fricción
&lt;/h2&gt;

&lt;p&gt;Desde la gestión de ingeniería, la pregunta no es si Floci es mejor que otra herramienta, sino qué dependencia elimina y qué responsabilidad nueva introduce. Elimina la necesidad de una cuenta cloud y de un ambiente compartido para la mayoría de las pruebas de integración. Introduce la responsabilidad de gestionar la versión del emulador, de conocer qué servicios se emulan con fidelidad suficiente y de mantener las pruebas en la nube real donde la emulación no alcanza.&lt;/p&gt;

&lt;p&gt;La adopción conviene hacerla de forma gradual: empezar por un servicio con dependencias simples, como S3, SQS o DynamoDB; medir el tiempo de feedback y la tasa de pruebas inestables antes y después; fijar la versión del emulador en la plataforma; y recién entonces incorporarlo a la plantilla de servicios. Si las métricas no mejoran o aparecen más fallas en producción, la decisión correcta es revisar el alcance, no extenderlo.&lt;/p&gt;

&lt;p&gt;La lección transferible va más allá de esta herramienta. La velocidad del feedback no depende solo de la disciplina de cada equipo: es una propiedad que la plataforma habilita o impide. Una plataforma que logra que probar contra dependencias realistas sea más fácil que no probar está haciendo, en la práctica, que el camino correcto sea el más fácil.&lt;/p&gt;

&lt;h2&gt;
  
  
  Referencias
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Floci. &lt;a href="https://github.com/floci-io" rel="noopener noreferrer"&gt;floci-io en GitHub&lt;/a&gt;: &lt;a href="https://github.com/floci-io/floci" rel="noopener noreferrer"&gt;floci&lt;/a&gt;, &lt;a href="https://github.com/floci-io/floci-az" rel="noopener noreferrer"&gt;floci-az&lt;/a&gt;, &lt;a href="https://github.com/floci-io/floci-gcp" rel="noopener noreferrer"&gt;floci-gcp&lt;/a&gt;, &lt;a href="https://github.com/floci-io/floci-oci" rel="noopener noreferrer"&gt;floci-oci&lt;/a&gt;, &lt;a href="https://github.com/floci-io/floci-cli" rel="noopener noreferrer"&gt;floci-cli&lt;/a&gt;, &lt;a href="https://github.com/floci-io/floci-ui" rel="noopener noreferrer"&gt;floci-ui&lt;/a&gt; y &lt;a href="https://github.com/floci-io/testcontainers-floci" rel="noopener noreferrer"&gt;testcontainers-floci&lt;/a&gt;. Consultados el 15 de noviembre de 2026.&lt;/li&gt;
&lt;li&gt;Floci. &lt;a href="https://floci.io/" rel="noopener noreferrer"&gt;Documentación oficial&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;LocalStack. &lt;a href="https://blog.localstack.cloud/the-road-ahead-for-localstack/" rel="noopener noreferrer"&gt;The Road Ahead for LocalStack&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Moto. &lt;a href="https://github.com/getmoto/moto" rel="noopener noreferrer"&gt;Mock AWS Services&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Microsoft. &lt;a href="https://github.com/Azure/Azurite" rel="noopener noreferrer"&gt;Azurite&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;a href="https://cloud.google.com/sdk/gcloud/reference/beta/emulators" rel="noopener noreferrer"&gt;Emuladores locales de gcloud&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Testcontainers. &lt;a href="https://java.testcontainers.org/" rel="noopener noreferrer"&gt;Documentación para Java&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;DORA. &lt;a href="https://dora.dev/" rel="noopener noreferrer"&gt;dora.dev&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;En síntesis: Floci reduce la dependencia de cuentas y ambientes compartidos para la mayoría de las pruebas de integración, y lo hace con un enfoque que combina emulación en proceso y contenedores reales. No reemplaza la nube: IAM, networking, cuotas y fallas siguen requiriendo pruebas en un ambiente real. Su valor depende de integrarlo en la plataforma con versiones fijas, una estrategia de pruebas por capas y métricas que confirmen que el feedback más rápido no se paga con más fallas en producción.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>devops</category>
      <category>cloud</category>
      <category>java</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Harness engineering: cómo dar confianza al trabajo de un agente de código</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:31:57 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/harness-engineering-como-dar-confianza-al-trabajo-de-un-agente-de-codigo-3868</link>
      <guid>https://dev.to/julian_cardozo_dev/harness-engineering-como-dar-confianza-al-trabajo-de-un-agente-de-codigo-3868</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/harness-engineering-agentes-codigo-guias-sensores/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Un agente de código puede producir en minutos un cambio que a una persona le llevaría horas. La dificultad aparece después: decidir si ese cambio es correcto, mantenible y coherente con la arquitectura exige una revisión que consume buena parte del tiempo ahorrado. En «Harness engineering for coding agent users», publicado el 2 de abril de 2026 en martinfowler.com, Birgitta Böckeler, Distinguished Engineer de Thoughtworks, propone un modelo para reducir esa dependencia de la revisión manual: rodear al agente de controles que aumenten la probabilidad de que acierte en el primer intento y que le permitan corregirse antes de que intervenga una persona. Este artículo resume el modelo, lo contrasta con otras prácticas y lo aplica a un sistema multiagente propio.&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué es un harness y qué parte le corresponde al usuario
&lt;/h2&gt;

&lt;p&gt;El término &lt;em&gt;harness&lt;/em&gt; se usa con frecuencia para designar todo lo que rodea al modelo en un agente de IA. Böckeler parte de esa definición, tomada de una publicación de LangChain que resume la idea como «agente = modelo + harness», pero la considera demasiado amplia y la acota a un contexto específico: el de quien usa un agente de código, no el de quien lo construye.&lt;/p&gt;

&lt;p&gt;La distinción se entiende como tres anillos concéntricos. En el centro está el modelo. Alrededor, el harness que arma el proveedor del agente: el prompt de sistema, la recuperación de contexto y la orquestación interna. En el anillo exterior está el harness del usuario, el conjunto de reglas, herramientas y verificaciones que un equipo agrega para su propio código. El artículo trata ese último anillo, que es el único que el equipo controla.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Los tres contextos de un agente de código, según Böckeler: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/harness-engineering-agentes-codigo-guias-sensores/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;El objetivo de ese harness exterior es doble: aumentar la probabilidad de que el agente produzca un resultado correcto en el primer intento y agregar un ciclo de feedback que corrija problemas antes de la revisión humana. Según Böckeler, el beneficio se mide en menos trabajo de revisión, mejor calidad del sistema y menos tokens desperdiciados en intentos fallidos.&lt;/p&gt;

&lt;h3&gt;
  
  
  Relación con context engineering y loop engineering
&lt;/h3&gt;

&lt;p&gt;Böckeler describe la construcción de un harness de usuario como «una forma específica de context engineering»: el contexto es el medio por el cual las guías y los sensores llegan al agente. La relación con &lt;a href="https://juliancardozo.github.io/blog/loop-engineering-agentic-loops/" rel="noopener noreferrer"&gt;Loop Engineering&lt;/a&gt;, otra práctica que se discute en 2026, es complementaria. Loop engineering se ocupa del ciclo de trabajo: qué lo dispara, dónde se guarda su estado y cuándo se detiene. Harness engineering se ocupa de qué controles alimentan ese ciclo y qué tan confiables son. Un loop sin un buen harness itera contra señales débiles; un harness sin un loop produce señales que nadie consume.&lt;/p&gt;

&lt;h2&gt;
  
  
  Guías y sensores
&lt;/h2&gt;

&lt;p&gt;El modelo organiza los controles según el momento en que actúan. Las &lt;strong&gt;guías&lt;/strong&gt; (&lt;em&gt;feedforward&lt;/em&gt;) orientan al agente antes de que actúe: convenciones de código, documentación de arquitectura, instrucciones para un tipo de tarea. Los &lt;strong&gt;sensores&lt;/strong&gt; (&lt;em&gt;feedback&lt;/em&gt;) observan el resultado después de que el agente actúa y le permiten corregirse: tests, linters, revisiones.&lt;/p&gt;

&lt;p&gt;Ninguno de los dos alcanza por separado. Un harness hecho solo de sensores produce, en palabras de Böckeler, un agente que repite los mismos errores, porque nada le indica cómo evitarlos. Uno hecho solo de guías codifica reglas que nunca se comprueban. Una observación práctica del artículo es que los sensores rinden más cuando su salida está escrita para un modelo de lenguaje: un mensaje de linter que explica cómo corregir el problema funciona, según Böckeler, como una forma positiva de inyección de instrucciones.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Ejemplos de controles del artículo, clasificados por dirección y tipo&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Control&lt;/th&gt;
&lt;th&gt;Dirección&lt;/th&gt;
&lt;th&gt;Tipo&lt;/th&gt;
&lt;th&gt;Implementación de ejemplo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Convenciones de código&lt;/td&gt;
&lt;td&gt;Guía&lt;/td&gt;
&lt;td&gt;Inferencial&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;AGENTS.md&lt;/code&gt;, skills&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Instrucciones para iniciar un proyecto&lt;/td&gt;
&lt;td&gt;Guía&lt;/td&gt;
&lt;td&gt;Ambos&lt;/td&gt;
&lt;td&gt;Una skill con un script de inicialización&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Transformaciones de código&lt;/td&gt;
&lt;td&gt;Guía&lt;/td&gt;
&lt;td&gt;Computacional&lt;/td&gt;
&lt;td&gt;Recetas de OpenRewrite&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tests estructurales&lt;/td&gt;
&lt;td&gt;Sensor&lt;/td&gt;
&lt;td&gt;Computacional&lt;/td&gt;
&lt;td&gt;Hook de pre-commit con ArchUnit para límites entre módulos&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Instrucciones de revisión&lt;/td&gt;
&lt;td&gt;Sensor&lt;/td&gt;
&lt;td&gt;Inferencial&lt;/td&gt;
&lt;td&gt;Skills de revisión&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Controles computacionales e inferenciales
&lt;/h2&gt;

&lt;p&gt;La segunda dimensión del modelo es el tipo de control. Los &lt;strong&gt;computacionales&lt;/strong&gt; son deterministas: tests, linters, verificadores de tipos, análisis estructural. Corren en CPU, tardan entre milisegundos y segundos y dan siempre el mismo resultado ante la misma entrada. Los &lt;strong&gt;inferenciales&lt;/strong&gt; usan un modelo para hacer análisis semántico: revisión de código con IA o un modelo que actúa como juez. Son más lentos, más caros y no deterministas, pero pueden evaluar aspectos que un linter no ve.&lt;/p&gt;

&lt;p&gt;La consecuencia práctica es una división del trabajo. Los controles computacionales son lo bastante baratos para ejecutarse en cada cambio. Los inferenciales conviene reservarlos para momentos en que su costo se justifica y, según Böckeler, aumentan la confianza cuando se usan con un modelo capaz.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Diferencias entre los dos tipos de control&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Criterio&lt;/th&gt;
&lt;th&gt;Computacional&lt;/th&gt;
&lt;th&gt;Inferencial&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Ejemplos&lt;/td&gt;
&lt;td&gt;Tests, linters, type checking, ArchUnit, mutation testing&lt;/td&gt;
&lt;td&gt;Revisión con IA, LLM como juez, skills de revisión&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Determinismo&lt;/td&gt;
&lt;td&gt;Sí&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Costo y latencia&lt;/td&gt;
&lt;td&gt;Bajos: milisegundos a segundos&lt;/td&gt;
&lt;td&gt;Altos: requieren inferencia en GPU&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Frecuencia razonable&lt;/td&gt;
&lt;td&gt;En cada cambio&lt;/td&gt;
&lt;td&gt;En momentos seleccionados&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fortaleza&lt;/td&gt;
&lt;td&gt;Reglas explícitas y verificables&lt;/td&gt;
&lt;td&gt;Juicio semántico: duplicación conceptual, sobreingeniería&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  El ciclo de dirección y el momento de cada control
&lt;/h2&gt;

&lt;p&gt;El modelo asigna a las personas un rol que Böckeler llama &lt;em&gt;steering loop&lt;/em&gt;, el ciclo de dirección: cuando un problema se repite, la tarea no es corregirlo una vez más, sino mejorar una guía o un sensor para que sea menos probable o directamente imposible. El propio agente puede ayudar a construir el harness: escribir tests estructurales, redactar reglas a partir de patrones observados, generar linters personalizados o documentar cómo funciona una parte del código.&lt;/p&gt;

&lt;p&gt;El segundo principio retoma ideas de integración y entrega continuas: los controles deben ejecutarse lo más temprano posible, porque un error detectado antes es más barato de corregir. El artículo distribuye los sensores a lo largo del ciclo de vida de un cambio.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Dónde ubica cada sensor el modelo de Böckeler: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/harness-engineering-agentes-codigo-guias-sensores/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Los sensores continuos cubren dos tipos de problema que un pipeline no ve. La deriva del código, como código muerto, dependencias desactualizadas o cobertura que se degrada, y la salud en tiempo de ejecución: degradación de latencia o disponibilidad, o un modelo que muestrea respuestas para evaluar su calidad.&lt;/p&gt;

&lt;h2&gt;
  
  
  Tres dimensiones que un harness puede regular
&lt;/h2&gt;

&lt;p&gt;Böckeler propone agrupar los controles según lo que regulan, y aclara que la clasificación le resulta útil «por ahora». Las tres dimensiones tienen un grado de madurez muy distinto.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Mantenibilidad.&lt;/strong&gt; Es la dimensión más accesible, porque existen muchas herramientas. Los sensores computacionales detectan con confiabilidad código duplicado, complejidad ciclomática, falta de cobertura, deriva arquitectónica y violaciones de estilo. Los modelos abordan problemas semánticos, como duplicación conceptual, tests redundantes o sobreingeniería, pero de forma costosa y probabilística, no en cada commit. Ninguno de los dos detecta con confiabilidad un diagnóstico equivocado, funcionalidades innecesarias o instrucciones mal interpretadas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Aptitud arquitectónica.&lt;/strong&gt; Agrupa guías y sensores para características de la arquitectura, lo que Thoughtworks llama &lt;em&gt;fitness functions&lt;/em&gt;. Un ejemplo del artículo combina una skill que describe requisitos de rendimiento con tests de rendimiento que devuelven el resultado al agente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Comportamiento.&lt;/strong&gt; Böckeler lo llama el problema central. La práctica habitual combina una especificación funcional como guía con una suite de tests generada por IA, su cobertura y pruebas manuales como sensores. El diagnóstico del artículo es explícito: ese enfoque deposita demasiada confianza en tests que escribió el mismo tipo de sistema que escribió el código, y todavía no alcanza. Algunos equipos usan &lt;a href="https://lexler.github.io/augmented-coding-patterns/patterns/approved-fixtures/" rel="noopener noreferrer"&gt;fixtures aprobados&lt;/a&gt; de forma selectiva, pero no hay una respuesta general.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;El punto más débil:&lt;/strong&gt; La dimensión de comportamiento es la que más importa al usuario final y la menos resuelta. Un harness puede garantizar que el código sea mantenible y respete la arquitectura, y aun así aceptar una funcionalidad que no hace lo que se pidió. Por eso el modelo no propone eliminar la revisión humana, sino dirigirla hacia donde los sensores no llegan.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Harnessability: no todo código se deja controlar igual
&lt;/h2&gt;

&lt;p&gt;El modelo introduce una propiedad del código: la facilidad con que admite un harness. Un lenguaje con tipado fuerte ofrece el verificador de tipos como sensor gratuito. Módulos con límites claros permiten escribir reglas de arquitectura. Frameworks como Spring ocultan detalles y, de forma implícita, aumentan la tasa de éxito del agente. El artículo recoge además el concepto de &lt;em&gt;ambient affordances&lt;/em&gt;, de Ned Letcher: propiedades estructurales del entorno que lo vuelven legible y navegable para un agente.&lt;/p&gt;

&lt;p&gt;Esto tiene una consecuencia incómoda que Böckeler formula con precisión: el harness es más necesario donde es más difícil de construir. Un proyecto nuevo puede diseñarse para ser controlable desde el inicio; un sistema heredado, sin tests ni límites claros, es el que más necesita controles y el que menos los admite.&lt;/p&gt;

&lt;p&gt;Para organizaciones con muchos servicios, el artículo sugiere &lt;em&gt;harness templates&lt;/em&gt;: si unas pocas topologías, como APIs de negocio, procesadores de eventos o dashboards, cubren la mayor parte de las necesidades, cada una puede tener su paquete de guías y sensores. La justificación proviene de la cibernética, en particular de la ley de la variedad requerida de Ashby: un regulador solo puede controlar la variedad que es capaz de modelar, y comprometerse con una topología reduce el espacio de resultados posibles. El costo, advierte Böckeler, es el mismo que el de las plantillas de servicio: versionado y deriva, quizá agravados por controles no deterministas.&lt;/p&gt;

&lt;h2&gt;
  
  
  El rol de las personas
&lt;/h2&gt;

&lt;p&gt;Una persona que desarrolla software trae consigo un harness implícito: convenciones absorbidas con el tiempo, la incomodidad de trabajar con código complejo, responsabilidad ante el equipo, alineación con la organización y un ritmo que deja espacio para aplicar la experiencia. Un agente carece de responsabilidad social, de criterio estético, de intuición sobre el equipo y de memoria organizacional.&lt;/p&gt;

&lt;p&gt;Un harness intenta externalizar parte de ese conocimiento, pero tiene límites, y construirlo es costoso, de modo que conviene priorizar. La conclusión de Böckeler es que un buen harness no debería apuntar a eliminar la intervención humana, sino a orientarla hacia las decisiones donde aporta más.&lt;/p&gt;

&lt;h2&gt;
  
  
  El modelo aplicado a un caso: Website Factory
&lt;/h2&gt;

&lt;p&gt;Para evaluar la utilidad del modelo, conviene aplicarlo a un sistema concreto. &lt;a href="https://juliancardozo.github.io/blog/orquestacion-multiagente-website-factory/" rel="noopener noreferrer"&gt;Website Factory&lt;/a&gt; es un sistema propio en el que un orquestador de Claude Code coordina subagentes especializados para convertir un brief en un sitio Astro. Sus controles no se diseñaron con este modelo en mente, lo que hace el ejercicio más informativo: muestra qué cubre un harness construido por intuición y qué deja afuera.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Controles de Website Factory clasificados con el modelo de guías y sensores&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Control&lt;/th&gt;
&lt;th&gt;Dirección&lt;/th&gt;
&lt;th&gt;Tipo&lt;/th&gt;
&lt;th&gt;Dimensión&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;CLAUDE.md&lt;/code&gt; con reglas de orquestación y definiciones de subagentes en &lt;code&gt;.claude/agents/&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Guía&lt;/td&gt;
&lt;td&gt;Inferencial&lt;/td&gt;
&lt;td&gt;Mantenibilidad y comportamiento&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Especificación, plan y tareas de Spec Kit&lt;/td&gt;
&lt;td&gt;Guía&lt;/td&gt;
&lt;td&gt;Inferencial&lt;/td&gt;
&lt;td&gt;Comportamiento&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;/speckit.analyze&lt;/code&gt; antes de implementar&lt;/td&gt;
&lt;td&gt;Sensor&lt;/td&gt;
&lt;td&gt;Inferencial&lt;/td&gt;
&lt;td&gt;Comportamiento (consistencia de la especificación)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;astro check&lt;/code&gt; y &lt;code&gt;astro build&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Sensor&lt;/td&gt;
&lt;td&gt;Computacional&lt;/td&gt;
&lt;td&gt;Mantenibilidad&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;validate_content.py&lt;/code&gt; contra el contrato de contenido&lt;/td&gt;
&lt;td&gt;Sensor&lt;/td&gt;
&lt;td&gt;Computacional&lt;/td&gt;
&lt;td&gt;Comportamiento&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;qa-reviewer&lt;/code&gt; independiente, con hallazgos por severidad&lt;/td&gt;
&lt;td&gt;Sensor&lt;/td&gt;
&lt;td&gt;Inferencial&lt;/td&gt;
&lt;td&gt;Las tres&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;/speckit.converge&lt;/code&gt; al final&lt;/td&gt;
&lt;td&gt;Sensor&lt;/td&gt;
&lt;td&gt;Inferencial&lt;/td&gt;
&lt;td&gt;Comportamiento (especificación frente a código)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La clasificación deja ver tres cosas. Primero, el sistema depende más de controles inferenciales que computacionales, la combinación más costosa y menos determinista. Segundo, no hay ningún sensor de aptitud arquitectónica: ninguna regla verifica de forma automática los límites entre componentes ni el rendimiento del sitio generado. Tercero, la dimensión de comportamiento se apoya en un validador escrito por el propio agente de frontend, y en una ejecución el &lt;code&gt;qa-reviewer&lt;/code&gt; detectó que ese validador cubría menos casos que el contrato que debía controlar. Es exactamente el riesgo que Böckeler señala para la dimensión de comportamiento.&lt;/p&gt;

&lt;p&gt;Según el modelo, las mejoras con mejor relación costo-beneficio serían sensores computacionales baratos: un presupuesto de rendimiento con Lighthouse, controles de accesibilidad automatizados y tests estructurales sobre la organización de componentes. También ayudaría que el validador de contenido se derive del contrato y no lo escriba el mismo agente que implementa.&lt;/p&gt;

&lt;h2&gt;
  
  
  Preguntas abiertas y un punto de partida
&lt;/h2&gt;

&lt;p&gt;El artículo no presenta datos cuantitativos ni experimentos controlados; describe un modelo mental de técnicas que ya se usan. Entre los ejemplos que cita figuran el relato de OpenAI sobre un equipo que construyó un producto con código escrito por agentes, con arquitectura en capas impuesta mediante linters y tests estructurales, y el de Stripe sobre sus agentes &lt;em&gt;minions&lt;/em&gt;, con hooks de pre-push y la idea de llevar el feedback lo más temprano posible.&lt;/p&gt;

&lt;p&gt;Böckeler deja varias preguntas sin resolver: cómo mantener la coherencia entre guías y sensores a medida que el harness crece, cuánto confiar en las decisiones del agente cuando las instrucciones y el feedback se contradicen, si un sensor que nunca se activa indica alta calidad o baja capacidad de detección, y cómo medir la cobertura del propio harness, de forma análoga a la cobertura de código o al mutation testing.&lt;/p&gt;

&lt;h3&gt;
  
  
  Cómo empezar
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Inventariar los controles existentes&lt;/strong&gt; y clasificarlos por dirección (guía o sensor), tipo (computacional o inferencial) y dimensión. El inventario suele mostrar dónde no hay nada.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Priorizar sensores computacionales baratos&lt;/strong&gt; que corran en cada cambio: verificador de tipos, linters y tests estructurales. Escribir sus mensajes de error pensando en que los leerá un agente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Registrar los errores que se repiten&lt;/strong&gt; en la revisión humana y convertir cada uno en una guía o un sensor nuevo. Ese es el ciclo de dirección.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reservar los controles inferenciales&lt;/strong&gt; para momentos de mayor costo, como la integración o la revisión de arquitectura, en lugar de cada commit.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tratar la dimensión de comportamiento con cautela:&lt;/strong&gt; separar quién escribe los tests de quién escribe el código y mantener la revisión humana donde los sensores no alcanzan.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Referencias
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Böckeler, B. (2026). &lt;a href="https://martinfowler.com/articles/harness-engineering.html" rel="noopener noreferrer"&gt;Harness engineering for coding agent users&lt;/a&gt;. martinfowler.com, 2 de abril de 2026.&lt;/li&gt;
&lt;li&gt;Böckeler, B. &lt;a href="https://martinfowler.com/articles/exploring-gen-ai/context-engineering-coding-agents.html" rel="noopener noreferrer"&gt;Context engineering for coding agents&lt;/a&gt;. martinfowler.com.&lt;/li&gt;
&lt;li&gt;LangChain. &lt;a href="https://blog.langchain.com/the-anatomy-of-an-agent-harness/" rel="noopener noreferrer"&gt;The anatomy of an agent harness&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Anthropic. &lt;a href="https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents" rel="noopener noreferrer"&gt;Effective harnesses for long-running agents&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;OpenAI. &lt;a href="https://openai.com/index/harness-engineering/" rel="noopener noreferrer"&gt;Harness engineering: leveraging Codex in an agent-first world&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Stripe. &lt;a href="https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents" rel="noopener noreferrer"&gt;Minions: Stripe’s one-shot, end-to-end coding agents&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Thoughtworks Technology Radar. &lt;a href="https://www.thoughtworks.com/en-de/radar/techniques/architectural-fitness-function" rel="noopener noreferrer"&gt;Architectural fitness function&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Augmented Coding Patterns. &lt;a href="https://lexler.github.io/augmented-coding-patterns/patterns/approved-fixtures/" rel="noopener noreferrer"&gt;Approved fixtures&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Fowler, M. &lt;a href="https://martinfowler.com/articles/continuousIntegration.html" rel="noopener noreferrer"&gt;Continuous Integration&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;En síntesis: harness engineering es el trabajo de rodear a un agente de código de guías que orienten su resultado y sensores que le permitan corregirse antes de la revisión humana. El modelo de Böckeler ordena esos controles por momento, tipo y dimensión, y deja claro su límite principal: la corrección funcional todavía no tiene sensores confiables. Un buen harness no elimina la revisión humana; la dirige hacia donde los controles no llegan.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Tooling para equipos de alto desempeño: de herramientas aisladas a sistemas de ingeniería aumentados por IA</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:26:51 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/tooling-para-equipos-de-alto-desempeno-de-herramientas-aisladas-a-sistemas-de-ingenieria-eki</link>
      <guid>https://dev.to/julian_cardozo_dev/tooling-para-equipos-de-alto-desempeno-de-herramientas-aisladas-a-sistemas-de-ingenieria-eki</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/tooling-equipos-alto-desempeno-sistemas-ingenieria-ia/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Un equipo trabaja con GitHub, Jira, Slack, Confluence, dashboards de observabilidad y pipelines de CI/CD. Tiene todas las herramientas que se esperan de un equipo moderno y, aun así, las decisiones quedan dispersas en hilos de chat, el standup consiste en reconstruir de memoria lo que pasó ayer, las revisiones de código dependen de dos personas que conocen el sistema y cada incidente produce información que rara vez se convierte en aprendizaje. Este artículo sostiene una tesis: un equipo de alto desempeño no es el que tiene más herramientas ni el que usa más inteligencia artificial, sino el que logra reducir el costo de coordinación, preservar el conocimiento, automatizar el trabajo repetitivo y mejorar la calidad de sus decisiones. Para desarrollarla, usa como caso de estudio el plugin de ingeniería que Anthropic publicó en su repositorio knowledge-work-plugins.&lt;/p&gt;

&lt;h2&gt;
  
  
  El problema no es la falta de herramientas
&lt;/h2&gt;

&lt;p&gt;Cada herramienta de ese equipo resuelve bien su parte: GitHub guarda el código, Jira el estado del trabajo, Slack las conversaciones, el sistema de monitoreo las métricas. El problema aparece entre ellas. La información necesaria para tomar una decisión casi nunca vive en un solo lugar, y alguien tiene que recorrer varias fuentes, reconstruir el contexto e interpretarlo. Ese trabajo de integración lo hacen las personas, a mano y de forma repetida.&lt;/p&gt;

&lt;p&gt;Dos conceptos ayudan a nombrarlo. La &lt;strong&gt;carga cognitiva&lt;/strong&gt;, que Team Topologies propone como una restricción de diseño de los equipos: cuanto más contexto ajeno a su tarea principal debe sostener un equipo, menos capacidad le queda para esa tarea. Y el &lt;strong&gt;costo de coordinación&lt;/strong&gt;: el tiempo que se dedica a sincronizar, buscar información, esperar respuestas y reconstruir decisiones. Agregar herramientas sin integrarlas suele aumentar ambos, porque multiplica los lugares donde puede estar la información.&lt;/p&gt;

&lt;p&gt;Por eso la cantidad de herramientas no predice el desempeño. Lo que importa es si el conjunto funciona como un sistema: si la información fluye entre las fuentes, si las prácticas del equipo están incorporadas en la forma de trabajar y si cada ciclo deja al equipo mejor preparado para el siguiente.&lt;/p&gt;

&lt;h2&gt;
  
  
  Del tooling individual al sistema de trabajo del equipo
&lt;/h2&gt;

&lt;p&gt;Para pasar de herramientas a sistema, resulta útil pensar en capas, cada una con una responsabilidad distinta. El modelo que sigue es una propuesta propia, no un estándar.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Fuentes de verdad:&lt;/strong&gt; el código, los tickets, la documentación, las decisiones registradas y las métricas. Son los sistemas de registro.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Integraciones:&lt;/strong&gt; APIs, conectores y servidores MCP que exponen esas fuentes a otras herramientas, incluidas las de IA.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Capacidades reutilizables:&lt;/strong&gt; skills, comandos, reglas y automatizaciones que codifican cómo el equipo hace una tarea.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Workflows:&lt;/strong&gt; secuencias orientadas a un resultado, como revisar un cambio, depurar un error, desplegar o gestionar un incidente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Gobernanza:&lt;/strong&gt; permisos, aprobaciones humanas, controles deterministas y trazabilidad.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Aprendizaje:&lt;/strong&gt; feedback, métricas y revisión que modifican las capas anteriores.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;em&gt;Arquitectura de un sistema de trabajo de ingeniería con IA: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/tooling-equipos-alto-desempeno-sistemas-ingenieria-ia/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Las capas interactúan en dos direcciones. Hacia arriba, cada workflow consume capacidades, que a su vez dependen de integraciones con las fuentes de verdad. Hacia abajo, el aprendizaje modifica las capacidades y deja registro en las fuentes. Un equipo que solo invierte en las capas 2 y 3, conectores y prompts, obtiene velocidad sin dirección; uno que descuida la capa 5 obtiene velocidad sin control.&lt;/p&gt;

&lt;h2&gt;
  
  
  El plugin de ingeniería de Anthropic como caso de estudio
&lt;/h2&gt;

&lt;p&gt;El repositorio &lt;a href="https://github.com/anthropics/knowledge-work-plugins" rel="noopener noreferrer"&gt;knowledge-work-plugins&lt;/a&gt;, con licencia Apache 2.0, contiene plugins para distintos tipos de trabajo. El de ingeniería, en su versión 1.2.0 al commit &lt;code&gt;e91a134&lt;/code&gt;, se describe como diseñado principalmente para Cowork, la aplicación de escritorio de Anthropic, aunque también funciona en Claude Code. Su contenido es deliberadamente simple: diez skills escritas en Markdown, un archivo de conectores y una configuración de servidores MCP.&lt;/p&gt;

&lt;p&gt;Seis de esas skills se invocan como comandos (&lt;code&gt;/standup&lt;/code&gt;, revisión de código, &lt;code&gt;/architecture&lt;/code&gt;, &lt;code&gt;/debug&lt;/code&gt;, gestión de incidentes y &lt;code&gt;/deploy-checklist&lt;/code&gt;) y cuatro se activan automáticamente cuando el tema es relevante: diseño de sistemas, deuda técnica, estrategia de testing y documentación. Cada skill tiene una descripción que indica cuándo usarla, un procedimiento, un formato de salida y una sección que explica qué hacer si hay conectores disponibles. Hay un detalle menor pero ilustrativo: el README presenta los comandos como &lt;code&gt;/review&lt;/code&gt; e &lt;code&gt;/incident&lt;/code&gt;, mientras que las skills se llaman &lt;code&gt;code-review&lt;/code&gt; e &lt;code&gt;incident-response&lt;/code&gt;. Incluso un catálogo pequeño necesita mantenimiento.&lt;/p&gt;

&lt;p&gt;Dos decisiones de diseño son más interesantes que los comandos en sí. La primera es la &lt;strong&gt;independencia de herramientas&lt;/strong&gt;: las skills no nombran productos, sino categorías mediante marcadores como &lt;code&gt;~~source control&lt;/code&gt; o &lt;code&gt;~~monitoring&lt;/code&gt;, y el archivo de conectores mapea cada categoría a servidores concretos. La configuración &lt;code&gt;.mcp.json&lt;/code&gt; incluye servidores HTTP para Slack, Linear, Asana, Atlassian, Notion, GitHub, PagerDuty y Datadog, y no incluye ninguno para CI/CD. La segunda es el modo &lt;strong&gt;standalone o supercharged&lt;/strong&gt;: cada comando funciona con lo que la persona describe o pega, y mejora cuando hay conectores. La práctica queda separada de la integración.&lt;/p&gt;

&lt;p&gt;Lo que el plugin no hace también importa. No ejecuta controles deterministas ni impone aprobaciones: el checklist de despliegue es un documento que la persona completa, no un gate del pipeline. La gobernanza queda a cargo del entorno que lo ejecuta y del sistema de CI/CD del equipo. Es razonable que así sea, pero significa que adoptar el plugin no equivale a tener un proceso controlado.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Workflows manuales frente a asistidos, a partir de las skills del plugin (el beneficio y la métrica son propuestas propias)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Workflow&lt;/th&gt;
&lt;th&gt;Problema original&lt;/th&gt;
&lt;th&gt;Qué aporta la skill&lt;/th&gt;
&lt;th&gt;Responsabilidad humana&lt;/th&gt;
&lt;th&gt;Riesgo principal&lt;/th&gt;
&lt;th&gt;Métrica útil&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Standup&lt;/td&gt;
&lt;td&gt;Reconstruir de memoria commits, PRs y tickets&lt;/td&gt;
&lt;td&gt;Formato ayer/hoy/bloqueos; con conectores, toma commits, PRs, tickets y conversaciones&lt;/td&gt;
&lt;td&gt;Agregar matices, prioridades y bloqueos reales&lt;/td&gt;
&lt;td&gt;Confundir actividad con progreso; uso como vigilancia&lt;/td&gt;
&lt;td&gt;Tiempo de preparación; bloqueos detectados antes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Revisión de código&lt;/td&gt;
&lt;td&gt;Dependencia de pocos revisores&lt;/td&gt;
&lt;td&gt;Revisión estructurada en seguridad, performance, corrección y mantenibilidad, con veredicto&lt;/td&gt;
&lt;td&gt;Aprobar o rechazar; juzgar diseño y contexto&lt;/td&gt;
&lt;td&gt;Reviews superficiales que se aprueban por confianza&lt;/td&gt;
&lt;td&gt;Defectos encontrados después del merge; tiempo de revisión&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Decisiones de arquitectura&lt;/td&gt;
&lt;td&gt;Decisiones sin registro ni alternativas&lt;/td&gt;
&lt;td&gt;ADR con contexto, opciones, trade-offs, consecuencias y tareas&lt;/td&gt;
&lt;td&gt;Elegir, firmar y asumir la decisión&lt;/td&gt;
&lt;td&gt;ADR plausibles pero sin restricciones reales&lt;/td&gt;
&lt;td&gt;Decisiones revisadas con su ADR; retrabajo por decisiones&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Incidentes&lt;/td&gt;
&lt;td&gt;Comunicación desordenada y postmortems que no se escriben&lt;/td&gt;
&lt;td&gt;Severidad SEV1–4, roles, actualizaciones de estado y postmortem blameless con 5 porqués&lt;/td&gt;
&lt;td&gt;Comandar el incidente y decidir mitigaciones&lt;/td&gt;
&lt;td&gt;Diagnóstico confiado con contexto incompleto&lt;/td&gt;
&lt;td&gt;Tiempo hasta el postmortem; incidentes recurrentes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Despliegue&lt;/td&gt;
&lt;td&gt;Pasos olvidados y criterios de rollback improvisados&lt;/td&gt;
&lt;td&gt;Checklist antes, durante y después, con disparadores de rollback definidos de antemano&lt;/td&gt;
&lt;td&gt;Ejecutar el despliegue y decidir el rollback&lt;/td&gt;
&lt;td&gt;Tratar un checklist como un control&lt;/td&gt;
&lt;td&gt;Tasa de fallas de cambio; tiempo de recuperación&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Tools, skills, MCP, workflows, agentes y harness
&lt;/h2&gt;

&lt;p&gt;Estos términos se usan como sinónimos y no lo son. Distinguirlos ayuda a decidir en qué invertir.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Tool:&lt;/strong&gt; una capacidad para ejecutar o consultar una acción concreta, como leer un pull request o consultar una métrica.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Skill:&lt;/strong&gt; conocimiento e instrucciones reutilizables para hacer bien una tarea. Una skill no ejecuta nada por sí misma; orienta cómo se usan las tools.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MCP:&lt;/strong&gt; el &lt;a href="https://modelcontextprotocol.io/" rel="noopener noreferrer"&gt;Model Context Protocol&lt;/a&gt;, un protocolo abierto para conectar aplicaciones de IA con sistemas externos. Estandariza cómo se exponen las tools, no qué se hace con ellas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Workflow:&lt;/strong&gt; una secuencia coordinada de pasos orientada a un resultado, con puntos de decisión.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agente:&lt;/strong&gt; un sistema que razona sobre un objetivo y usa las capacidades disponibles dentro de límites definidos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Harness:&lt;/strong&gt; el entorno que rodea al agente con contexto, herramientas, restricciones, evaluación y mecanismos de control, como se analiza en &lt;a href="https://juliancardozo.github.io/blog/harness-engineering-agentes-codigo-guias-sensores/" rel="noopener noreferrer"&gt;este artículo sobre harness engineering&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;En una revisión de pull request, las piezas se combinan así: el servidor MCP de GitHub expone la tool que obtiene el diff; la skill de revisión indica qué dimensiones evaluar y qué formato entregar; el agente ejecuta el procedimiento; el workflow define que la revisión asistida ocurre después de que el pipeline pasa y antes de la revisión humana; y el harness aporta los controles deterministas, como tests, análisis estático y reglas de arquitectura, además de los permisos que impiden que el agente apruebe o fusione el cambio. Ninguna pieza sustituye a las otras.&lt;/p&gt;

&lt;h2&gt;
  
  
  Golden paths para el trabajo diario
&lt;/h2&gt;

&lt;p&gt;En Platform Engineering, un golden path es el camino recomendado y soportado para una tarea frecuente, normalmente crear un servicio o aprovisionar infraestructura. La idea se puede extender al trabajo diario: incorporar a una persona nueva, abrir y revisar un pull request, documentar una decisión, resolver un incidente, preparar un despliegue o gestionar deuda técnica. En cada caso, el estándar del equipo debería estar incorporado en la herramienta, no en una página de wiki que nadie consulta.&lt;/p&gt;

&lt;p&gt;Las skills son un vehículo natural para esto, porque convierten una práctica implícita en una capacidad explícita y versionada. La skill de deuda técnica del plugin, por ejemplo, propone una fórmula de priorización explícita: impacto más riesgo, multiplicado por seis menos el esfuerzo. Se puede discutir la fórmula, pero tenerla escrita permite discutirla. Bajo el enfoque de Platform as a Product, estas capacidades deberían tratarse como un producto interno: con usuarios, feedback, versiones y la libertad de no usarlas cuando no aplican. Un golden path que se impone por obligación deja de ser un camino fácil y se convierte en burocracia.&lt;/p&gt;

&lt;h2&gt;
  
  
  Alto desempeño sin burocracia
&lt;/h2&gt;

&lt;p&gt;Buena parte del valor inmediato está en reducir trabajo administrativo: standups escritos y asíncronos que parten de un borrador generado a partir de la actividad real, reportes que se arman solos, documentación generada y luego revisada, y una conexión directa entre tickets, código y resultados que permite detectar bloqueos antes de la reunión semanal.&lt;/p&gt;

&lt;p&gt;Conviene separar dos cosas que suelen mezclarse: automatizar la &lt;strong&gt;recopilación&lt;/strong&gt; de información y automatizar la &lt;strong&gt;interpretación&lt;/strong&gt; del trabajo humano. La primera es útil y de bajo riesgo. La segunda, como resumir el desempeño de una persona a partir de sus commits, es peligrosa: confunde actividad con aporte y convierte la herramienta en un mecanismo de vigilancia. Un standup generado debería ser un borrador para la persona, no un informe sobre ella. Si el equipo percibe que la herramienta lo observa, dejará de usarla o empezará a optimizar lo que mide.&lt;/p&gt;

&lt;h2&gt;
  
  
  La IA como acelerador del aprendizaje organizacional
&lt;/h2&gt;

&lt;p&gt;El aporte más duradero no es hacer más rápido una tarea, sino reducir el costo de convertir experiencia en conocimiento reutilizable. Dos ciclos lo muestran. En el primero, un incidente se investiga, se documenta en un postmortem, el aprendizaje se traduce en un runbook o una skill actualizada y eso previene o acorta el siguiente incidente. En el segundo, una decisión de arquitectura se registra en un ADR, se implementa, se observa con métricas y se revisa, y la revisión ajusta el estándar del equipo.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Dos ciclos de aprendizaje organizacional: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/tooling-equipos-alto-desempeno-sistemas-ingenieria-ia/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;La IA reduce el costo de cada paso: reconstruir la línea de tiempo, redactar el primer borrador del postmortem, proponer alternativas para un ADR. Lo que no puede hacer es decidir qué se aprendió. Es la misma lógica de &lt;a href="https://juliancardozo.github.io/blog/loop-engineering-agentic-loops/" rel="noopener noreferrer"&gt;Loop Engineering&lt;/a&gt; aplicada a la organización: un ciclo solo mejora si tiene una señal de salida y alguien que la evalúe. Y es una cuestión de context engineering: el aprendizaje que no queda registrado en una fuente de verdad no está disponible para el próximo ciclo, ni para las personas ni para los agentes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Caso práctico: una alerta de latencia de extremo a extremo
&lt;/h2&gt;

&lt;p&gt;El escenario es ficticio e ilustrativo. Nexo Logística, una empresa inventada, tiene un equipo de plataforma de cinco personas que mantiene servicios Java con Spring Boot desplegados en Kubernetes sobre AWS. Usa GitHub, Jira, GitHub Actions, SonarQube, New Relic y Backstage como portal interno, y Claude Code con servidores MCP para GitHub, Jira y su herramienta de monitoreo. Un martes a las 10:40, una alerta indica que la latencia p95 del servicio &lt;code&gt;order-pricing&lt;/code&gt; subió de forma sostenida.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Qué se asiste con IA, qué verifican los controles automáticos y qué decide una persona (escenario ficticio)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Paso&lt;/th&gt;
&lt;th&gt;Asistido con IA&lt;/th&gt;
&lt;th&gt;Verificación automática&lt;/th&gt;
&lt;th&gt;Responsabilidad humana&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Triage&lt;/td&gt;
&lt;td&gt;Resume la alerta, las métricas del servicio y propone una severidad con la skill de incidentes&lt;/td&gt;
&lt;td&gt;Umbrales de alerta y SLO definidos en el monitoreo&lt;/td&gt;
&lt;td&gt;La persona de guardia confirma la severidad y asume el rol de incident commander&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Contexto&lt;/td&gt;
&lt;td&gt;Cruza despliegues recientes, PRs fusionados y tickets: un cambio de ayer agregó una consulta por cada ítem del pedido&lt;/td&gt;
&lt;td&gt;Registro de despliegues de GitHub Actions y catálogo de Backstage&lt;/td&gt;
&lt;td&gt;Validar que la correlación tiene sentido&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Diagnóstico&lt;/td&gt;
&lt;td&gt;Con la skill de debug, formula hipótesis y señala un patrón N+1&lt;/td&gt;
&lt;td&gt;Trazas distribuidas que confirman el aumento de llamadas a la base&lt;/td&gt;
&lt;td&gt;Aceptar o descartar la causa raíz&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Mitigación&lt;/td&gt;
&lt;td&gt;Redacta las actualizaciones de estado&lt;/td&gt;
&lt;td&gt;Rollback automatizado del despliegue&lt;/td&gt;
&lt;td&gt;Decidir el rollback y comunicar&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Decisión técnica&lt;/td&gt;
&lt;td&gt;Borrador de ADR: consulta agregada frente a caché&lt;/td&gt;
&lt;td&gt;Prueba de carga comparativa en staging&lt;/td&gt;
&lt;td&gt;Elegir la opción y registrar el ADR&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Corrección y revisión&lt;/td&gt;
&lt;td&gt;Implementa el cambio y hace una primera revisión estructurada&lt;/td&gt;
&lt;td&gt;Tests, cobertura y quality gate de SonarQube en el pipeline&lt;/td&gt;
&lt;td&gt;Revisar y aprobar el pull request&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Despliegue&lt;/td&gt;
&lt;td&gt;Genera el checklist con disparadores de rollback a partir de las métricas actuales&lt;/td&gt;
&lt;td&gt;Canary con análisis automático de error y latencia&lt;/td&gt;
&lt;td&gt;Autorizar la promoción a producción&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Aprendizaje&lt;/td&gt;
&lt;td&gt;Redacta el postmortem y propone una regla nueva de revisión para consultas en bucles&lt;/td&gt;
&lt;td&gt;Una regla de análisis estático que detecta el patrón&lt;/td&gt;
&lt;td&gt;Aprobar el postmortem y la actualización del estándar&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;El caso muestra el reparto que conviene diseñar. La IA reduce el tiempo de recopilar y redactar; los controles deterministas, como tests, quality gates y el análisis del canary, verifican; y las personas deciden en los puntos donde hay responsabilidad: la severidad, la causa, la mitigación, la decisión técnica y la aprobación. El último paso es el más valioso, porque convierte el incidente en un control nuevo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Medir el impacto del tooling
&lt;/h2&gt;

&lt;p&gt;Las métricas fáciles de obtener son las menos útiles. La cantidad de prompts, los tokens consumidos, las líneas generadas o el número de pull requests miden actividad, no resultado, y pueden subir mientras la calidad baja. Las métricas relevantes provienen de marcos establecidos: &lt;a href="https://dora.dev/" rel="noopener noreferrer"&gt;DORA&lt;/a&gt; para el flujo de entrega y &lt;a href="https://queue.acm.org/detail.cfm?id=3454124" rel="noopener noreferrer"&gt;SPACE&lt;/a&gt; para recordar que la productividad tiene varias dimensiones, entre ellas la satisfacción y la colaboración.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Matriz de métricas para evaluar un sistema de trabajo&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Dimensión&lt;/th&gt;
&lt;th&gt;Indicadores&lt;/th&gt;
&lt;th&gt;Fuente&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Flujo de entrega&lt;/td&gt;
&lt;td&gt;Lead time for changes, frecuencia de despliegue, tasa de fallas de cambio, tiempo de recuperación de despliegues fallidos&lt;/td&gt;
&lt;td&gt;CI/CD y control de versiones&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Developer Experience&lt;/td&gt;
&lt;td&gt;Tiempo dedicado a buscar información, carga cognitiva percibida, tiempo de onboarding, fricción en tareas frecuentes, satisfacción con herramientas internas&lt;/td&gt;
&lt;td&gt;Encuestas breves y recurrentes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Calidad y operación&lt;/td&gt;
&lt;td&gt;Defectos en producción, incidentes recurrentes, tiempo de recuperación, actualización de la documentación, retrabajo por requisitos ambiguos&lt;/td&gt;
&lt;td&gt;Tracker, monitoreo y postmortems&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Adopción&lt;/td&gt;
&lt;td&gt;Uso efectivo de los workflows, tareas completadas sin asistencia manual innecesaria, utilidad percibida&lt;/td&gt;
&lt;td&gt;Telemetría de uso y encuestas&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Para que la medición sirva, hace falta una línea de base antes del cambio, comparar períodos equivalentes y desconfiar de las atribuciones causales simples. Si el lead time baja en el trimestre en que se adoptó una herramienta, también pudo influir un cambio de prioridades, una contratación o una estacionalidad. Las métricas de adopción y las de resultado deben leerse juntas: una herramienta muy usada que no mejora ningún resultado es un costo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Los riesgos de automatizar prácticas de ingeniería
&lt;/h2&gt;

&lt;p&gt;Automatizar una práctica no la mejora si la práctica es deficiente; la vuelve más rápida. Los riesgos más concretos son la dependencia excesiva de agentes y la pérdida gradual de conocimiento humano; las revisiones superficiales que se aprueban porque «ya lo revisó la IA»; las alucinaciones y el contexto incompleto; los conectores con permisos excesivos; la exposición de información sensible a través de integraciones; el prompt injection, especialmente cuando un agente lee contenido no confiable como issues, comentarios o logs; el aumento de la complejidad operativa y la dependencia de proveedores.&lt;/p&gt;

&lt;p&gt;Los controles son conocidos, aunque se apliquen poco: &lt;strong&gt;menor privilegio&lt;/strong&gt; en cada conector, empezando por accesos de solo lectura; &lt;strong&gt;auditoría&lt;/strong&gt; de lo que hace cada agente; &lt;strong&gt;evaluación continua&lt;/strong&gt; de la calidad de las salidas; preferencia por &lt;strong&gt;acciones reversibles&lt;/strong&gt;; &lt;strong&gt;controles deterministas&lt;/strong&gt; en los puntos críticos, en lugar de instrucciones; y &lt;strong&gt;human-in-the-loop&lt;/strong&gt; en toda acción con efectos externos, como fusionar, desplegar, paginar a alguien o comunicar a clientes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cómo implementarlo: una hoja de ruta de 90 días
&lt;/h2&gt;

&lt;p&gt;La hoja de ruta que sigue es una propuesta. Su premisa es empezar por la fricción real del equipo, no por la herramienta.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Días 1–30, discovery.&lt;/strong&gt; Entrevistas breves, observación de tareas frecuentes y una línea de base de métricas. Se eligen dos workflows de alto impacto y bajo riesgo; el standup asíncrono y la revisión asistida de pull requests suelen ser buenos candidatos, porque son frecuentes y la decisión final sigue siendo humana.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Días 31–60, piloto.&lt;/strong&gt; Se configuran las integraciones con permisos de solo lectura, se adaptan las skills a las prácticas del equipo, se definen los controles y se mide la adopción con usuarios reales, recogiendo feedback cada semana.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Días 61–90, evolución.&lt;/strong&gt; Se comparan los resultados con la línea de base, se corrigen los problemas, se documentan los aprendizajes y se decide qué capacidades escalar, cuáles ajustar y cuáles abandonar.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;Matriz de priorización de workflows candidatos (valoraciones ilustrativas)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Workflow&lt;/th&gt;
&lt;th&gt;Impacto&lt;/th&gt;
&lt;th&gt;Frecuencia&lt;/th&gt;
&lt;th&gt;Riesgo&lt;/th&gt;
&lt;th&gt;Esfuerzo&lt;/th&gt;
&lt;th&gt;Prioridad sugerida&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Standup asíncrono&lt;/td&gt;
&lt;td&gt;Medio&lt;/td&gt;
&lt;td&gt;Diaria&lt;/td&gt;
&lt;td&gt;Bajo&lt;/td&gt;
&lt;td&gt;Bajo&lt;/td&gt;
&lt;td&gt;Alta: piloto&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Revisión asistida de PR&lt;/td&gt;
&lt;td&gt;Alto&lt;/td&gt;
&lt;td&gt;Diaria&lt;/td&gt;
&lt;td&gt;Medio&lt;/td&gt;
&lt;td&gt;Medio&lt;/td&gt;
&lt;td&gt;Alta: piloto&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ADR asistido&lt;/td&gt;
&lt;td&gt;Alto&lt;/td&gt;
&lt;td&gt;Mensual&lt;/td&gt;
&lt;td&gt;Bajo&lt;/td&gt;
&lt;td&gt;Bajo&lt;/td&gt;
&lt;td&gt;Media&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Postmortem asistido&lt;/td&gt;
&lt;td&gt;Alto&lt;/td&gt;
&lt;td&gt;Ocasional&lt;/td&gt;
&lt;td&gt;Bajo&lt;/td&gt;
&lt;td&gt;Bajo&lt;/td&gt;
&lt;td&gt;Media&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Checklist de despliegue&lt;/td&gt;
&lt;td&gt;Medio&lt;/td&gt;
&lt;td&gt;Semanal&lt;/td&gt;
&lt;td&gt;Alto si reemplaza gates&lt;/td&gt;
&lt;td&gt;Medio&lt;/td&gt;
&lt;td&gt;Media, solo como complemento del pipeline&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Respuesta a incidentes con acciones&lt;/td&gt;
&lt;td&gt;Alto&lt;/td&gt;
&lt;td&gt;Ocasional&lt;/td&gt;
&lt;td&gt;Alto&lt;/td&gt;
&lt;td&gt;Alto&lt;/td&gt;
&lt;td&gt;Baja hasta tener controles maduros&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  El nuevo rol del Engineering Manager
&lt;/h2&gt;

&lt;p&gt;Cuando una parte del trabajo de coordinación se automatiza, el rol del Engineering Manager no desaparece: se desplaza. Pasa de organizar y supervisar tareas a diseñar el sistema de trabajo en el que esas tareas ocurren. Eso implica identificar las fricciones antes de que se normalicen, crear condiciones para la autonomía, promover estándares útiles en lugar de procesos, reducir dependencias entre equipos, facilitar el aprendizaje continuo, proteger la calidad de las decisiones y asegurar que la adopción de IA sea responsable, con permisos acotados y criterios explícitos.&lt;/p&gt;

&lt;p&gt;La IA no elimina la necesidad de liderazgo ni de coordinación humana. Cambia dónde se ejerce: menos en el seguimiento de tareas y más en las decisiones sobre qué automatizar, qué controlar y qué conocimiento preservar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusión
&lt;/h2&gt;

&lt;p&gt;El plugin de ingeniería de Anthropic es útil como caso de estudio precisamente por su simplicidad: muestra que una práctica de ingeniería puede escribirse como una capacidad explícita, reutilizable e independiente de la herramienta concreta, y que su valor crece cuando se conecta con las fuentes de verdad del equipo. También muestra sus límites: una skill orienta, pero no controla, y la gobernanza sigue siendo responsabilidad del sistema que la ejecuta.&lt;/p&gt;

&lt;p&gt;El objetivo no es que la IA haga más cosas por el equipo, sino diseñar un entorno en el que el equipo pueda concentrar su capacidad en los problemas que requieren inteligencia, creatividad y criterio profesional. Un equipo de alto desempeño, en ese sentido, es sostenible: reduce su costo de coordinación, conserva lo que aprende y mejora sus decisiones con cada ciclo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Referencias
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Anthropic. &lt;a href="https://github.com/anthropics/knowledge-work-plugins/tree/e91a134584eb798bac7fb0379358006a2b63b965/engineering" rel="noopener noreferrer"&gt;knowledge-work-plugins: engineering&lt;/a&gt;, commit &lt;code&gt;e91a134&lt;/code&gt;, versión 1.2.0 del plugin. Incluye &lt;a href="https://github.com/anthropics/knowledge-work-plugins/blob/e91a134584eb798bac7fb0379358006a2b63b965/engineering/README.md" rel="noopener noreferrer"&gt;README&lt;/a&gt;, &lt;a href="https://github.com/anthropics/knowledge-work-plugins/blob/e91a134584eb798bac7fb0379358006a2b63b965/engineering/CONNECTORS.md" rel="noopener noreferrer"&gt;CONNECTORS.md&lt;/a&gt; y &lt;code&gt;.mcp.json&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Model Context Protocol. &lt;a href="https://modelcontextprotocol.io/" rel="noopener noreferrer"&gt;Especificación y documentación&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;DORA. &lt;a href="https://dora.dev/" rel="noopener noreferrer"&gt;dora.dev&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Forsgren, N., Storey, M.-A., Maddila, C., Zimmermann, T., Houck, B. y Butler, J. (2021). &lt;a href="https://queue.acm.org/detail.cfm?id=3454124" rel="noopener noreferrer"&gt;The SPACE of Developer Productivity&lt;/a&gt;. ACM Queue.&lt;/li&gt;
&lt;li&gt;Skelton, M. y Pais, M. &lt;a href="https://teamtopologies.com/" rel="noopener noreferrer"&gt;Team Topologies&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;CNCF TAG App Delivery. &lt;a href="https://tag-app-delivery.cncf.io/whitepapers/platforms/" rel="noopener noreferrer"&gt;Platforms White Paper&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Backstage. &lt;a href="https://backstage.io/" rel="noopener noreferrer"&gt;backstage.io&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Nygard, M. (2011). &lt;a href="https://www.cognitect.com/blog/2011/11/15/documenting-architecture-decisions" rel="noopener noreferrer"&gt;Documenting Architecture Decisions&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;En síntesis: el desempeño de un equipo depende menos de la cantidad de herramientas que del sistema que forman. Convertir prácticas en capacidades explícitas, como hace el plugin de ingeniería de Anthropic, reduce el costo de coordinación y preserva conocimiento, pero solo genera valor si se integra con las fuentes de verdad, se gobierna con controles deterministas y aprobación humana, y se mide por resultados de entrega, calidad y experiencia, no por actividad.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>leadership</category>
      <category>ai</category>
      <category>devops</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Loop Engineering: cómo diseñar el ciclo de trabajo de los agentes de IA</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:26:46 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/loop-engineering-como-disenar-el-ciclo-de-trabajo-de-los-agentes-de-ia-3c52</link>
      <guid>https://dev.to/julian_cardozo_dev/loop-engineering-como-disenar-el-ciclo-de-trabajo-de-los-agentes-de-ia-3c52</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/loop-engineering-agentic-loops/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Quien trabaja con agentes de código conoce la secuencia: el agente entrega un resultado, una persona lo revisa y responde con indicaciones como "ejecutá los tests", "el build falló" o "intentá de nuevo". Cada una de esas respuestas es, en los hechos, una iteración de un ciclo de control. El ciclo existe, pero lo sostiene una persona. Loop Engineering, un término que empezó a circular a mediados de 2026, describe el esfuerzo de llevar ese ciclo al diseño del sistema: definir qué lo inicia, dónde se conserva el progreso, cómo se verifica cada resultado, qué información recibe el agente en la siguiente vuelta y bajo qué condiciones se detiene o pide intervención humana.&lt;/p&gt;

&lt;h2&gt;
  
  
  Un término reciente para un problema conocido
&lt;/h2&gt;

&lt;p&gt;Conviene distinguir lo establecido de lo emergente. La idea de que un agente es un modelo de lenguaje que razona y actúa dentro de un ciclo, usando herramientas, está bien asentada. El nombre &lt;em&gt;Loop Engineering&lt;/em&gt;, en cambio, es nuevo. El paper &lt;a href="https://arxiv.org/abs/2608.21884" rel="noopener noreferrer"&gt;Loop Engineering: Building Blocks, Adoption, and Impact&lt;/a&gt;, de Jai Lal Lulla, Vahram Nersesyan, Seyedmoein Mohsenimofidi, Christoph Treude y Sebastian Baltes, sitúa su aparición en junio de 2026, cuando distintos practicantes empezaron a describir un nivel de trabajo en el que, en lugar de interactuar con un agente mediante prompts, "los desarrolladores diseñan sistemas que promptean a los agentes por ellos".&lt;/p&gt;

&lt;p&gt;IBM, en &lt;a href="https://www.ibm.com/think/topics/loop-engineering" rel="noopener noreferrer"&gt;What is loop engineering?&lt;/a&gt;, publicado en julio de 2026, la define como la práctica de diseñar flujos agénticos que guían de forma iterativa a los agentes hacia objetivos definidos por el usuario, "con mínima intervención humana", y la presenta como una práctica emergente. Su modelo describe cuatro etapas —objetivo, acción, observación y ajuste— y subraya la necesidad de criterios de parada claros y verificables.&lt;/p&gt;

&lt;p&gt;El mismo paper aporta una advertencia que merece atención. Tras revisar la literatura gris sobre el tema, los autores encontraron un acuerdo amplio sobre los componentes de un loop, pero concluyen que esas fuentes "no aportan evidencia sistemática de los beneficios que afirman". Se trata, por lo tanto, de una práctica con fundamentos razonables y todavía poco estudiada. Este artículo la aborda con esa cautela.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cuatro prácticas complementarias
&lt;/h2&gt;

&lt;p&gt;Loop Engineering no sustituye a las prácticas anteriores; se apoya en ellas. Cada una responde a una pregunta distinta, y un ciclo bien diseñado no compensa instrucciones ambiguas, un contexto incompleto o un entorno mal delimitado: en esos casos, solo itera más rápido hacia un resultado deficiente.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;La pregunta que responde cada práctica&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Práctica&lt;/th&gt;
&lt;th&gt;Pregunta central&lt;/th&gt;
&lt;th&gt;Ejemplo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Prompt Engineering&lt;/td&gt;
&lt;td&gt;¿Qué se le pide al agente y de qué manera?&lt;/td&gt;
&lt;td&gt;Una delegación con objetivo, entradas, salidas y criterios de aceptación&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Context Engineering&lt;/td&gt;
&lt;td&gt;¿Qué información necesita para decidir bien?&lt;/td&gt;
&lt;td&gt;Indicar las rutas exactas de la especificación y del plan, en lugar de pedirle que explore el repositorio&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Harness Engineering&lt;/td&gt;
&lt;td&gt;¿Con qué herramientas, permisos y límites opera?&lt;/td&gt;
&lt;td&gt;Un agente de análisis sin acceso a la terminal; un navegador habilitado solo para el entorno local&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Loop Engineering&lt;/td&gt;
&lt;td&gt;¿Qué inicia el ciclo, cómo se mide el avance, qué se hace ante un error y cuándo termina?&lt;/td&gt;
&lt;td&gt;Un build fallido genera información estructurada para una nueva iteración, con un máximo de dos antes de escalar a una persona&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La frontera entre harness y loop no es nítida, y las fuentes no la trazan de la misma manera. El &lt;a href="https://developers.openai.com/cookbook/examples/agents_sdk/agent_improvement_loop" rel="noopener noreferrer"&gt;cookbook de OpenAI sobre ciclos de mejora de agentes&lt;/a&gt; define el harness como "el contrato completo alrededor del modelo", que incluye los controles de validación. Una distinción práctica es considerar el harness como el entorno en el que se ejecuta el agente, y el loop como la política de control que determina qué ocurre entre una ejecución y la siguiente.&lt;/p&gt;

&lt;h2&gt;
  
  
  La anatomía de un loop agéntico
&lt;/h2&gt;

&lt;p&gt;Al cruzar la definición de IBM, la revisión del paper y la experiencia que Anthropic documentó con agentes de larga duración, emergen nueve componentes. El paper resume los elementos comunes de la literatura: ciclos iniciados por un cronograma o por eventos del repositorio, acotados por condiciones de parada verificables por máquina, con archivos de estado persistentes, subagentes verificadores, presupuestos de tokens y puntos definidos de escalamiento a personas.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Trigger.&lt;/strong&gt; El evento que inicia la ejecución: un comando, un cambio en el repositorio, una tarea programada o el fallo de otro ciclo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Objetivo y especificación.&lt;/strong&gt; Lo que debe lograrse, expresado de modo que un componente distinto del agente pueda determinar si se logró.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Estado.&lt;/strong&gt; El progreso, conservado fuera de la ventana de contexto del modelo. Anthropic describe el problema con precisión: cada sesión nueva "comienza sin memoria de lo anterior". Su propuesta combina un archivo de progreso, una lista de funcionalidades en JSON y el historial de git (&lt;a href="https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents" rel="noopener noreferrer"&gt;Effective harnesses for long-running agents&lt;/a&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ejecución del agente.&lt;/strong&gt; El razonamiento y el uso de herramientas, dentro de los límites que fija el harness.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verificador.&lt;/strong&gt; Tests, compilación, contratos, análisis estático o la revisión de otro agente. Cuanto más determinista sea la señal, más confiable es el ciclo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Feedback.&lt;/strong&gt; La información del verificador que se incorpora a la siguiente iteración, y el formato en que se entrega.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reintento y recuperación.&lt;/strong&gt; Los mecanismos para corregir sin repetir el mismo error, incluida la posibilidad de volver a un estado válido conocido, por ejemplo mediante un commit.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Condiciones de parada.&lt;/strong&gt; Éxito verificado, presupuesto agotado, falta de avance o error no recuperable.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Intervención humana.&lt;/strong&gt; Los casos en los que el ciclo no debe decidir por sí mismo y devuelve el control.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;Arquitectura de un loop agéntico con verificación y escalamiento: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/loop-engineering-agentic-loops/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Pseudocódigo de un loop con verificadores, presupuesto y detección de estancamiento&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;run_loop&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;goal&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;budget&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;agent&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;execute&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;goal&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;context&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;relevant&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;feedback&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;last_feedback&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;report&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;verifiers&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;          &lt;span class="c1"&gt;# build, tests, contratos: señales deterministas&lt;/span&gt;
        &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;record&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;report&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;            &lt;span class="c1"&gt;# persistido en archivos y commits, no en el contexto&lt;/span&gt;

        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;report&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;passed&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="n"&gt;acceptance&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;met&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;Done&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evidence&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;report&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;        &lt;span class="c1"&gt;# éxito = verificación + aceptación, no la palabra del agente&lt;/span&gt;

        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;report&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;requires_human&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;             &lt;span class="c1"&gt;# dependencias nuevas, credenciales, ambigüedad de negocio&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;Escalate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;reason&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;report&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;blocker&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;iterations&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="n"&gt;budget&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;max_iterations&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;cost&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="n"&gt;budget&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;max_cost&lt;/span&gt; \
           &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;elapsed&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="n"&gt;budget&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;max_time&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;Escalate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;reason&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"presupuesto agotado"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;no_progress&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;window&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;         &lt;span class="c1"&gt;# los mismos errores en dos iteraciones seguidas&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;Escalate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;reason&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"sin avance"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

        &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;last_feedback&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;report&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;structured&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;   &lt;span class="c1"&gt;# archivo:línea, regla incumplida, salida del comando&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;report&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;regressed&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;restore_last_good&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;               &lt;span class="c1"&gt;# recuperación: volver al último estado verificado&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Dos aspectos del pseudocódigo concentran buena parte del diseño. El primero es que el éxito exige verificación y, además, aceptación contra la especificación: que los tests pasen es una condición necesaria, no suficiente. El segundo es que existen tres salidas distintas del éxito —decisión humana, presupuesto agotado y falta de avance— y en todas el estado queda preparado para que otra persona u otro agente retome el trabajo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Un caso de aplicación: loops dentro de un sistema multiagente
&lt;/h2&gt;

&lt;p&gt;En &lt;a href="https://juliancardozo.github.io/blog/orquestacion-multiagente-website-factory/" rel="noopener noreferrer"&gt;un artículo anterior&lt;/a&gt; describí &lt;a href="https://github.com/juliancardozo/website-factory-mvp" rel="noopener noreferrer"&gt;Website Factory&lt;/a&gt;, un sistema en el que un orquestador de Claude Code coordina seis subagentes especializados para convertir un brief en Markdown en un sitio Astro con Tailwind CSS 4, sobre el flujo de GitHub Spec Kit. Los agentes no se comunican entre sí: intercambian información a través de archivos. Aquel texto se centraba en la orquestación; este se ocupa de una cuestión diferente.&lt;/p&gt;

&lt;p&gt;Orquestar consiste en decidir quién hace cada tarea y en qué orden. Diseñar loops consiste en decidir qué ocurre cuando un resultado no cumple lo esperado. Un flujo bien orquestado pero sin ciclos de corrección se interrumpe ante el primer error; un sistema con ciclos pero sin orquestación reintenta sin saber a qué componente corresponde el problema. Ambos diseños se necesitan.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Distribución de responsabilidades en Website Factory&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Responsabilidad&lt;/th&gt;
&lt;th&gt;Responsable&lt;/th&gt;
&lt;th&gt;Artefacto&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Planificación&lt;/td&gt;
&lt;td&gt;Orquestador, mediante las skills de Spec Kit (specify, plan, tasks, analyze)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;spec.md&lt;/code&gt;, &lt;code&gt;plan.md&lt;/code&gt;, &lt;code&gt;tasks.md&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ejecución&lt;/td&gt;
&lt;td&gt;Subagentes especializados; el &lt;code&gt;frontend-engineer&lt;/code&gt; implementa&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;docs/*.md&lt;/code&gt;, &lt;code&gt;src/&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Verificación&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;astro check&lt;/code&gt;, &lt;code&gt;astro build&lt;/code&gt;, &lt;code&gt;validate_content.py&lt;/code&gt; y un &lt;code&gt;qa-reviewer&lt;/code&gt; independiente&lt;/td&gt;
&lt;td&gt;&lt;code&gt;docs/qa-report.md&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Control&lt;/td&gt;
&lt;td&gt;Orquestador: prioridades, reintentos, parada y escalamiento&lt;/td&gt;
&lt;td&gt;&lt;code&gt;docs/agent-runs.md&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  Lo que el sistema ya incorpora
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Un ciclo interno de implementación.&lt;/strong&gt; El agente que implementa ejecuta la verificación de tipos y el build; un error de compilación vuelve como salida del comando y origina una nueva iteración dentro de su sesión.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Un ciclo de evaluación y corrección acotado.&lt;/strong&gt; El &lt;code&gt;qa-reviewer&lt;/code&gt; registra hallazgos con severidad y referencia &lt;code&gt;archivo:línea&lt;/code&gt;; el orquestador aplica correcciones con un máximo de dos iteraciones, y lo que queda sin resolver se documenta como pendiente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verificación antes y después de implementar.&lt;/strong&gt; &lt;code&gt;/speckit.analyze&lt;/code&gt; revisa la consistencia entre especificación, plan y tareas antes de escribir código, y &lt;code&gt;/speckit.converge&lt;/code&gt; compara especificación y código al final.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Estado fuera del contexto.&lt;/strong&gt; La especificación, las tareas, el reporte de QA y el registro de cada delegación quedan en archivos versionados. Es un punto relevante: en su análisis de repositorios, el paper identificó 217 proyectos con ciclos autónomos y observó que casi todos versionaban la configuración que inicia el ciclo, pero casi ninguno los archivos de estado.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escalamiento según el tipo de error.&lt;/strong&gt; Cuando una tarea requería instalar una dependencia nueva, el sistema no la instaló: marcó la tarea como bloqueada y trasladó la decisión.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Un hallazgo de esa ejecución muestra por qué el verificador también necesita ser verificado. El &lt;code&gt;qa-reviewer&lt;/code&gt; detectó que el validador escrito por el agente de frontend cubría menos casos que el contrato que debía controlar. Un ciclo que confía en un verificador incompleto converge rápido, pero hacia un resultado equivocado.&lt;/p&gt;

&lt;h3&gt;
  
  
  Mejoras posibles, todavía no implementadas
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Un trigger automático.&lt;/strong&gt; Hoy el ciclo se inicia manualmente con &lt;code&gt;/website-factory&lt;/code&gt;; un pull request que modifique un brief sería un disparador natural.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Presupuestos explícitos&lt;/strong&gt; de tokens, tiempo y costo por ejecución, además del límite de iteraciones.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Detección de estancamiento&lt;/strong&gt;, comparando los errores de dos iteraciones consecutivas y escalando si se repiten.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Feedback con un esquema definido.&lt;/strong&gt; El reporte de QA es Markdown estructurado; un formato JSON con severidad, regla y ubicación sería más difícil de reinterpretar. Anthropic eligió JSON para su lista de funcionalidades precisamente porque el modelo tiende menos a modificarlo de forma indebida.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verificación de punta a punta integrada al ciclo.&lt;/strong&gt; La revisión visual en tres anchos de pantalla se realizó con un navegador, pero no forma parte de los verificadores automáticos.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Las condiciones de parada
&lt;/h2&gt;

&lt;p&gt;La condición de parada es probablemente la decisión de diseño más importante de un loop, y también la que con más facilidad queda implícita. Cuando no está definida, el ciclo termina cuando el modelo considera que terminó. Anthropic documenta ese modo de falla: agentes que, al observar que hubo avances, dan el trabajo por concluido, o que marcan funcionalidades como completas antes de comprobarlas.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Tipos de condición de parada&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Condición&lt;/th&gt;
&lt;th&gt;Qué previene&lt;/th&gt;
&lt;th&gt;Riesgo a considerar&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Máximo de iteraciones&lt;/td&gt;
&lt;td&gt;Ciclos indefinidos y costos sin control&lt;/td&gt;
&lt;td&gt;Un valor arbitrario; conviene basarlo en cuántas iteraciones suelen ser necesarias&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Presupuesto de tokens, tiempo y costo&lt;/td&gt;
&lt;td&gt;Que una tarea simple consuma recursos desproporcionados&lt;/td&gt;
&lt;td&gt;Interrumpir sin dejar el estado listo para retomar&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Aceptación verificable&lt;/td&gt;
&lt;td&gt;Dar por exitoso un resultado sin evidencia&lt;/td&gt;
&lt;td&gt;Criterios que el propio agente pueda reinterpretar&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Falta de avance&lt;/td&gt;
&lt;td&gt;Reintentar el mismo error con otra formulación&lt;/td&gt;
&lt;td&gt;Confundir cambio con avance: lo que importa son los errores resueltos, no el tamaño del diff&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Errores que requieren a una persona&lt;/td&gt;
&lt;td&gt;Que el agente resuelva decisiones que no le corresponden&lt;/td&gt;
&lt;td&gt;Clasificarlos de antemano: credenciales, dependencias, datos de negocio, despliegues&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;El riesgo más difícil de advertir es aceptar un resultado incorrecto porque las pruebas pasan. Un ciclo optimiza contra su verificador; si el verificador mide algo más acotado que la necesidad real, el ciclo encontrará la manera de satisfacerlo sin resolver el problema. Es una forma de la ley de Goodhart aplicada a agentes. IBM aborda una cuestión cercana con el concepto de &lt;em&gt;comprehension debt&lt;/em&gt;: la distancia entre la cantidad de código de un sistema y el grado en que las personas lo comprenden. Por eso resulta útil distinguir entre éxito técnico —el build pasa— y cumplimiento —el resultado responde a lo que el usuario necesitaba— y asegurar que este último incluya al menos un control que no haya escrito el mismo agente que produjo el código.&lt;/p&gt;

&lt;h2&gt;
  
  
  Observabilidad y gobernanza
&lt;/h2&gt;

&lt;p&gt;Desde la perspectiva de Platform Engineering, un loop agéntico es una carga de trabajo más, y requiere lo mismo que cualquier otra: trazas, logs, métricas, control de costos, permisos, aislamiento y auditoría. El cookbook de OpenAI ilustra un ciclo de mejora del propio agente en el que, según sus palabras, las trazas muestran qué ocurrió, el feedback explica qué importaba, los evals convierten esas expectativas en controles reutilizables y Codex implementa los cambios resultantes. Como punto de partida recomienda un ciclo revisado, en el que el sistema propone los cambios y una persona aprueba el diff antes del merge. Es un ejemplo construido con datos sintéticos, no una medición de resultados, pero su arquitectura es instructiva.&lt;/p&gt;

&lt;p&gt;En &lt;a href="https://openai.com/index/harness-engineering/" rel="noopener noreferrer"&gt;Harness engineering: leveraging Codex in an agent-first world&lt;/a&gt;, de febrero de 2026, OpenAI relató cómo un equipo construyó un producto interno cuyo código escribieron agentes, y señaló que el avance inicial fue más lento de lo previsto debido a un entorno insuficientemente especificado, no a las capacidades del modelo. La observación se extiende a los ciclos: la calidad del sistema depende en buena medida del entorno y de los verificadores.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Indicadores propuestos para evaluar un loop (propuesta; no son resultados medidos)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Indicador&lt;/th&gt;
&lt;th&gt;Pregunta que responde&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Porcentaje de ejecuciones verificadas con éxito&lt;/td&gt;
&lt;td&gt;¿El ciclo resuelve lo que se le pide sin intervención?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Reintentos por tarea aceptada&lt;/td&gt;
&lt;td&gt;¿Converge con pocas iteraciones o necesita muchas?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Costo por tarea aceptada&lt;/td&gt;
&lt;td&gt;¿Cuánto cuesta un resultado útil, no una ejecución?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tasa de escalamiento humano, por motivo&lt;/td&gt;
&lt;td&gt;¿Escala por razones de riesgo o por fallas del propio ciclo?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo hasta completar&lt;/td&gt;
&lt;td&gt;¿Cuánto transcurre desde el trigger hasta un resultado aceptado?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Defectos detectados después de la aceptación&lt;/td&gt;
&lt;td&gt;¿El verificador es más débil que la necesidad?&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La gobernanza agrega dos requisitos que la Developer Experience no puede pasar por alto. Cada ejecución debe poder reconstruirse —qué recibió, qué herramientas usó, qué verificó y por qué se detuvo— y cada agente debe operar con identidad y permisos propios, aislado en un worktree o en un sandbox. Un ciclo que no puede auditarse difícilmente pueda adoptarse a escala en un equipo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Los límites de la autonomía
&lt;/h2&gt;

&lt;p&gt;Los riesgos de un loop son los de cualquier sistema con realimentación, amplificados por un componente probabilístico:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Ciclos indefinidos&lt;/strong&gt;, que no fallan de manera visible: simplemente consumen recursos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verificadores insuficientes&lt;/strong&gt;, que convierten el ciclo en un mecanismo eficiente para producir resultados que superan controles equivocados.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Acumulación de errores.&lt;/strong&gt; Cada iteración parte del resultado anterior, de modo que un supuesto incorrecto temprano se convierte en la base de todo lo que sigue.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Contexto desactualizado.&lt;/strong&gt; El agente decide con una versión del estado que ya no es la vigente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Éxito prematuro.&lt;/strong&gt; El agente declara terminado un trabajo que no verificó de punta a punta.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Por estas razones, la autonomía de un sistema agéntico no debería evaluarse por la cantidad de intervención humana que elimina, sino por la evidencia verificable que produce y por la claridad de sus límites operativos. Mayor autonomía sin mayor evidencia no reduce el riesgo: lo desplaza.&lt;/p&gt;

&lt;h2&gt;
  
  
  Por dónde empezar
&lt;/h2&gt;

&lt;p&gt;Para un equipo que quiera diseñar su primer loop, una secuencia razonable es la siguiente:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Elegir una tarea con un verificador confiable y de bajo costo&lt;/strong&gt;, como un build y una suite de tests, o el cumplimiento de un contrato. Sin verificador no hay un ciclo de control, sino reintentos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Definir las condiciones de parada antes que el prompt&lt;/strong&gt;: éxito, presupuesto, falta de avance y casos de escalamiento.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mantener el estado fuera del contexto&lt;/strong&gt;, con un archivo de progreso y un commit por iteración.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Estructurar el feedback&lt;/strong&gt; con archivo, línea, regla incumplida y salida del comando, en lugar de mensajes genéricos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Comenzar con un ciclo revisado&lt;/strong&gt;, en el que el sistema propone y una persona aprueba, y reducir la revisión solo donde la evidencia lo justifique.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Medir resultados por tarea aceptada&lt;/strong&gt;, no por ejecución.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  El rol del ingeniero
&lt;/h2&gt;

&lt;p&gt;Desde la gestión de equipos de ingeniería, el cambio que se observa no implica menos ingeniería, sino ingeniería ejercida en otro nivel. Diseñar un loop requiere las competencias de siempre —definir requisitos verificables, elegir buenos tests, anticipar modos de falla, gestionar el riesgo y cuidar la experiencia de quienes usan el sistema—, aplicadas ahora a un ejecutor que no es una persona.&lt;/p&gt;

&lt;p&gt;Para un Tech Lead, esto desplaza buena parte del trabajo de mayor impacto hacia el verificador y las condiciones de parada, más que hacia la redacción del prompt. Para un Engineering Manager, implica tratar la adopción de agentes como una decisión de plataforma y de gobernanza, con métricas de resultado y puntos de escalamiento definidos. La ingeniería no desaparece; cambia el nivel de abstracción en el que se ejerce.&lt;/p&gt;

&lt;h3&gt;
  
  
  Referencias
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://www.ibm.com/think/topics/loop-engineering" rel="noopener noreferrer"&gt;What is loop engineering?&lt;/a&gt; — Ivan Belcic y Cole Stryker, IBM Think, 17 de julio de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://arxiv.org/abs/2608.21884" rel="noopener noreferrer"&gt;Loop Engineering: Building Blocks, Adoption, and Impact&lt;/a&gt; — Lulla, Nersesyan, Mohsenimofidi, Treude y Baltes, arXiv:2608.21884, agosto de 2026 (v3, octubre de 2026; JAWs@ASE 2026).&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents" rel="noopener noreferrer"&gt;Effective harnesses for long-running agents&lt;/a&gt; — Justin Young, Anthropic, 26 de noviembre de 2025.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://openai.com/index/harness-engineering/" rel="noopener noreferrer"&gt;Harness engineering: leveraging Codex in an agent-first world&lt;/a&gt; — Ryan Lopopolo, OpenAI, 11 de febrero de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://developers.openai.com/cookbook/examples/agents_sdk/agent_improvement_loop" rel="noopener noreferrer"&gt;Build an Agent Improvement Loop with Traces, Evals, and Codex&lt;/a&gt; — OpenAI Cookbook, 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/juliancardozo/website-factory-mvp" rel="noopener noreferrer"&gt;Website Factory&lt;/a&gt; — repositorio del caso, con la ejecución completa.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;En síntesis: un loop no es un agente que reintenta, sino un componente con disparador, estado persistido, verificador independiente, feedback estructurado, presupuesto y condiciones de parada definidas antes que el prompt. Poder explicar cuándo y por qué se detiene es la mejor prueba de que fue diseñado.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>spanish</category>
    </item>
    <item>
      <title>De ingeniería a producto: por qué las plataformas internas necesitan Technical Product Managers</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:21:39 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/de-ingenieria-a-producto-por-que-las-plataformas-internas-necesitan-technical-product-managers-1no3</link>
      <guid>https://dev.to/julian_cardozo_dev/de-ingenieria-a-producto-por-que-las-plataformas-internas-necesitan-technical-product-managers-1no3</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/technical-product-manager-developer-platform/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;El equipo de ingeniería de The New York Times publica en NYT Open una serie dedicada a los recorridos de sus Product Managers. Una de sus entregas, de febrero de 2026, presenta a Danny Cassidy, que llegó al diario en 2015 como ingeniero backend y hoy es Senior Technical Product Manager en el área que provee infraestructura y herramientas a los equipos de ingeniería de producto. Es un texto breve, con formato de perfil, pero plantea una cuestión que cualquier organización que construye una plataforma interna termina enfrentando: quién debe gestionar como producto algo cuyos usuarios son ingenieros.&lt;/p&gt;

&lt;h2&gt;
  
  
  Un recorrido que empieza en el código
&lt;/h2&gt;

&lt;p&gt;Según el artículo, Cassidy aprendió a programar por su cuenta en la escuela secundaria, estudió tecnologías de la información y trabajó como ingeniero en APIs backend y sistemas de gestión de contenidos para empresas de medios. En The Times se incorporó al equipo de las APIs que llevan el contenido del CMS a las aplicaciones de escritorio y móviles.&lt;/p&gt;

&lt;p&gt;El cambio de rol no surgió de un plan de carrera. A medida que participaba en proyectos más complejos y transversales, observó que los mejores líderes de ingeniería volvían una y otra vez a las mismas preguntas: por qué se construye algo, a quién sirve y cómo contribuye al negocio. Fue su responsable de entonces quien, al notar que su trabajo se inclinaba en esa dirección, le propuso considerar Product Management. Cassidy relata que hasta ese momento no sabía que existía el rol de Technical Product Manager.&lt;/p&gt;

&lt;p&gt;Ese detalle merece atención desde la gestión de equipos. La transición no la inició un proceso formal, sino un líder que reconoció un cambio en el tipo de trabajo en el que una persona estaba destacándose y abrió la conversación. Muchas trayectorias valiosas dependen de que alguien haga esa pregunta a tiempo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cuando los usuarios del producto son ingenieros
&lt;/h2&gt;

&lt;p&gt;En su rol actual, Cassidy es responsable de proveer infraestructura y herramientas centralizadas para que los equipos de ingeniería de producto de The Times trabajen con mayor eficiencia. Describe una plataforma muy técnica, con usuarios que tienen distintos niveles de experiencia y necesidades, y explica que recurre a su formación técnica casi a diario para moverse entre dominios técnicos y perfiles de usuario.&lt;/p&gt;

&lt;p&gt;La tesis central del artículo es que, en este tipo de producto, resulta difícil ejercer buen criterio de producto sin comprender cómo las decisiones técnicas afectan a los usuarios y a los resultados de negocio. En una plataforma interna, la distancia entre una decisión técnica y la experiencia del usuario es mínima: elegir un sistema de CI, una forma de gestionar secretos o un modelo de despliegue es, al mismo tiempo, decidir cómo trabajarán cientos de ingenieros.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Qué cambia cuando el producto es una plataforma interna (lectura propia, no del artículo original)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Dimensión&lt;/th&gt;
&lt;th&gt;Producto para clientes externos&lt;/th&gt;
&lt;th&gt;Plataforma para ingenieros&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Usuarios&lt;/td&gt;
&lt;td&gt;Personas que eligen si usar el producto&lt;/td&gt;
&lt;td&gt;Equipos internos que con frecuencia no tienen alternativa&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Señal de valor&lt;/td&gt;
&lt;td&gt;Adopción, retención, ingresos&lt;/td&gt;
&lt;td&gt;Tiempo de espera, autoservicio, fricción percibida, incidentes evitados&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Discovery&lt;/td&gt;
&lt;td&gt;Entrevistas, analítica de uso&lt;/td&gt;
&lt;td&gt;Lo anterior, más leer pipelines, tickets y post-mortems&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Costo de una mala decisión&lt;/td&gt;
&lt;td&gt;Una funcionalidad que no se usa&lt;/td&gt;
&lt;td&gt;Fricción multiplicada en todos los equipos durante años&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Conocimiento técnico requerido&lt;/td&gt;
&lt;td&gt;Útil&lt;/td&gt;
&lt;td&gt;Necesario para evaluar alternativas y sus consecuencias&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  El caso del reemplazo de CI/CD
&lt;/h2&gt;

&lt;p&gt;El ejemplo concreto del artículo es el que mejor ilustra el argumento. Un proveedor discontinuó la herramienta de CI/CD que usaban varios equipos, y eso generó bloqueos para los desarrolladores. Cassidy, que conocía esos bloqueos de primera mano, condujo una evaluación centrada en los usuarios y basada en datos, que abarcó a The New York Times y a Wirecutter.&lt;/p&gt;

&lt;p&gt;De acuerdo con el texto, esa evaluación permitió sintetizar los puntos de dolor de la plataforma, analizar alternativas con proyección a futuro y alinear a la organización en torno a una estrategia de CI/CD de largo plazo que equilibrara impacto de negocio, experiencia de desarrollo y factibilidad técnica. El artículo incluye una captura de la matriz de evaluación, en la que las necesidades de los equipos se priorizan y se comparan entre proveedores. No detalla los criterios completos ni cuál fue la herramienta elegida.&lt;/p&gt;

&lt;p&gt;Lo instructivo del caso es su encuadre. La discontinuación de un proveedor suele tratarse como un problema de infraestructura: encontrar un reemplazo equivalente y migrar. Abordarlo como una decisión de producto cambia las preguntas: qué necesitan hoy los equipos que la herramienta anterior no resolvía, qué necesidades son comunes y cuáles particulares, y qué alternativa sostiene mejor la evolución de la organización.&lt;/p&gt;

&lt;h3&gt;
  
  
  Cómo podría estructurarse una matriz de ese tipo
&lt;/h3&gt;

&lt;p&gt;El artículo no publica la matriz completa. A modo de ejemplo, una evaluación de proveedores de CI/CD que combine las tres dimensiones que menciona podría organizarse así:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Ejemplo ilustrativo de matriz de evaluación (propuesta propia, no la utilizada por The New York Times)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Dimensión&lt;/th&gt;
&lt;th&gt;Criterio&lt;/th&gt;
&lt;th&gt;Cómo se evidencia&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Experiencia de desarrollo&lt;/td&gt;
&lt;td&gt;Tiempo de feedback de un pipeline típico&lt;/td&gt;
&lt;td&gt;Prueba piloto con repositorios representativos de cada equipo&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Experiencia de desarrollo&lt;/td&gt;
&lt;td&gt;Esfuerzo de migración por repositorio&lt;/td&gt;
&lt;td&gt;Migración de muestra y estimación por tipo de proyecto&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Factibilidad técnica&lt;/td&gt;
&lt;td&gt;Integración con el entorno actual (nube, secretos, artefactos)&lt;/td&gt;
&lt;td&gt;Prueba de concepto y revisión de arquitectura&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Factibilidad técnica&lt;/td&gt;
&lt;td&gt;Seguridad y cumplimiento&lt;/td&gt;
&lt;td&gt;Revisión con el equipo de seguridad&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Impacto de negocio&lt;/td&gt;
&lt;td&gt;Costo total en tres años&lt;/td&gt;
&lt;td&gt;Licencias, cómputo y horas de mantenimiento&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Impacto de negocio&lt;/td&gt;
&lt;td&gt;Riesgo de proveedor&lt;/td&gt;
&lt;td&gt;Hoja de ruta pública, portabilidad de la configuración, salida posible&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Una lección del propio caso:&lt;/strong&gt; El punto de partida fue la discontinuación de un proveedor. Incluir el riesgo de proveedor y la portabilidad de la configuración como criterios explícitos reduce la probabilidad de repetir la misma situación con la herramienta elegida.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Por qué el perfil técnico es una ventaja en Platform Engineering
&lt;/h2&gt;

&lt;p&gt;El argumento conecta con una idea que ya había desarrollado en &lt;a href="https://juliancardozo.github.io/blog/developer-experience-ia-friccion-plataforma/" rel="noopener noreferrer"&gt;un análisis sobre Developer Experience y plataformas internas&lt;/a&gt;: una plataforma tratada como proyecto se entrega y se mantiene; una plataforma tratada como producto tiene usuarios, discovery, una hoja de ruta priorizada por valor y métricas de resultado. El perfil de Cassidy muestra quién puede sostener ese enfoque.&lt;/p&gt;

&lt;p&gt;En la práctica, un Technical Product Manager de plataforma aporta tres capacidades que difícilmente se encuentren juntas por separado:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Empatía con el usuario basada en experiencia propia.&lt;/strong&gt; Haber sufrido un pipeline lento o una migración mal planificada permite reconocer el problema real detrás de un pedido.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Capacidad para evaluar alternativas técnicas.&lt;/strong&gt; Sin reemplazar a los ingenieros en las decisiones de arquitectura, puede discutir consecuencias, costos de migración y riesgos con el mismo vocabulario.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Traducción hacia el negocio.&lt;/strong&gt; Puede explicar a la dirección por qué una inversión en infraestructura interna se traduce en velocidad de entrega, menos incidentes o menor costo operativo.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;El riesgo opuesto también existe y conviene nombrarlo. Un perfil muy técnico puede caer en la tentación de decidir la arquitectura en lugar de facilitar la decisión, o de priorizar lo técnicamente interesante sobre lo que más fricción elimina. El valor del rol está en mantener las preguntas de producto —por qué, para quién, con qué impacto— aun cuando el conocimiento técnico permitiría saltearlas.&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué pueden tomar los líderes de ingeniería
&lt;/h2&gt;

&lt;p&gt;Para quienes gestionan equipos, el artículo deja algunas lecciones prácticas, más allá del recorrido individual:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Gestionar la plataforma interna como un producto&lt;/strong&gt;, con una persona responsable de su estrategia, sus usuarios y sus resultados, y no solo de su operación.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Buscar ese perfil dentro de la organización.&lt;/strong&gt; Los ingenieros que preguntan sistemáticamente por qué y para quién se construye algo suelen ser los mejores candidatos, aunque nunca hayan considerado el rol.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tratar los cambios forzados de proveedor como decisiones de producto&lt;/strong&gt;, con discovery, criterios explícitos y participación de los equipos afectados.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Documentar la evaluación.&lt;/strong&gt; Una matriz compartida no solo ayuda a decidir: permite que la organización entienda y acepte la decisión.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Equilibrar explícitamente tres dimensiones&lt;/strong&gt;: impacto de negocio, experiencia de desarrollo y factibilidad técnica. Optimizar una sola suele trasladar el costo a las otras dos.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;El texto de NYT Open cierra invitando a quienes tienen formación técnica a considerar Product Management como próximo paso. Desde la perspectiva de una organización, la lectura complementaria es igual de relevante: las plataformas internas se benefician especialmente de que alguien con ese recorrido las gestione como un producto.&lt;/p&gt;

&lt;h3&gt;
  
  
  Referencias
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://open.nytimes.com/the-right-team-for-the-job-from-engineering-to-product-a-superpower-for-developer-platform-a290e65970ea" rel="noopener noreferrer"&gt;The Right Team for the Job: From Engineering to Product: A Superpower for Developer Platform Strategy&lt;/a&gt; — Geethu Jacob, Daniel Cassidy, Nikki Larson y Erica Vendetti, NYT Open, 11 de febrero de 2026.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;En síntesis: cuando los usuarios de un producto son ingenieros, el criterio de producto depende de comprender las consecuencias técnicas de cada decisión. Un Technical Product Manager con experiencia en ingeniería puede sostener esa doble mirada y convertir decisiones de infraestructura en decisiones de producto.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>leadership</category>
      <category>product</category>
      <category>devops</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Open Finance como infraestructura: la arquitectura que hay detrás del consentimiento</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:21:34 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/open-finance-como-infraestructura-la-arquitectura-que-hay-detras-del-consentimiento-589</link>
      <guid>https://dev.to/julian_cardozo_dev/open-finance-como-infraestructura-la-arquitectura-que-hay-detras-del-consentimiento-589</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/open-finance-argentina-arquitectura-apis-consentimiento/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;En octubre, Forbes Argentina publicó la crónica de un panel del Summit Fintech 2026 dedicado a Open Finance, con Julián Bersano, CEO y cofundador de Klimber, y Andrés Gil, socio de Cyber en Banca, Seguros y Tecnología de Deloitte. La conversación giró alrededor de una idea: que el cliente controle sus datos financieros y pueda compartirlos, con su consentimiento, con otros proveedores. La nota se detiene en el impacto sobre la competencia, la regulación y la educación financiera. Este artículo se ocupa de la capa que la hace posible: qué tiene que existir, en términos de arquitectura, para que compartir datos financieros sea seguro, auditable y revocable.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lo que se dijo en el panel
&lt;/h2&gt;

&lt;p&gt;Según la crónica, firmada por Andrea Glikman, Open Finance reúne en un mismo acceso información de cuentas bancarias, billeteras virtuales, inversiones, seguros y créditos. El usuario decide qué datos comparte, con quién, con qué finalidad y por cuánto tiempo, y a cambio puede acceder a ofertas más ajustadas a su perfil. Bersano lo describió como la "democratización de los servicios financieros" y calificó al mercado argentino de incipiente.&lt;/p&gt;

&lt;p&gt;Gil aportó la mirada de seguridad y regulación. Mencionó el Decreto 353 de mayo de 2025 como punto de partida de la agenda de finanzas abiertas, con principios generales que todavía requieren normas específicas, y planteó la necesidad de actualizar la legislación de protección de datos personales y fortalecer su aplicación. Sostuvo además dos ideas con consecuencias directas para la arquitectura: que los datos no estarán en un repositorio central, sino en cada participante, compartidos mediante reglas comunes; y que la seguridad no puede pensarse entidad por entidad, porque una organización con buenos controles queda expuesta a las vulnerabilidades de sus contrapartes.&lt;/p&gt;

&lt;p&gt;El panel dejó abierta una pregunta concreta: quién verificará que las APIs sean seguras y cómo se controlará a los participantes que acceden al ecosistema. Es, en esencia, una pregunta de ingeniería de plataformas.&lt;/p&gt;

&lt;h2&gt;
  
  
  Los componentes de un ecosistema de Open Finance
&lt;/h2&gt;

&lt;p&gt;Los mercados que avanzaron antes —el Reino Unido con Open Banking, Brasil con Open Finance— convergieron en una arquitectura con piezas reconocibles. Ninguna es exótica por separado; la dificultad está en que deben funcionar igual en decenas de organizaciones con sistemas, prioridades y niveles de madurez distintos.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Arquitectura de referencia de un ecosistema de Open Finance: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/open-finance-argentina-arquitectura-apis-consentimiento/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Responsabilidad de cada componente&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Componente&lt;/th&gt;
&lt;th&gt;Responsabilidad&lt;/th&gt;
&lt;th&gt;Pregunta que responde&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Directorio de participantes&lt;/td&gt;
&lt;td&gt;Registrar entidades habilitadas, sus roles y sus certificados&lt;/td&gt;
&lt;td&gt;¿Quién puede participar y quién es cada uno?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Servidor de autorización&lt;/td&gt;
&lt;td&gt;Autenticar al usuario y emitir tokens con alcance acotado&lt;/td&gt;
&lt;td&gt;¿Qué autorizó el usuario y a quién?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Servicio de consentimientos&lt;/td&gt;
&lt;td&gt;Persistir cada consentimiento, su finalidad, su vigencia y su estado&lt;/td&gt;
&lt;td&gt;¿Este acceso sigue siendo válido hoy?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;API gateway&lt;/td&gt;
&lt;td&gt;Aplicar autenticación mutua, límites de uso y validación del consentimiento en cada llamada&lt;/td&gt;
&lt;td&gt;¿Esta llamada concreta está permitida?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;APIs de datos&lt;/td&gt;
&lt;td&gt;Exponer información con esquemas comunes y versionados&lt;/td&gt;
&lt;td&gt;¿Qué datos se entregan y en qué formato?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Auditoría y eventos&lt;/td&gt;
&lt;td&gt;Registrar accesos y propagar cambios de estado&lt;/td&gt;
&lt;td&gt;¿Qué ocurrió, cuándo y quién lo hizo?&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  El consentimiento es una máquina de estados
&lt;/h2&gt;

&lt;p&gt;La definición que se escuchó en el panel —qué datos, con quién, para qué y por cuánto tiempo— es, leída desde la ingeniería, la especificación de un objeto. El error más frecuente es tratar el consentimiento como un booleano o como un registro que se escribe una vez. En la práctica es un proceso con estados, transiciones y efectos, del mismo modo que un cobro no es una llamada HTTP sino un proceso de negocio auditable, como desarrollé en &lt;a href="https://juliancardozo.github.io/blog/webhooks-pagos-maquinas-de-estado/" rel="noopener noreferrer"&gt;un artículo sobre webhooks de pago&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Ciclo de vida de un consentimiento: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/open-finance-argentina-arquitectura-apis-consentimiento/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Modelarlo así tiene consecuencias de diseño concretas. Las transiciones deben ser idempotentes, porque una revocación puede llegar dos veces. Los estados finales no deben poder reabrirse: un nuevo acceso exige un consentimiento nuevo. Cada llamada a una API de datos debe validar el estado vigente, no el estado al momento de emitir el token. Y la revocación tiene que propagarse a los receptores mediante eventos, con reintentos y verificación, para que dejen de usar los datos y no solo de pedirlos.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Ejemplo ilustrativo de solicitud de acceso con detalle de autorización (estructura inspirada en RFC 9396; los campos no corresponden a un estándar argentino)&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"authorization_details"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"account_information"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="nl"&gt;"purpose"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"evaluacion_crediticia"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="nl"&gt;"permissions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"accounts:read"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"balances:read"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"transactions:read"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="nl"&gt;"transaction_window_days"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;180&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="nl"&gt;"expires_at"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"2027-05-13T00:00:00-03:00"&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;La finalidad (&lt;code&gt;purpose&lt;/code&gt;) merece una mención aparte. No es un dato decorativo: es lo que permite, más adelante, auditar si los datos se usaron para lo que el usuario autorizó. Un diseño que no la persiste en el consentimiento ni la asocia a cada acceso no puede responder esa pregunta.&lt;/p&gt;

&lt;h2&gt;
  
  
  Seguridad sistémica: proteger APIs entre organizaciones
&lt;/h2&gt;

&lt;p&gt;La observación de Gil sobre la seguridad del ecosistema tiene una traducción técnica directa. En un esquema de Open Finance, una entidad con controles robustos puede verse comprometida si uno de los participantes a los que entrega datos tiene credenciales débiles o tokens que pueden reutilizarse. Por eso los mercados que avanzaron no dejaron la seguridad de las APIs librada al criterio de cada organización: adoptaron perfiles de seguridad comunes.&lt;/p&gt;

&lt;p&gt;El más difundido es FAPI (Financial-grade API), de la OpenID Foundation, que construye sobre OAuth 2.0 y OpenID Connect y restringe las opciones a las combinaciones adecuadas para datos financieros. Brasil lo adoptó para su Open Finance, y el Reino Unido lo utiliza en su estándar de Open Banking. Sus mecanismos centrales responden a riesgos específicos:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Mecanismos de un perfil de seguridad para APIs financieras&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Mecanismo&lt;/th&gt;
&lt;th&gt;Especificación&lt;/th&gt;
&lt;th&gt;Riesgo que mitiga&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Pushed Authorization Requests (PAR)&lt;/td&gt;
&lt;td&gt;RFC 9126&lt;/td&gt;
&lt;td&gt;Manipulación de los parámetros de la solicitud en el navegador del usuario&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Autenticación mutua con TLS&lt;/td&gt;
&lt;td&gt;RFC 8705&lt;/td&gt;
&lt;td&gt;Que un cliente no registrado se haga pasar por un participante habilitado&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tokens restringidos al emisor (mTLS o DPoP)&lt;/td&gt;
&lt;td&gt;RFC 8705 / RFC 9449&lt;/td&gt;
&lt;td&gt;Reutilización de un token robado por un tercero&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Detalle de autorización&lt;/td&gt;
&lt;td&gt;RFC 9396&lt;/td&gt;
&lt;td&gt;Permisos amplios cuando el usuario autorizó algo específico&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pruebas de conformidad&lt;/td&gt;
&lt;td&gt;Suites de la OpenID Foundation&lt;/td&gt;
&lt;td&gt;Implementaciones que dicen cumplir el perfil y no lo cumplen&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La última fila responde, en parte, la pregunta que el panel dejó abierta. En los ecosistemas más maduros, la verificación de que una API es segura no depende de una auditoría documental: combina un perfil técnico obligatorio, pruebas de conformidad automatizadas que cada participante debe superar y un directorio que solo emite credenciales a quienes cumplen. La supervisión deja de ser un control periódico y se convierte en una condición para operar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Datos distribuidos, contratos comunes
&lt;/h2&gt;

&lt;p&gt;Que los datos permanezcan en cada participante, como señaló Gil, es una decisión acertada desde la privacidad y la resiliencia: no hay un repositorio central que concentre riesgo. Pero traslada la complejidad a los contratos. Si cada entidad expone sus datos con un esquema propio, cada receptor debe construir y mantener una integración por proveedor, y la promesa de comparar ofertas con facilidad se diluye.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Esquemas comunes y versionados.&lt;/strong&gt; Una especificación compartida, por ejemplo en OpenAPI, con reglas explícitas de compatibilidad y plazos de convivencia entre versiones.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Niveles de servicio públicos.&lt;/strong&gt; Disponibilidad, latencia y límites de uso medidos y publicados por cada proveedor; sin ellos, un receptor no puede ofrecer una experiencia confiable.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Semántica precisa.&lt;/strong&gt; Qué significa "saldo disponible", en qué moneda y zona horaria se informan los movimientos, cómo se identifican las cuentas. Las diferencias semánticas generan más errores que los formatos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Entornos de prueba compartidos.&lt;/strong&gt; Un sandbox con datos sintéticos realistas acelera la integración y permite automatizar las pruebas de conformidad.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Para equipos que trabajan con plataformas multi-tenant, el problema resulta familiar: como se analiza en &lt;a href="https://juliancardozo.github.io/blog/multi-tenancy-rls-frontera-datos/" rel="noopener noreferrer"&gt;el artículo sobre Row Level Security&lt;/a&gt;, el aislamiento y la autorización deben resolverse en la capa de datos, no confiarse a cada pantalla o servicio. El mismo principio, aplicado a nivel de ecosistema, lleva a validar el consentimiento en el gateway en cada llamada, y no solo al emitir el token.&lt;/p&gt;

&lt;h2&gt;
  
  
  Agentes de IA con acceso a datos financieros
&lt;/h2&gt;

&lt;p&gt;Bersano planteó, en condicional, que agentes de IA podrían comparar créditos o seguros en nombre del usuario y proponer alternativas según su perfil. Es una posibilidad plausible, y también el escenario que más exige de la arquitectura de consentimiento.&lt;/p&gt;

&lt;p&gt;Un agente que actúa por un usuario necesita una autorización delegada con alcance mínimo, finalidad explícita y vigencia corta; no las credenciales del usuario. Cada acceso debe quedar atribuido al agente y al consentimiento que lo habilitó. Y el agente no debería poder ampliar sus propios permisos ni encadenar finalidades: comparar ofertas de crédito no es lo mismo que contratar una. Las mismas reglas que ordenan el trabajo de agentes en desarrollo de software —mínimo privilegio, verificadores deterministas y escalamiento a una persona ante decisiones con consecuencias, como se analiza en &lt;a href="https://juliancardozo.github.io/blog/loop-engineering-agentic-loops/" rel="noopener noreferrer"&gt;el artículo sobre Loop Engineering&lt;/a&gt;— se vuelven, en finanzas, requisitos de cumplimiento.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fraude, transparencia y educación
&lt;/h2&gt;

&lt;p&gt;El cierre de la nota advierte que, sin estándares, una mayor circulación de información puede aumentar el riesgo de fraude. La ingeniería puede reducir ese riesgo, aunque no eliminarlo. Tres prácticas tienen un impacto directo:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Un panel de consentimientos para el usuario&lt;/strong&gt;, en cada entidad, que muestre quién accede a qué datos, con qué finalidad y hasta cuándo, con revocación en un paso. Es la contraparte técnica de la educación financiera que reclamó el panel.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Detección de anomalías sobre el patrón de acceso&lt;/strong&gt;: volúmenes, horarios o tipos de datos inusuales para un receptor y una finalidad determinados.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Trazabilidad de punta a punta&lt;/strong&gt;: un identificador de correlación que permita reconstruir, ante un reclamo, el recorrido desde la autorización hasta cada lectura de datos.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Lo que un equipo puede hacer hoy
&lt;/h2&gt;

&lt;p&gt;Según la nota, Argentina cuenta con un marco inicial y con experiencias de intercambio entre entidades mediante APIs, pero todavía carece de reglas específicas y de mecanismos efectivos de supervisión. Para un equipo técnico en un banco o una fintech, esperar la norma definitiva no es la única opción. Hay decisiones que resultan valiosas en cualquier escenario regulatorio:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Modelar el consentimiento como entidad propia&lt;/strong&gt;, con estados, finalidad, vigencia y auditoría, aunque hoy solo se use internamente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Separar autorización de acceso a datos&lt;/strong&gt;: un servidor de autorización basado en estándares abiertos y un gateway que valide cada llamada.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Adoptar un perfil de seguridad reconocido&lt;/strong&gt;, como FAPI, en lugar de diseñar uno propio. Es más fácil adaptarse a una norma futura desde un estándar que desde una solución a medida.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Documentar las APIs con contratos versionados&lt;/strong&gt; y publicar niveles de servicio, aunque los consumidores sean, por ahora, internos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Diseñar la revocación desde el inicio&lt;/strong&gt;, incluida su propagación a terceros y la eliminación de los datos ya entregados cuando corresponda.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Medir el ecosistema, no solo la integración&lt;/strong&gt;: tasa de consentimientos revocados, tiempo de propagación de una revocación, accesos rechazados por consentimiento vencido.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Open Finance suele presentarse como un cambio de modelo de negocio, y lo es. Pero su viabilidad se decide en una capa menos visible: la que garantiza que cada dato compartido tenga una autorización vigente, una finalidad declarada y un registro que permita explicarlo. Como dijo Gil en el panel, lo que importa de cualquier normativa es cómo se aplica; en este caso, buena parte de esa aplicación será código.&lt;/p&gt;

&lt;h3&gt;
  
  
  Referencias
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://www.forbesargentina.com/summit/open-finance-infraestructura-puede-cambiar-negocio-fintech-bancos-argentina-n100767" rel="noopener noreferrer"&gt;Open Finance: la infraestructura que puede cambiar el negocio de fintech y bancos en la Argentina&lt;/a&gt; — Andrea Glikman, Forbes Argentina, 21 de octubre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://openid.net/wg/fapi/" rel="noopener noreferrer"&gt;FAPI Working Group&lt;/a&gt; — OpenID Foundation: perfiles de seguridad para APIs financieras.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.rfc-editor.org/rfc/rfc9126" rel="noopener noreferrer"&gt;RFC 9126: OAuth 2.0 Pushed Authorization Requests&lt;/a&gt; — IETF.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.rfc-editor.org/rfc/rfc8705" rel="noopener noreferrer"&gt;RFC 8705: OAuth 2.0 Mutual-TLS Client Authentication and Certificate-Bound Access Tokens&lt;/a&gt; — IETF.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.rfc-editor.org/rfc/rfc9449" rel="noopener noreferrer"&gt;RFC 9449: OAuth 2.0 Demonstrating Proof of Possession (DPoP)&lt;/a&gt; — IETF.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.rfc-editor.org/rfc/rfc9396" rel="noopener noreferrer"&gt;RFC 9396: OAuth 2.0 Rich Authorization Requests&lt;/a&gt; — IETF.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;En síntesis: Open Finance se discute como una transformación de negocio, pero se construye como infraestructura. Consentimiento modelado como máquina de estados, un perfil de seguridad común, un directorio de participantes, contratos versionados y revocación de punta a punta son las condiciones para que compartir datos financieros sea, además de posible, confiable.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>payments</category>
      <category>architecture</category>
      <category>security</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Quarkus para equipos Java: qué cambia cuando el framework arranca en el build</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:16:28 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/quarkus-para-equipos-java-que-cambia-cuando-el-framework-arranca-en-el-build-337o</link>
      <guid>https://dev.to/julian_cardozo_dev/quarkus-para-equipos-java-que-cambia-cuando-el-framework-arranca-en-el-build-337o</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/quarkus-java-cloud-native-equipos-spring/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Quarkus se presenta como un framework Java para construir aplicaciones cloud-native rápidas y eficientes. Su documentación, organizada en un índice de guías que hoy corresponde a la versión 3.40, cubre desde la primera API REST hasta compilación nativa, mensajería, seguridad y observabilidad. Para un equipo que trabaja con Spring Boot, la pregunta relevante no es si Quarkus es más rápido, sino qué cambia en la forma de construir, probar y operar un servicio, y qué costos implica ese cambio. Este artículo recorre las guías con esa pregunta, a partir de una trayectoria que empezó en backend Java con Spring.&lt;/p&gt;

&lt;h2&gt;
  
  
  La idea central: mover trabajo del arranque al build
&lt;/h2&gt;

&lt;p&gt;Un framework Java tradicional hace buena parte de su trabajo cuando la aplicación arranca: escanea el classpath, lee anotaciones mediante reflexión, construye el grafo de dependencias, genera proxies y procesa la configuración. Ese trabajo se repite en cada inicio y consume tiempo y memoria durante toda la vida del proceso.&lt;/p&gt;

&lt;p&gt;Quarkus traslada la mayor parte de ese trabajo a la compilación. El proyecto lo llama &lt;em&gt;compile time boot&lt;/em&gt;: durante el build, cada extensión analiza el código, resuelve la inyección de dependencias, precalcula metadatos y genera el código necesario para arrancar. En tiempo de ejecución queda un proceso que ya sabe qué tiene que hacer. Según la página del proyecto, eso permite arranques rápidos y menor consumo de memoria tanto en la JVM como en ejecutables nativos.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Dónde ocurre el trabajo: arranque tradicional frente a compile time boot: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/quarkus-java-cloud-native-equipos-spring/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Esta decisión de diseño tiene consecuencias que conviene conocer antes de adoptar el framework. Lo que se resuelve en el build no puede cambiar en ejecución: la inyección de dependencias se determina al compilar, y por eso, por ejemplo, la anotación &lt;code&gt;@Conditional&lt;/code&gt; de Spring no tiene efecto en la capa de compatibilidad. La flexibilidad se traslada a los perfiles de configuración y de build, no al arranque.&lt;/p&gt;

&lt;h2&gt;
  
  
  JVM, caché AOT o nativo: qué dicen los números oficiales
&lt;/h2&gt;

&lt;p&gt;La compilación a ejecutable nativo con GraalVM o Mandrel es la característica más citada de Quarkus, y también la más malinterpretada. La propia guía de compilación nativa es explícita: Quarkus en la JVM ya es rápido, y para muchas aplicaciones el modo JVM es la opción correcta. Su recomendación es empezar en JVM y pasar a nativo cuando exista una necesidad concreta.&lt;/p&gt;

&lt;p&gt;La guía publica una comparación entre tres modos de ejecución, medida en abril de 2026 con Quarkus 3.34.3, JDK 25 y GraalVM 25, sobre 4 CPU y un heap máximo de 512 MB:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Modos de ejecución según la guía oficial de compilación nativa (benchmark del proyecto, no medición propia)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Indicador&lt;/th&gt;
&lt;th&gt;JVM (fast-jar)&lt;/th&gt;
&lt;th&gt;JVM + caché AOT de Leyden&lt;/th&gt;
&lt;th&gt;Nativo (Mandrel)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Arranque en frío&lt;/td&gt;
&lt;td&gt;≈ 0,4 s a 3 s&lt;/td&gt;
&lt;td&gt;≈ 80 ms a 900 ms&lt;/td&gt;
&lt;td&gt;≈ 17 ms a 240 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo hasta la primera respuesta&lt;/td&gt;
&lt;td&gt;4.417 ms&lt;/td&gt;
&lt;td&gt;1.859 ms&lt;/td&gt;
&lt;td&gt;581 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Throughput máximo&lt;/td&gt;
&lt;td&gt;13.265 tps&lt;/td&gt;
&lt;td&gt;12.389 tps (≈ 7 % menos)&lt;/td&gt;
&lt;td&gt;5.411 tps (≈ 59 % menos)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Memoria residente (RSS)&lt;/td&gt;
&lt;td&gt;304 MiB&lt;/td&gt;
&lt;td&gt;240 MiB&lt;/td&gt;
&lt;td&gt;95 MiB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tiempo de build&lt;/td&gt;
&lt;td&gt;≈ 30 s&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;3 a 10 min, con 4 a 8 GB de RAM&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La tabla muestra un trade-off claro. El ejecutable nativo arranca en milisegundos y usa una fracción de la memoria, pero en este benchmark entrega menos de la mitad del throughput máximo y multiplica el tiempo de build. La guía lo resume en criterios: nativo cuando el arranque es crítico (serverless, escalado a cero, herramientas de línea de comandos), la memoria es escasa o el tamaño de la imagen importa; JVM cuando el throughput máximo es prioritario, el tiempo de build es una restricción o la aplicación depende mucho de reflexión o carga dinámica de clases.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Una lectura práctica:&lt;/strong&gt; La opción intermedia —la JVM con la caché AOT del proyecto Leyden, disponible desde JDK 24— reduce el arranque y la memoria con una pérdida de throughput pequeña y sin renunciar a las herramientas habituales de la JVM. Para servicios de larga duración, suele ser el primer paso a evaluar antes que el nativo.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  La experiencia de desarrollo: dev mode, testing continuo y Dev Services
&lt;/h2&gt;

&lt;p&gt;El testimonio de Adoptium que aparece en el sitio del proyecto ilustra un punto que los benchmarks no capturan: para aplicaciones de larga duración, el arranque rápido no era decisivo, pero la recarga en vivo ahorraba tiempo de desarrollo. En la práctica, el argumento más fuerte de Quarkus para un equipo suele estar en el ciclo de trabajo diario.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Dev mode.&lt;/strong&gt; &lt;code&gt;quarkus dev&lt;/code&gt; (o &lt;code&gt;./mvnw quarkus:dev&lt;/code&gt;) recompila y recarga la aplicación al guardar un cambio, sin reiniciar el proceso manualmente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Testing continuo.&lt;/strong&gt; Con el dev mode activo, Quarkus detecta qué tests cubren el código modificado y ejecuta solo esos. Arranca en pausa por defecto y se controla con teclas: &lt;code&gt;r&lt;/code&gt; vuelve a correr todo, &lt;code&gt;f&lt;/code&gt; solo los fallidos, &lt;code&gt;b&lt;/code&gt; activa el modo de tests rotos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dev Services.&lt;/strong&gt; Si una extensión necesita un servicio —una base PostgreSQL, Kafka, Redis, Keycloak— y no hay una conexión configurada, Quarkus lo levanta automáticamente en un contenedor durante desarrollo y tests, y conecta la aplicación. Requiere Docker o Podman.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;application.properties: Dev Services en desarrollo y tests, conexión explícita solo en producción&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight properties"&gt;&lt;code&gt;&lt;span class="c1"&gt;# Desarrollo y tests: sin URL configurada, Dev Services inicia PostgreSQL en un contenedor
&lt;/span&gt;&lt;span class="na"&gt;quarkus.datasource.db-kind&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;postgresql&lt;/span&gt;

&lt;span class="c1"&gt;# Producción: la conexión se define únicamente en el perfil prod
&lt;/span&gt;&lt;span class="na"&gt;%prod.quarkus.datasource.jdbc.url&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;jdbc&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="n"&gt;postgresql&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="c1"&gt;//db:5432/app&lt;/span&gt;
&lt;span class="na"&gt;%prod.quarkus.datasource.username&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;$&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="no"&gt;DB_USER&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="na"&gt;%prod.quarkus.datasource.password&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;$&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="no"&gt;DB_PASSWORD&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El detalle importa: Dev Services se activa solo cuando no hay configuración explícita. Declarar la conexión de producción con el prefijo &lt;code&gt;%prod.&lt;/code&gt; permite que el entorno local siga siendo automático sin riesgo de que un desarrollador apunte por error a una base real. Para equipos de plataforma, es una forma concreta de reducir la fricción de incorporación: clonar el repositorio y ejecutar un comando alcanza para tener el servicio con sus dependencias funcionando.&lt;/p&gt;

&lt;h2&gt;
  
  
  Viniendo de Spring: compatibilidad útil, no equivalencia
&lt;/h2&gt;

&lt;p&gt;Quarkus ofrece extensiones de compatibilidad con Spring —inyección de dependencias, Web, Data JPA, Security, Scheduling, entre otras— que permiten usar anotaciones conocidas. La guía de Spring DI aclara el alcance: las clases de Spring se usan solo para leer metadatos; no se inicia un &lt;code&gt;ApplicationContext&lt;/code&gt; ni se ejecuta infraestructura de Spring, y agregar bibliotecas arbitrarias de Spring no tiene efecto. Por debajo, la inyección la resuelve ArC, la implementación de Jakarta CDI 4.1 de Quarkus, en tiempo de build.&lt;/p&gt;

&lt;p&gt;La propia documentación recomienda usar las anotaciones de CDI y publica una tabla de equivalencias. La migración de un componente típico es mecánica:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;El mismo componente con anotaciones de Spring y con CDI (equivalencias de la guía oficial)&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Spring&lt;/span&gt;
&lt;span class="nd"&gt;@Service&lt;/span&gt;
&lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;GreetingService&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nd"&gt;@Value&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"${greeting.suffix:!}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;suffix&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="c1"&gt;// Quarkus con CDI&lt;/span&gt;
&lt;span class="nd"&gt;@Singleton&lt;/span&gt;
&lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;GreetingService&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nd"&gt;@ConfigProperty&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"greeting.suffix"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;defaultValue&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"!"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;suffix&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;Limitaciones documentadas de la capa de compatibilidad con Spring DI&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Comportamiento de Spring&lt;/th&gt;
&lt;th&gt;En Quarkus&lt;/th&gt;
&lt;th&gt;Alternativa&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;@Conditional&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Se ignora: la inyección se resuelve en el build&lt;/td&gt;
&lt;td&gt;Perfiles de build condicionales&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;@Autowired(required = false)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;No soportado&lt;/td&gt;
&lt;td&gt;Inyectar &lt;code&gt;Instance&amp;lt;T&amp;gt;&lt;/code&gt; y verificar &lt;code&gt;isResolvable()&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Resolución por nombre ante beans ambiguos&lt;/td&gt;
&lt;td&gt;No soportada&lt;/td&gt;
&lt;td&gt;Usar &lt;code&gt;@Named&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Inyectar &lt;code&gt;Set&amp;lt;T&amp;gt;&lt;/code&gt; o &lt;code&gt;Map&amp;lt;String, T&amp;gt;&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;No soportado; solo &lt;code&gt;List&amp;lt;T&amp;gt;&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Usar &lt;code&gt;List&amp;lt;T&amp;gt;&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;@Import&lt;/code&gt;, &lt;code&gt;@ComponentScan&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;No aplica: el descubrimiento ocurre en el build&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Funcionalidades de test de Spring Boot&lt;/td&gt;
&lt;td&gt;No soportadas&lt;/td&gt;
&lt;td&gt;Guía de testing de Quarkus&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La conclusión práctica es que la compatibilidad reduce la curva de aprendizaje y permite migrar por partes, pero no convierte a Quarkus en un Spring más rápido. Los proyectos que dependen de configuración condicional en tiempo de ejecución, de auto-configuración de Spring Boot o de bibliotecas del ecosistema Spring requieren rediseño, no solo un cambio de dependencias.&lt;/p&gt;

&lt;h2&gt;
  
  
  Un mapa de las guías según la necesidad del equipo
&lt;/h2&gt;

&lt;p&gt;El índice de guías es extenso y está organizado por áreas. Para no recorrerlo de forma lineal, conviene entrar según el problema que el equipo necesita resolver:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Puntos de entrada en la documentación de Quarkus&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Necesidad&lt;/th&gt;
&lt;th&gt;Guías relevantes&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Primer contacto&lt;/td&gt;
&lt;td&gt;"Creating your first application" (una API REST con recarga en vivo, inyección y tests en menos de 15 minutos) y "Your second Quarkus application"&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;APIs y servicios web&lt;/td&gt;
&lt;td&gt;Quarkus REST, REST Client, OpenAPI, gRPC, GraphQL, WebSockets&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Datos&lt;/td&gt;
&lt;td&gt;Datasources, Hibernate ORM con Panache, Hibernate Reactive, Flyway y Liquibase, Redis y MongoDB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Mensajería y eventos&lt;/td&gt;
&lt;td&gt;Kafka, AMQP, RabbitMQ, Pulsar, JMS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Seguridad&lt;/td&gt;
&lt;td&gt;OpenID Connect, JWT, OAuth2, WebAuthn, Keycloak&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Modelo de ejecución&lt;/td&gt;
&lt;td&gt;Virtual threads, programación reactiva con Mutiny, propagación de contexto&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Operación&lt;/td&gt;
&lt;td&gt;Health checks, logging, Micrometer, OpenTelemetry, Fault Tolerance&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Despliegue&lt;/td&gt;
&lt;td&gt;Imágenes de contenedor, Kubernetes, OpenShift, funciones serverless en AWS Lambda, Azure y Google Cloud&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Gobernanza, versiones y la capa de IA
&lt;/h2&gt;

&lt;p&gt;Dos aspectos no técnicos influyen en una decisión de adopción. El primero es la gobernanza: el proyecto pasó a la Commonhaus Foundation, y el sitio lo presenta como una respuesta a la percepción de dependencia de un único proveedor; IBM, Red Hat y HeroDevs figuran como patrocinadores. El segundo es la política de versiones: Quarkus mantiene líneas LTS —3.40 y 3.33, entre otras— y publica versiones de emergencia cuando corresponde. La más reciente, 3.40.1.2, del 9 de noviembre de 2026, corrige un conjunto de CVE. Para un equipo, eso implica definir una política de actualización explícita, no solo elegir una versión.&lt;/p&gt;

&lt;p&gt;El proyecto también avanza sobre herramientas para agentes de IA. Las guías para escribir extensiones incluyen capítulos sobre Dev MCP, Agent MCP y Dev Assistant, y el blog oficial publicó en noviembre de 2026 contenidos sobre análisis de causa raíz con LLM conectado por MCP a un stack de observabilidad y sobre aislamiento de agentes. Es una señal de dirección interesante, aunque todavía en evolución, para equipos que combinan Java con &lt;a href="https://juliancardozo.github.io/blog/loop-engineering-agentic-loops/" rel="noopener noreferrer"&gt;ingeniería agéntica&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cómo evaluarlo en un equipo sin reescribir un sistema
&lt;/h2&gt;

&lt;p&gt;Adoptar un framework es una decisión de plataforma, con efectos durante años. Una evaluación razonable no empieza por migrar el servicio más crítico, sino por un piloto acotado con criterios definidos de antemano:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Elegir un servicio nuevo o periférico&lt;/strong&gt;, con dependencias representativas (una base de datos, un broker de mensajes, autenticación) pero sin impacto crítico.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Definir qué se quiere mejorar&lt;/strong&gt;: tiempo de arranque, memoria por instancia, costo de infraestructura o, con frecuencia, el ciclo de desarrollo. Cada objetivo lleva a decisiones distintas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Empezar en modo JVM&lt;/strong&gt; y medir con la carga real del servicio, no con un benchmark genérico. Evaluar la caché AOT antes que el ejecutable nativo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Medir la experiencia del equipo&lt;/strong&gt;: tiempo hasta el primer cambio en una persona nueva, duración del ciclo editar-probar, facilidad para levantar el entorno local con Dev Services.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Inventariar dependencias de Spring&lt;/strong&gt; que no tienen equivalente directo, en particular configuración condicional y bibliotecas del ecosistema.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Decidir con datos&lt;/strong&gt;: mantener, extender a otros servicios o descartar. Una plataforma con dos frameworks también tiene un costo, y conviene explicitarlo.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Quarkus no resuelve todos los problemas de un backend Java, y su propia documentación evita prometerlo. Lo que ofrece es una tesis clara —resolver en el build lo que no necesita resolverse en cada arranque— y un conjunto de herramientas que reducen la fricción del desarrollo diario. Para muchos equipos, ese segundo beneficio termina pesando más que el primero.&lt;/p&gt;

&lt;h3&gt;
  
  
  Referencias
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://quarkus.io/guides/" rel="noopener noreferrer"&gt;Quarkus: guías oficiales&lt;/a&gt; — índice de documentación, versión 3.40.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://quarkus.io/" rel="noopener noreferrer"&gt;Quarkus&lt;/a&gt; — sitio oficial del proyecto.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://quarkus.io/guides/building-native-image" rel="noopener noreferrer"&gt;Building a native executable&lt;/a&gt; — comparación de modos de ejecución y criterios de elección.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://quarkus.io/guides/dev-services" rel="noopener noreferrer"&gt;Dev Services overview&lt;/a&gt; — aprovisionamiento automático de servicios en desarrollo y tests.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://quarkus.io/guides/continuous-testing" rel="noopener noreferrer"&gt;Continuous testing&lt;/a&gt; — ejecución automática de tests afectados por un cambio.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://quarkus.io/guides/spring-di" rel="noopener noreferrer"&gt;Quarkus extension for Spring DI API&lt;/a&gt; — alcance y limitaciones de la compatibilidad con Spring.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://quarkus.io/blog/quarkus-3-40-1-2-released/" rel="noopener noreferrer"&gt;Quarkus 3.40.1.2 released&lt;/a&gt; — versión de emergencia de la línea LTS 3.40, 9 de noviembre de 2026.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;En síntesis: Quarkus mueve al build el trabajo que otros frameworks repiten en cada arranque. El ejecutable nativo es una opción para casos concretos, no un objetivo; el beneficio más amplio suele estar en el ciclo de desarrollo. Para equipos que vienen de Spring, la compatibilidad facilita la transición, pero la adopción conviene evaluarla con un piloto y criterios medibles.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>java</category>
      <category>architecture</category>
      <category>cloud</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Uber H3: buscando soluciones óptimas en ingeniería y arquitectura. Caso práctico</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:16:20 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/uber-h3-buscando-soluciones-optimas-en-ingenieria-y-arquitectura-caso-practico-4g8d</link>
      <guid>https://dev.to/julian_cardozo_dev/uber-h3-buscando-soluciones-optimas-en-ingenieria-y-arquitectura-caso-practico-4g8d</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/uber-h3-soluciones-optimas-ingenieria-arquitectura/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Cada viaje solicitado, cada inicio de recorrido y cada pedido de comida deja en el marketplace de Uber un evento con latitud y longitud. Según el artículo con el que la empresa presentó H3 en 2018, esos eventos se cuentan por millones cada día. Ante un volumen así, la reacción habitual de un equipo de ingeniería es buscar la solución óptima en términos de velocidad: qué base de datos escala mejor, cuántos nodos agregar, cómo acelerar una consulta. El caso H3 muestra que la búsqueda de una solución óptima empieza antes, al decidir en qué unidad se piensa el problema, y que lo óptimo solo existe respecto de criterios explícitos. Este artículo es un análisis independiente basado en fuentes públicas; no se apoya en información interna de Uber y señala como inferencia todo razonamiento que las fuentes no documentan.&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué significa óptimo en arquitectura
&lt;/h2&gt;

&lt;p&gt;En matemática, una solución óptima es la mejor según una función objetivo y dentro de un conjunto de restricciones. En arquitectura de software rara vez hay una sola función objetivo: rendimiento, costo, simplicidad, precisión, facilidad de operación y capacidad de cambio tiran en direcciones distintas. Por eso una solución óptima no es la más rápida ni la más elegante, sino la que mejor satisface los criterios que importan para una decisión concreta, con costos conocidos y aceptados.&lt;/p&gt;

&lt;p&gt;Esa definición tiene una consecuencia práctica. Optimizar sin criterios escritos suele llevar a mejorar lo que es fácil de medir, normalmente la velocidad, aunque el problema esté en otro lado. Buscar una solución óptima exige, en orden, formular la decisión que se quiere habilitar, explicitar los criterios, comparar alternativas contra ellos y registrar lo que se sacrifica. El caso H3 permite recorrer esos pasos con fuentes públicas.&lt;/p&gt;

&lt;h2&gt;
  
  
  El límite de las opciones convencionales
&lt;/h2&gt;

&lt;p&gt;El artículo de Isaac Brodsky, ingeniero de Uber, parte de una observación sencilla: analizar cada evento en su ubicación exacta es difícil y costoso, mientras que analizarlo por áreas, como barrios, resulta mucho más práctico. Con eso el problema cambia de forma. La pregunta deja de ser cómo procesar puntos y pasa a ser qué áreas usar.&lt;/p&gt;

&lt;p&gt;Las alternativas que el texto menciona tienen costos concretos. Las zonas dibujadas a mano por equipos de operaciones capturan conocimiento local, pero requieren actualizaciones frecuentes a medida que la ciudad cambia y tienen bordes arbitrarios. Los códigos postales presentan formas y tamaños poco útiles para el análisis y cambian por motivos ajenos a él. La combinación de la proyección de Mercator con una grilla cuadrada funciona, pero Mercator distorsiona significativamente los tamaños: celdas nominalmente iguales terminan cubriendo áreas muy distintas.&lt;/p&gt;

&lt;p&gt;Los cuadrados tienen además un problema menos visible. Tienen dos tipos de vecinos, los que comparten un lado y los que comparten solo un vértice, y según Uber eso obliga a manejar varios conjuntos de coeficientes en el análisis.&lt;/p&gt;

&lt;p&gt;Ninguna de estas dificultades es de rendimiento. Son problemas de representación: la unidad de análisis introduce sesgo, inestabilidad o complejidad antes de que se escriba la primera consulta. Una optimización de consultas sobre cualquiera de esas unidades habría producido una solución más rápida, pero no mejor.&lt;/p&gt;

&lt;h2&gt;
  
  
  La decisión de representación
&lt;/h2&gt;

&lt;p&gt;La idea central de H3 es convertir cada coordenada en el identificador de una celda. Un evento deja de ser un par de números decimales y pasa a ser «la celda X en la resolución 9». Ese identificador es un entero de 64 bits. Lo que antes era un problema geométrico, qué puntos están cerca de cuáles, se convierte en aritmética sobre identificadores: agrupar por celda, obtener las celdas vecinas, pasar a una resolución más gruesa.&lt;/p&gt;

&lt;p&gt;Un ejemplo ayuda a fijar la idea. En un barrio a la hora de mayor demanda hay pedidos de viaje y conductores disponibles. Con H3, cada punto cae en un hexágono, y contar pedidos y conductores por hexágono produce un mapa de oferta y demanda por zona. Uber documenta este uso de forma explícita: el precio dinámico se calcula midiendo oferta y demanda en hexágonos.&lt;/p&gt;

&lt;p&gt;Conviene hacer una distinción. Ese cálculo es análisis del mercado. Decidir qué conductor toma qué viaje es asignación (matching o dispatch), y el artículo no describe ese algoritmo. Menciona que H3 se usa para optimizar precios y despacho, y que los eventos pueden revelar, por ejemplo, dos pedidos cercanos a un conductor de uberPOOL. Pero H3 es la capa de indexación sobre la que se construyen esos análisis, no el sistema que asigna viajes.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Patrón básico de agregación por celdas (pseudocódigo ilustrativo, no un diseño de producción)&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;PARA cada evento e en el lote:
    celda ← coordenada_a_celda(e.lat, e.lng, resolución = r)
    conteo[celda][e.tipo] += 1

PARA cada celda c con datos:
    zona ← vecinas_hasta_distancia(c, k = 1)   # c y sus vecinas
    demanda ← SUMA conteo[z]["pedido"]    para z en zona
    oferta  ← SUMA conteo[z]["conductor"] para z en zona
    indicador[c] ← demanda / max(oferta, 1)

SI hace falta una vista más gruesa:
    padre ← celda_padre(c, r - 1)   # contención lógica, no geométrica exacta
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;En la API actual de la librería (versión 4), esas operaciones corresponden a &lt;code&gt;latLngToCell&lt;/code&gt;, &lt;code&gt;gridDisk&lt;/code&gt; y &lt;code&gt;cellToParent&lt;/code&gt;. El artículo de 2018 usa los nombres de la versión 3, como &lt;code&gt;geoToH3&lt;/code&gt; y &lt;code&gt;kRing&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Hexágonos, icosaedro y jerarquía
&lt;/h2&gt;

&lt;p&gt;El argumento a favor del hexágono es geométrico. Un hexágono tiene una sola distancia entre su centro y el de cada vecino; un cuadrado tiene dos y un triángulo, tres. Uber explica que esto simplifica el análisis y el suavizado de gradientes, y que minimiza el error de cuantización cuando las personas se desplazan por la ciudad. Los anillos de vecinos, además, aproximan círculos.&lt;/p&gt;

&lt;p&gt;Para llevar la grilla a la esfera, H3 usa proyecciones gnomónicas centradas en las 20 caras de un icosaedro. Una esfera no puede cubrirse solo con hexágonos, de modo que cada resolución tiene exactamente 12 pentágonos, uno en cada vértice del icosaedro. La orientación elegida, basada en el mapa Dymaxion de Buckminster Fuller, ubica todos esos vértices en el agua, lejos de donde Uber opera.&lt;/p&gt;

&lt;p&gt;La jerarquía comienza en 122 celdas base (110 hexágonos y 12 pentágonos) y ofrece 16 resoluciones, de 0 a 15. En cada nivel más fino, las celdas tienen aproximadamente un séptimo del área de las del nivel anterior. La documentación llama a esta subdivisión apertura 7.&lt;/p&gt;

&lt;h3&gt;
  
  
  Los costos del diseño
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Las celdas no son uniformes.&lt;/strong&gt; El área de una celda varía según su posición respecto de los vértices del icosaedro.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Los hijos no quedan perfectamente contenidos en el padre.&lt;/strong&gt; Un hexágono no se subdivide limpiamente en siete hexágonos; H3 aproxima esa subdivisión rotando la grilla entre niveles. La contención lógica en el índice es exacta, pero la geográfica es aproximada: un punto dentro de una celda hija puede quedar fuera del polígono de la celda padre.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Los pentágonos tienen cinco vecinos.&lt;/strong&gt; El código que asume seis puede fallar en esos casos.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;La aproximación solo afecta cuando se cambia de resolución. Indexar puntos en una resolución fija y buscar vecinos no se ve afectado. Cuando se necesitan bordes exactos, la documentación del proyecto sugiere usar la grilla como optimización, combinada con un chequeo preciso de punto en polígono.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Sistemas de indexación espacial comparados: ninguno es óptimo en todos los criterios&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Criterio&lt;/th&gt;
&lt;th&gt;Grilla cuadrada&lt;/th&gt;
&lt;th&gt;Geohash&lt;/th&gt;
&lt;th&gt;S2 (Google)&lt;/th&gt;
&lt;th&gt;H3&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Forma de celda&lt;/td&gt;
&lt;td&gt;Rectángulo&lt;/td&gt;
&lt;td&gt;Rectángulo (curva Z)&lt;/td&gt;
&lt;td&gt;Cuadrilátero sobre un cubo proyectado (curva de Hilbert)&lt;/td&gt;
&lt;td&gt;Hexágono, más 12 pentágonos por resolución&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Vecinos&lt;/td&gt;
&lt;td&gt;Dos tipos (lado y vértice)&lt;/td&gt;
&lt;td&gt;Dos tipos; un prefijo común no garantiza cercanía&lt;/td&gt;
&lt;td&gt;Dos tipos&lt;/td&gt;
&lt;td&gt;Un tipo, equidistante&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Jerarquía&lt;/td&gt;
&lt;td&gt;Depende de la implementación&lt;/td&gt;
&lt;td&gt;Por prefijo de la cadena&lt;/td&gt;
&lt;td&gt;31 niveles (0 a 30), subdivisión exacta en cuatro&lt;/td&gt;
&lt;td&gt;16 resoluciones, contención geográfica aproximada&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Distorsión&lt;/td&gt;
&lt;td&gt;Alta lejos del ecuador&lt;/td&gt;
&lt;td&gt;Alta en polos y en el meridiano 180&lt;/td&gt;
&lt;td&gt;Moderada&lt;/td&gt;
&lt;td&gt;Moderada; varía cerca de los vértices&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Encaja mejor en&lt;/td&gt;
&lt;td&gt;Análisis local simple&lt;/td&gt;
&lt;td&gt;Claves legibles, búsquedas por prefijo&lt;/td&gt;
&lt;td&gt;Agregación y subdivisión exactas, cobertura de regiones&lt;/td&gt;
&lt;td&gt;Vecindad, recorrido de grilla, movimiento, suavizado&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Fuentes de la comparación: la &lt;a href="https://s2geometry.io/devguide/s2cell_hierarchy" rel="noopener noreferrer"&gt;jerarquía de celdas de S2&lt;/a&gt;, la &lt;a href="https://en.wikipedia.org/wiki/Geohash" rel="noopener noreferrer"&gt;entrada de Geohash&lt;/a&gt;, las &lt;a href="https://h3geo.org/docs/" rel="noopener noreferrer"&gt;comparaciones del propio proyecto H3&lt;/a&gt; y un &lt;a href="https://foursquare.com/resources/reports-and-insights/ebook/all-about-h3-your-questions-answered/" rel="noopener noreferrer"&gt;resumen de Foursquare&lt;/a&gt;, que concluye que S2 rinde mejor cuando se necesitan agregación y subdivisión exactas, y H3 cuando importan los vecinos. Foursquare usa H3 comercialmente y la comparación de H3 la escribe el propio proyecto, por lo que ambas pueden tener sesgo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cómo se llegó a la solución: criterios, opciones y decisión
&lt;/h2&gt;

&lt;p&gt;Con lo publicado puede reconstruirse la estructura de una búsqueda de solución óptima, no una historia: una necesidad, criterios, opciones, un diseño y sus propiedades.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Necesidad.&lt;/strong&gt; Analizar millones de eventos a escala de ciudad, con granularidad fina, para fijar precios dinámicos y tomar otras decisiones del marketplace.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Criterios.&lt;/strong&gt; Las críticas del artículo los dejan ver: formas y tamaños comparables entre ciudades, unidades que no cambien por motivos arbitrarios, vecindad simple y capacidad de cambiar de nivel de detalle. Que estos fueran los criterios formales del equipo es una inferencia.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Opciones.&lt;/strong&gt; Zonas manuales, códigos postales y proyección con grilla cuadrada, cada una con los costos descritos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Diseño.&lt;/strong&gt; Una grilla global hexagonal con indexación jerárquica, sobre un icosaedro orientado para dejar los pentágonos en el océano.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Propiedades.&lt;/strong&gt; Identificadores de 64 bits, anillos de vecinos y compactación. El ejemplo del artículo: California ocupa 10.633 hexágonos en la resolución 6 y 901 en su representación compacta con resoluciones mixtas. Uber liberó H3 como código abierto en 2018, bajo licencia Apache 2.0.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Lo que las fuentes no permiten afirmar
&lt;/h3&gt;

&lt;p&gt;Las fuentes no indican quién propuso la idea, cuánto tiempo llevó ni qué prototipos se descartaron. Tampoco documentan una evaluación formal de S2 o de geohash. El README del repositorio describe H3 como una combinación de los beneficios de una grilla hexagonal con las subdivisiones jerárquicas de S2, lo que muestra que el equipo conocía S2, no que exista una evaluación publicada. No hay en estas fuentes cifras de mejora en latencia, ingresos o precisión, ni una descripción de cómo H3 se integra con el sistema de despacho.&lt;/p&gt;

&lt;h2&gt;
  
  
  Otros casos con el mismo patrón
&lt;/h2&gt;

&lt;p&gt;Algunos sistemas conocidos comparten un rasgo con H3: cuestionaron un supuesto en lugar de acelerar la solución vigente. No son equivalentes; cada uno resolvió un problema distinto.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Amazon Dynamo (2007).&lt;/strong&gt; Servicios como el carrito de compras debían poder leer y escribir siempre, aun con fallas de discos, redes o centros de datos. El &lt;a href="https://www.amazon.science/publications/dynamo-amazons-highly-available-key-value-store" rel="noopener noreferrer"&gt;paper&lt;/a&gt; observa que muchos servicios solo accedían por clave primaria y que la replicación de las bases relacionales tendía a elegir consistencia sobre disponibilidad. La respuesta fue un almacén clave-valor que particiona y replica con consistent hashing, versiona objetos y coordina réplicas con una técnica tipo quorum, a cambio de sacrificar consistencia en ciertos escenarios de falla.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Google MapReduce (2004).&lt;/strong&gt; Cientos de cómputos sobre grandes volúmenes en los que paralelizar, distribuir datos y manejar fallas &lt;a href="https://research.google/pubs/pub62/" rel="noopener noreferrer"&gt;oscurecía una lógica simple&lt;/a&gt;. En lugar de que cada equipo escribiera su propio código distribuido, una abstracción de dos funciones, map y reduce, delegó el resto a un runtime común. El costo, como inferencia, es expresividad: no todo cómputo encaja cómodamente en ese modelo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;LinkedIn y el log (2013).&lt;/strong&gt; Jay Kreps propuso dejar de tratar la integración de datos como una red de conexiones punto a punto y adoptar un &lt;a href="https://engineering.linkedin.com/distributed-systems/log-what-every-software-engineer-should-know-about-real-time-datas-unifying" rel="noopener noreferrer"&gt;log central&lt;/a&gt;, ordenado y de solo escritura al final, al que cada sistema escribe y del que cada sistema se suscribe. Es un ensayo de autor, no un paper con evaluación, y debe leerse como testimonio.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Una distinción necesaria:&lt;/strong&gt; Consistent hashing y H3 no son la misma idea. El primero reparte claves entre nodos de modo que agregar o quitar un nodo mueva pocas claves, sin preservar ninguna noción de cercanía. H3 asigna puntos del espacio a celdas precisamente para preservar la vecindad.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Un método para buscar la solución óptima
&lt;/h2&gt;

&lt;p&gt;Aplicar la lección no requiere inventar una grilla global. El marco que sigue es una propuesta propia en seis etapas para buscar una solución óptima de forma explícita, inspirada en el caso pero no derivada de un proceso documentado por Uber.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Formular el problema sin nombrar una herramienta.&lt;/strong&gt; Qué decisión tiene que poder tomar alguien al final y qué ocurre hoy cuando no la toma. Una técnica útil es escribir el problema en una sola frase, sin nombres de productos, bases de datos ni frameworks.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Identificar invariantes y restricciones.&lt;/strong&gt; Qué tiene que seguir siendo cierto aunque cambie todo lo demás, y qué restricción es física y cuál es heredada. Una tabla con dos columnas, «no negociable» y «asumido», permite discutir cada fila de la segunda.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cuestionar la representación y la unidad de análisis.&lt;/strong&gt; Punto, zona, ticket, servicio o equipo: cada unidad introduce un sesgo. Ver el mismo dato en tres granularidades muestra qué decisiones cambian.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Explorar otros dominios.&lt;/strong&gt; Quién resolvió un problema con la misma forma en otro campo y qué estándar existente ya lo cubre. H3 se apoya en cartografía, geometría y la proyección de Fuller.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Prototipar alternativas y medir.&lt;/strong&gt; Dos o tres prototipos descartables sobre el mismo conjunto de datos, evaluados contra los criterios definidos al principio y con el criterio de abandono escrito antes de ejecutarlos. Es la etapa en la que «óptimo» deja de ser una opinión.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Registrar los trade-offs, introducir el cambio y revisar.&lt;/strong&gt; Un &lt;a href="https://www.cognitect.com/blog/2011/11/15/documenting-architecture-decisions" rel="noopener noreferrer"&gt;ADR&lt;/a&gt; con contexto, decisión y consecuencias, y una fecha de revisión.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;em&gt;La búsqueda de la solución óptima como ciclo: un prototipo que no supera el criterio vuelve a la representación: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/uber-h3-soluciones-optimas-ingenieria-arquitectura/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;El ciclo importa más que la secuencia. Un prototipo que falla vuelve a la representación, no al principio. Descartar una idea, o elegir un estándar existente, también es un resultado válido: a menudo la solución óptima es la que ya existe.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;El caso H3 leído como una serie de reencuadres (las tres primeras filas provienen del artículo de Uber; la última es un ejemplo propio)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Supuesto tradicional&lt;/th&gt;
&lt;th&gt;Reencuadre&lt;/th&gt;
&lt;th&gt;Alternativa&lt;/th&gt;
&lt;th&gt;Costo aceptado&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Hay que analizar cada punto&lt;/td&gt;
&lt;td&gt;La decisión se toma por zona&lt;/td&gt;
&lt;td&gt;Agregar en celdas&lt;/td&gt;
&lt;td&gt;Se pierde precisión individual&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Las zonas las define el negocio&lt;/td&gt;
&lt;td&gt;Las zonas pueden ser una grilla estable&lt;/td&gt;
&lt;td&gt;Grilla global&lt;/td&gt;
&lt;td&gt;No coincide con calles ni barrios&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;La grilla natural es cuadrada&lt;/td&gt;
&lt;td&gt;La vecindad importa más que la subdivisión&lt;/td&gt;
&lt;td&gt;Hexágonos&lt;/td&gt;
&lt;td&gt;Contención jerárquica aproximada y 12 pentágonos&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;El equipo de plataforma resuelve tickets&lt;/td&gt;
&lt;td&gt;El cuello de botella es la espera, no la ejecución&lt;/td&gt;
&lt;td&gt;Autoservicio&lt;/td&gt;
&lt;td&gt;Construir y mantener un producto interno&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Caso práctico en Platform Engineering
&lt;/h2&gt;

&lt;p&gt;Un ejemplo hipotético muestra cómo se traslada la pregunta. Un equipo de plataforma recibe tickets para crear bases de datos, colas y pipelines. La cola crece y la primera reacción es acelerar: más personas, mejores plantillas de ticket, acuerdos de servicio más cortos.&lt;/p&gt;

&lt;p&gt;Con el método, la unidad de análisis cambia. El ticket no es el problema; el problema es que un equipo de producto espera a otro para una tarea repetible. Ese reencuadre conduce a golden paths: caminos estandarizados y autoservicio para los casos más comunes, con el equipo de plataforma como responsable de un producto interno.&lt;/p&gt;

&lt;p&gt;El costo es real: ese producto hay que construirlo, documentarlo y mantenerlo, y los casos poco frecuentes siguen requiriendo atención humana. Para saber si el cambio funcionó, conviene medir antes y después el tiempo de entrega de cambios y la frecuencia de despliegue (métricas de &lt;a href="https://dora.dev/" rel="noopener noreferrer"&gt;DORA&lt;/a&gt;), el tiempo de incorporación hasta el primer despliegue, la proporción de servicios nuevos creados por el camino estándar, la satisfacción de los desarrolladores mediante una encuesta breve y recurrente, la tasa de fallas de cambio y el costo de infraestructura por servicio. Ninguna cifra de este ejemplo corresponde a una empresa real.&lt;/p&gt;

&lt;h2&gt;
  
  
  Preguntas para una revisión de arquitectura
&lt;/h2&gt;

&lt;p&gt;El método puede condensarse en cinco preguntas para la próxima revisión de diseño, o para un taller breve con el equipo.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Qué problema se estaría resolviendo si esta tecnología no existiera.&lt;/li&gt;
&lt;li&gt;En qué unidad se está midiendo, y qué decisión empeora por esa elección.&lt;/li&gt;
&lt;li&gt;Qué estándar o librería existente se descartó, y por qué.&lt;/li&gt;
&lt;li&gt;Qué resultado de un prototipo llevaría a abandonar la propuesta.&lt;/li&gt;
&lt;li&gt;Quién paga el trade-off aceptado, y cuándo se va a revisar.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Un ejercicio práctico consiste en pedir a cada integrante que escriba el problema actual del equipo en una oración, sin nombres de tecnología, y comparar las respuestas. Es habitual que aparezcan dos o tres formulaciones distintas que habilitan decisiones diferentes, y esa diferencia suele ser el punto de partida de la discusión.&lt;/p&gt;

&lt;h2&gt;
  
  
  Referencias
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Brodsky, I. (2018). &lt;a href="https://www.uber.com/us/en/blog/h3/" rel="noopener noreferrer"&gt;H3: Uber’s Hexagonal Hierarchical Spatial Index&lt;/a&gt;. Uber Engineering.&lt;/li&gt;
&lt;li&gt;Proyecto H3: &lt;a href="https://h3geo.org/docs/core-library/overview/" rel="noopener noreferrer"&gt;Overview&lt;/a&gt;, &lt;a href="https://h3geo.org/docs/highlights/indexing/" rel="noopener noreferrer"&gt;Indexing&lt;/a&gt;, &lt;a href="https://h3geo.org/docs/" rel="noopener noreferrer"&gt;Introducción y comparaciones&lt;/a&gt;, &lt;a href="https://h3geo.org/docs/core-library/restable/" rel="noopener noreferrer"&gt;Tablas por resolución&lt;/a&gt; y &lt;a href="https://h3geo.org/docs/api/indexing/" rel="noopener noreferrer"&gt;API de indexación&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Uber. &lt;a href="https://github.com/uber/h3" rel="noopener noreferrer"&gt;uber/h3&lt;/a&gt;, repositorio en GitHub (Apache 2.0; última versión publicada: 4.5.0).&lt;/li&gt;
&lt;li&gt;DeCandia, G. et al. (2007). &lt;a href="https://www.amazon.science/publications/dynamo-amazons-highly-available-key-value-store" rel="noopener noreferrer"&gt;Dynamo: Amazon’s Highly Available Key-value Store&lt;/a&gt;. SOSP.&lt;/li&gt;
&lt;li&gt;Dean, J. y Ghemawat, S. (2004). &lt;a href="https://research.google/pubs/pub62/" rel="noopener noreferrer"&gt;MapReduce: Simplified Data Processing on Large Clusters&lt;/a&gt;. OSDI.&lt;/li&gt;
&lt;li&gt;Kreps, J. (2013). &lt;a href="https://engineering.linkedin.com/distributed-systems/log-what-every-software-engineer-should-know-about-real-time-datas-unifying" rel="noopener noreferrer"&gt;The Log: What every software engineer should know about real-time data’s unifying abstraction&lt;/a&gt;. LinkedIn Engineering.&lt;/li&gt;
&lt;li&gt;Proyecto S2. &lt;a href="https://s2geometry.io/devguide/s2cell_hierarchy" rel="noopener noreferrer"&gt;S2 Cell Hierarchy&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Rabinowitz, N. (2021). &lt;a href="https://foursquare.com/resources/reports-and-insights/ebook/all-about-h3-your-questions-answered/" rel="noopener noreferrer"&gt;All about H3: your questions answered&lt;/a&gt;. Foursquare.&lt;/li&gt;
&lt;li&gt;Nygard, M. (2011). &lt;a href="https://www.cognitect.com/blog/2011/11/15/documenting-architecture-decisions" rel="noopener noreferrer"&gt;Documenting Architecture Decisions&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;DORA. &lt;a href="https://dora.dev/" rel="noopener noreferrer"&gt;dora.dev&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;En síntesis: una solución óptima en arquitectura es la que mejor satisface criterios explícitos, con costos conocidos y aceptados. H3 lo muestra: no resolvió un problema de velocidad sino de representación, y su grilla estable, comparable y con vecindad uniforme tiene costos declarados, como celdas no uniformes, pentágonos y una jerarquía exacta en lo lógico pero no en lo geométrico. La lección transferible no es adoptar hexágonos, sino definir qué significa óptimo y revisar la representación del problema antes de optimizar la solución.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>architecture</category>
      <category>data</category>
      <category>devops</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Siete agentes, un objetivo: cómo se orquesta un sistema multiagente que construye un sitio web</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:11:14 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/siete-agentes-un-objetivo-como-se-orquesta-un-sistema-multiagente-que-construye-un-sitio-web-1d58</link>
      <guid>https://dev.to/julian_cardozo_dev/siete-agentes-un-objetivo-como-se-orquesta-un-sistema-multiagente-que-construye-un-sitio-web-1d58</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/orquestacion-multiagente-website-factory/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Un modelo de lenguaje, por sí solo, es una función estocástica: recibe contexto y devuelve una muestra. Un agente es esa función dentro de un loop con herramientas, memoria y un criterio de parada. Y un sistema multiagente es otra cosa: una arquitectura distribuida donde varias de esas inferencias se reparten el trabajo, comparten estado y se controlan entre sí. Website Factory es un ejemplo completo y público: un orquestador de Claude Code descompone un objetivo, lo delega en seis subagentes especializados sobre el flujo Spec-Driven Development de GitHub Spec Kit y solo da una etapa por cerrada cuando un verificador determinista lo confirma. Entrada: un brief en Markdown. Salida: un sitio Astro + Tailwind CSS 4 que compila, pasa sus controles y deja la traza de cada decisión. Este artículo abre el sistema por dentro.&lt;/p&gt;

&lt;h2&gt;
  
  
  De la inferencia al sistema
&lt;/h2&gt;

&lt;p&gt;Para entender por qué hace falta orquestar, conviene separar tres niveles que en la conversación cotidiana se mezclan:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Tres niveles de abstracción en IA generativa aplicada&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Nivel&lt;/th&gt;
&lt;th&gt;Qué es&lt;/th&gt;
&lt;th&gt;Unidad de diseño&lt;/th&gt;
&lt;th&gt;Modo de falla típico&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Modelo&lt;/td&gt;
&lt;td&gt;Una inferencia: contexto → distribución → muestra&lt;/td&gt;
&lt;td&gt;El prompt&lt;/td&gt;
&lt;td&gt;Alucinación: una salida plausible y sin grounding&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Agente&lt;/td&gt;
&lt;td&gt;Un loop de razonamiento y acción con tool use (patrón ReAct)&lt;/td&gt;
&lt;td&gt;Herramientas, contexto y condición de parada&lt;/td&gt;
&lt;td&gt;Deriva: el loop no converge o converge a algo incorrecto&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sistema multiagente&lt;/td&gt;
&lt;td&gt;Varios agentes con roles, estado compartido y control&lt;/td&gt;
&lt;td&gt;Topología, contratos, verificadores y límites&lt;/td&gt;
&lt;td&gt;Errores en cascada: la salida mala de uno es la entrada de otro&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Con un agente generalista las tres fallas se acumulan en un único contexto: el mismo loop decide posicionamiento, copy, SEO, accesibilidad y código, y además evalúa su propio trabajo. La ventana de contexto se llena de información irrelevante para cada subtarea, la atención del modelo se diluye y no hay ningún punto independiente que detecte el error antes de que se propague. La respuesta de ingeniería es la misma que en cualquier sistema distribuido: &lt;strong&gt;descomponer, aislar, contratar interfaces y verificar en los bordes&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;En Website Factory el repositorio pasa a ser &lt;strong&gt;el programa que ejecutan los agentes&lt;/strong&gt;: las reglas (&lt;code&gt;CLAUDE.md&lt;/code&gt;), los roles (&lt;code&gt;.claude/agents/*.md&lt;/code&gt;), los flujos (&lt;code&gt;.claude/skills/*/SKILL.md&lt;/code&gt;), las especificaciones (&lt;code&gt;specs/&lt;/code&gt;) y los verificadores (&lt;code&gt;scripts/&lt;/code&gt;) son el código fuente del sistema, y el modelo es el runtime. Los prompts que recibe cada agente no se escriben a mano: los genera el orquestador a partir de ese programa.&lt;/p&gt;

&lt;h2&gt;
  
  
  El problema y las restricciones de diseño
&lt;/h2&gt;

&lt;p&gt;El objetivo es una &lt;strong&gt;fábrica reproducible&lt;/strong&gt;: dado cualquier brief con el mismo formato, producir un sitio que compile, pase controles automáticos y deje evidencia de cada decisión. El caso de demostración del repositorio es &lt;em&gt;Supermercado Los Álamos&lt;/em&gt;, un comercio ficticio. Antes de escribir una línea se fijaron cinco restricciones, que funcionan como la función objetivo del sistema:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Grounding estricto: el brief es la fuente de verdad.&lt;/strong&gt; Cada dato comercial se etiqueta como &lt;code&gt;VERIFIED&lt;/code&gt;, &lt;code&gt;ASSUMPTION&lt;/code&gt;, &lt;code&gt;PLACEHOLDER&lt;/code&gt; o &lt;code&gt;BLOCKED&lt;/code&gt;. Lo no confirmado no se publica como si fuera real: es la defensa estructural contra la alucinación.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Especialización con mínimo privilegio&lt;/strong&gt;: cada rol con sus herramientas y sus archivos de salida, y nada más.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Trazabilidad de punta a punta&lt;/strong&gt;: IDs que conecten brief → requisitos → spec → copy → tareas → código → QA.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verificación determinista&lt;/strong&gt;: &lt;code&gt;astro check&lt;/code&gt;, &lt;code&gt;astro build&lt;/code&gt; y un validador de contenido tienen que pasar; no alcanza con que el agente diga que pasaron.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Personas en los puntos de riesgo&lt;/strong&gt;: nada de despliegues, dependencias nuevas ni servicios externos sin aprobación explícita.&lt;/li&gt;
&lt;/ol&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Alcance:&lt;/strong&gt; MVP de hasta cinco páginas, sin CMS, pagos, autenticación ni formularios con backend. Stack fijo: Astro con TypeScript y salida estática, Tailwind CSS 4 vía &lt;a class="mentioned-user" href="https://dev.to/tailwindcss"&gt;@tailwindcss&lt;/a&gt;/vite, JavaScript de cliente solo cuando una funcionalidad lo justifique.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Topología: un orquestador, seis especialistas
&lt;/h2&gt;

&lt;p&gt;La primera decisión de arquitectura fue la topología. El sistema usa &lt;strong&gt;orquestador + especialistas&lt;/strong&gt; (hub-and-spoke), que en la taxonomía de Anthropic sobre sistemas agénticos corresponde al patrón &lt;em&gt;orchestrator-workers&lt;/em&gt;. Hay una sola sesión principal de Claude Code que decide prioridades, permisos, reintentos y resultado final. Los subagentes no se hablan entre sí, y no pueden crear otros agentes ni modificar las reglas superiores.&lt;/p&gt;

&lt;p&gt;La coordinación no ocurre por mensajes sino &lt;strong&gt;a través de archivos&lt;/strong&gt;, al estilo de una arquitectura &lt;em&gt;blackboard&lt;/em&gt;: cada agente lee los artefactos que produjeron los anteriores y escribe solo los suyos. Esto tiene tres ventajas sobre un chat entre agentes: el estado es inspeccionable y versionable con git, el contexto de cada agente queda acotado a lo que necesita, y el orquestador puede auditar cualquier paso intermedio.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Topología orquestador-especialistas con coordinación por archivos: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/orquestacion-multiagente-website-factory/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  Los seis especialistas y su superficie de herramientas
&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;Roles, herramientas y propiedad de archivos (definidos en .claude/agents/)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Agente&lt;/th&gt;
&lt;th&gt;Responsabilidad&lt;/th&gt;
&lt;th&gt;Herramientas&lt;/th&gt;
&lt;th&gt;Es dueño de&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;business-analyst&lt;/td&gt;
&lt;td&gt;Brief → REQ-001..n con Given/When/Then, supuestos y bloqueos; clasifica cada dato&lt;/td&gt;
&lt;td&gt;Read, Grep, Glob, Write&lt;/td&gt;
&lt;td&gt;requirements.md, content-inventory.md&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;brand-strategist&lt;/td&gt;
&lt;td&gt;Posicionamiento, tono, mensajes por sección, dirección visual&lt;/td&gt;
&lt;td&gt;Read, Grep, Glob, Write&lt;/td&gt;
&lt;td&gt;brand-strategy.md&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;content-seo-specialist&lt;/td&gt;
&lt;td&gt;Copy con IDs estables (HOME-S1-SUB…), SEO local, JSON-LD estricto&lt;/td&gt;
&lt;td&gt;Read, Grep, Glob, Write&lt;/td&gt;
&lt;td&gt;copy-deck.md, seo-plan.md&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ux-ui-designer&lt;/td&gt;
&lt;td&gt;Tokens &lt;a class="mentioned-user" href="https://dev.to/theme"&gt;@theme&lt;/a&gt;, componentes con props, responsive 360/768/1440, foco&lt;/td&gt;
&lt;td&gt;Read, Grep, Glob, Write&lt;/td&gt;
&lt;td&gt;design-system.md, site-map.md&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;frontend-engineer&lt;/td&gt;
&lt;td&gt;Implementa tasks.md en Astro + TS + Tailwind 4&lt;/td&gt;
&lt;td&gt;Read, Grep, Glob, Write, Edit, &lt;strong&gt;Bash&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;src/, public/, astro.config.mjs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;qa-reviewer&lt;/td&gt;
&lt;td&gt;Auditoría independiente brief ↔ spec ↔ diseño ↔ código&lt;/td&gt;
&lt;td&gt;Read, Grep, Glob, &lt;strong&gt;Bash&lt;/strong&gt;, Write&lt;/td&gt;
&lt;td&gt;qa-report.md&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Dos principios de coordinación sostienen la tabla. &lt;strong&gt;Propiedad exclusiva de archivos&lt;/strong&gt;: como &lt;code&gt;brand-strategist&lt;/code&gt; y &lt;code&gt;content-seo-specialist&lt;/code&gt; escriben archivos distintos, pueden correr en paralelo (&lt;em&gt;fan-out&lt;/em&gt;) sin condiciones de carrera; las ediciones de un mismo archivo se serializan. &lt;strong&gt;Mínimo privilegio&lt;/strong&gt;: los cuatro roles de análisis y diseño no tienen &lt;code&gt;Bash&lt;/code&gt;, así que no pueden instalar paquetes, borrar archivos ni ejecutar nada. Solo compila quien implementa y solo verifica quien audita.&lt;/p&gt;

&lt;h2&gt;
  
  
  Programar el sistema para que los agentes ejecuten los prompts
&lt;/h2&gt;

&lt;p&gt;La tendencia más interesante de la ingeniería agéntica es esta: dejamos de escribir prompts y empezamos a &lt;strong&gt;programar sistemas que generan y ejecutan prompts&lt;/strong&gt;. En Website Factory hay tres capas, cada una con un nivel de abstracción distinto:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Las capas del programa agéntico&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Capa&lt;/th&gt;
&lt;th&gt;Archivo&lt;/th&gt;
&lt;th&gt;Equivalente en software tradicional&lt;/th&gt;
&lt;th&gt;Qué define&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Gobernanza&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;CLAUDE.md&lt;/code&gt; + &lt;code&gt;.specify/memory/constitution.md&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Invariantes y políticas del sistema&lt;/td&gt;
&lt;td&gt;Misión, regla de oro, secuencia obligatoria, política de subagentes, quality gates&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Flujo&lt;/td&gt;
&lt;td&gt;&lt;code&gt;.claude/skills/website-factory/SKILL.md&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Función principal / pipeline&lt;/td&gt;
&lt;td&gt;Los nueve pasos, qué agente o skill corre en cada uno, qué se paraleliza&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Roles&lt;/td&gt;
&lt;td&gt;&lt;code&gt;.claude/agents/*.md&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Módulos con interfaz&lt;/td&gt;
&lt;td&gt;Rol, inputs, outputs, restricciones y herramientas permitidas&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Contexto de trabajo&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;specs/001-…/&lt;/code&gt; y &lt;code&gt;docs/&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Estado / memoria compartida&lt;/td&gt;
&lt;td&gt;Spec, plan, contratos, tareas y artefactos intermedios&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Verificación&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;scripts/validate_content.py&lt;/code&gt;, &lt;code&gt;npm run check/build&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Tests&lt;/td&gt;
&lt;td&gt;Señales deterministas de aprobado o fallido&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Con esa estructura, &lt;code&gt;/website-factory briefs/cliente.md&lt;/code&gt; se comporta como una llamada a función: la skill lee el brief, recorre la secuencia y, en cada paso, &lt;strong&gt;compila un prompt&lt;/strong&gt; para el agente que corresponde. Ese prompt no es fijo; se construye con las rutas, los criterios de aceptación y las restricciones del paso actual.&lt;/p&gt;

&lt;p&gt;Una distinción que el &lt;code&gt;CLAUDE.md&lt;/code&gt; deja explícita, porque es fácil de confundir: las invocaciones &lt;code&gt;/speckit.*&lt;/code&gt; son operaciones del orquestador dentro del chat de Claude Code, no comandos de terminal, y que un agente "escriba una spec" no equivale a ejecutar &lt;code&gt;/speckit.specify&lt;/code&gt;. El sistema tiene dos runtimes —el shell y el agente— y cada instrucción tiene que dejar claro en cuál corre.&lt;/p&gt;

&lt;h2&gt;
  
  
  Prompt engineering: cada delegación es un contrato
&lt;/h2&gt;

&lt;p&gt;El prompt engineering cambia de naturaleza cuando quien escribe el prompt es otro agente. Ya no se trata de encontrar la frase mágica, sino de definir &lt;strong&gt;una interfaz&lt;/strong&gt;: qué entra, qué sale, cómo se valida y cuándo se termina. Por cada delegación, el orquestador genera un prompt con seis secciones obligatorias y registra un resumen en &lt;code&gt;docs/agent-runs.md&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Contrato de delegación (ejemplo reconstruido a partir del registro de la ejecución)&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;MISSION:          Convertir el brief en requisitos verificables y clasificar
                  cada dato como VERIFIED / ASSUMPTION / PLACEHOLDER / BLOCKED.
INPUTS:           briefs/supermercado-los-alamos.md
                  .specify/memory/constitution.md · CLAUDE.md · docs/quality-gates.md
OUTPUT FILES:     docs/requirements.md · docs/content-inventory.md   (solo estos)
ACCEPTANCE:       REQ-001..n con criterios Given/When/Then; cada dato comercial
                  con estado y línea del brief; supuestos A-xx y bloqueos B-xx.
CONSTRAINTS:      No inventar cifras, reseñas, servicios ni canales de contacto.
                  Stack y alcance fijos. No editar archivos de otros agentes.
STOP CONDITIONS:  Si un dato es contradictorio, marcarlo BLOCKED y devolver el
                  control; no resolver la ambigüedad por cuenta propia.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;MISSION&lt;/strong&gt; acota el rol a una responsabilidad. Un agente con una misión difusa expande su alcance.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;INPUTS&lt;/strong&gt; con rutas exactas es &lt;em&gt;context engineering&lt;/em&gt;: el agente no explora el repo buscando qué leer, recibe exactamente lo necesario.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;OUTPUT FILES&lt;/strong&gt; convierte la propiedad de archivos en parte del contrato y hace posible la paralelización.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;ACCEPTANCE&lt;/strong&gt; con IDs medibles permite que otro agente (el QA) verifique sin interpretar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CONSTRAINTS&lt;/strong&gt; repite las invariantes en el punto de uso: no se confía en que el agente "recuerde" la constitución.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;STOP CONDITIONS&lt;/strong&gt; es la sección que más se olvida y la que más importa: define cuándo el agente tiene que dejar de intentar y devolver el control.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Los prompts de rol (&lt;code&gt;.claude/agents/*.md&lt;/code&gt;) son estables y cortos; los prompts de tarea son dinámicos y específicos. Esa separación es la misma que entre la definición de una clase y la llamada a uno de sus métodos con argumentos.&lt;/p&gt;

&lt;h2&gt;
  
  
  Context engineering: el contexto es un presupuesto
&lt;/h2&gt;

&lt;p&gt;Si el prompt es la interfaz, el contexto es la memoria de trabajo, y es un recurso finito. Cuanto más ruido entra en la ventana de contexto, peor decide el modelo. El diseño del enjambre es, en buena medida, una estrategia de gestión de contexto:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Aislamiento por subagente.&lt;/strong&gt; Cada subagente arranca con su propia ventana de contexto. El &lt;code&gt;ux-ui-designer&lt;/code&gt; no carga la conversación sobre JSON-LD; el orquestador solo recibe resúmenes, no la exploración completa de cada agente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Memoria externa en archivos.&lt;/strong&gt; Los artefactos de &lt;code&gt;docs/&lt;/code&gt; y &lt;code&gt;specs/&lt;/code&gt; son memoria persistente: sobreviven a la sesión, se pueden leer por partes y cualquier agente posterior los consume sin reconstruirlos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Contexto progresivo.&lt;/strong&gt; Las skills se cargan cuando se invocan; los roles exponen una &lt;code&gt;description&lt;/code&gt; corta y el cuerpo completo entra solo cuando el agente se usa.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;IDs estables como índice.&lt;/strong&gt; &lt;code&gt;REQ-007&lt;/code&gt;, &lt;code&gt;FR-012&lt;/code&gt;, &lt;code&gt;CONT-S2-MAP-TITLE&lt;/code&gt;, &lt;code&gt;T024&lt;/code&gt;: un agente puede citar y buscar un requisito sin copiar su texto, y el QA puede cruzar capas con &lt;code&gt;grep&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fuente única de datos.&lt;/strong&gt; Dirección, teléfono y horarios aparecen literalmente en un solo archivo, &lt;code&gt;src/content/site.ts&lt;/code&gt; (contrato C-01). Menos duplicación también es menos contexto contradictorio.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;src/content/site.ts: cada dato comercial lleva su estado y su origen en el brief&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// --- Teléfono: BRIEF-VALIDAR (brief L148, B-03); formato E.164 = ASSUMPTION (A-09) ---&lt;/span&gt;
&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;phone&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Phone&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;display&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'0000 00-0000'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="c1"&gt;// BRIEF-VALIDAR&lt;/span&gt;
  &lt;span class="n"&gt;e164&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;phoneE164&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;          &lt;span class="c1"&gt;// ASSUMPTION (A-09)&lt;/span&gt;
  &lt;span class="n"&gt;href&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'tel:'&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;phoneE164&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="c1"&gt;// --- Horarios: BRIEF-VALIDAR (brief L151-152). Sin feriados (PENDIENTE) ni "abierto ahora". ---&lt;/span&gt;
&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;hours&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;OpeningHours&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
  &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;days&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'Lunes a sábado'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'07:30 a 21:00'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;closed&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="c1"&gt;// BRIEF-VALIDAR&lt;/span&gt;
  &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;days&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'Domingo'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'Cerrado'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;closed&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;               &lt;span class="c1"&gt;// BRIEF-VALIDAR&lt;/span&gt;
&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;offers&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Offer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// sin ofertas confirmadas → estado vacío honesto&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Loop engineering: iterar con señales deterministas
&lt;/h2&gt;

&lt;p&gt;Todo agente es un loop: reunir contexto, actuar, observar el resultado y decidir si sigue. Un sistema multi-agente es un &lt;strong&gt;loop de loops&lt;/strong&gt;. Llamo &lt;em&gt;loop engineering&lt;/em&gt; a diseñar esos ciclos de forma explícita: qué señal cierra cada iteración, cuántas iteraciones se permiten y qué pasa cuando se agotan. Un loop sin señal de salida diverge; un loop con una señal blanda ("me parece que quedó bien") converge a cualquier cosa.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Los loops del sistema y sus condiciones de salida&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Loop&lt;/th&gt;
&lt;th&gt;Quién itera&lt;/th&gt;
&lt;th&gt;Señal de feedback&lt;/th&gt;
&lt;th&gt;Límite / salida&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Interno de implementación&lt;/td&gt;
&lt;td&gt;frontend-engineer&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;astro check&lt;/code&gt; y &lt;code&gt;astro build&lt;/code&gt; (exit code)&lt;/td&gt;
&lt;td&gt;0 errores, 0 warnings; si no, corrige y reintenta&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Consistencia de especificación&lt;/td&gt;
&lt;td&gt;Orquestador con &lt;code&gt;/speckit.analyze&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Hallazgos CRITICAL / MEDIUM / LOW entre spec, plan y tasks&lt;/td&gt;
&lt;td&gt;No se implementa con CRITICAL abiertos&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Evaluador-optimizador&lt;/td&gt;
&lt;td&gt;qa-reviewer → orquestador → corrección&lt;/td&gt;
&lt;td&gt;Hallazgos BLOCKER / MAJOR / MINOR con evidencia &lt;code&gt;archivo:línea&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;Máximo dos iteraciones&lt;/strong&gt;; lo no resuelto queda como pendiente documentado&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Convergencia&lt;/td&gt;
&lt;td&gt;Orquestador con &lt;code&gt;/speckit.converge&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Brechas entre spec y código generado&lt;/td&gt;
&lt;td&gt;Converged, o tarea bloqueada a la espera de una persona&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Aprobación humana&lt;/td&gt;
&lt;td&gt;Persona&lt;/td&gt;
&lt;td&gt;Decisión explícita&lt;/td&gt;
&lt;td&gt;Dependencias nuevas, servicios externos y despliegue&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;El patrón &lt;em&gt;evaluator-optimizer&lt;/em&gt; (un agente produce, otro evalúa, el primero corrige) funciona solo si el evaluador es &lt;strong&gt;independiente&lt;/strong&gt;: otro contexto, otro prompt, criterios escritos de antemano. Si el mismo agente que implementó se autoevalúa, tiende a confirmar lo que hizo: es el equivalente agéntico de evaluar un modelo con sus propios datos de entrenamiento. Por eso el &lt;code&gt;qa-reviewer&lt;/code&gt; no recibe el razonamiento del implementador, solo los artefactos; no hay fuga de información entre quien produce y quien evalúa.&lt;/p&gt;

&lt;p&gt;Y la parte que hace que los loops sean confiables: las señales de cierre son &lt;strong&gt;deterministas&lt;/strong&gt; siempre que se pueda. El modelo muestrea de una distribución; el exit code de un build no. En términos de aprendizaje por refuerzo, el verificador es una función de recompensa verificable: binaria, barata de calcular e imposible de convencer con una buena redacción. El validador de contenido convierte reglas de negocio en una señal binaria:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;scripts/validate_content.py (fragmento): invariante C-01 de fuente única&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;single_source&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;src&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s1"&gt;'content'&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s1"&gt;'site.ts'&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;src_files&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;single_source&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;continue&lt;/span&gt;
    &lt;span class="n"&gt;s&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;read_text&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;encoding&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'utf-8'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;finditer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="s1"&gt;'Ejemplo|B0000|00-0000|000000|07:30|21:00'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;errors&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s1"&gt;'{f.relative_to(root)}: C-01 dato comercial literal fuera de site.ts ("{m.group(0)}")'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  El arnés: guardrails que no dependen del modelo
&lt;/h2&gt;

&lt;p&gt;Un enjambre sin límites diverge. Además de los loops, el sistema tiene frenos que no dependen de que el modelo "se porte bien":&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Constitución versionada&lt;/strong&gt; con seis principios no negociables (brief como fuente de verdad, stack fijo, contenido separado del diseño, accesibilidad, SEO local honesto, verificabilidad). &lt;code&gt;/speckit.plan&lt;/code&gt; incluye un &lt;em&gt;Constitution Check&lt;/em&gt; que tiene que pasar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Estados vacíos honestos&lt;/strong&gt;: canales sin confirmar con &lt;code&gt;value: null&lt;/code&gt; no se renderizan; &lt;code&gt;offers: []&lt;/code&gt; muestra "todavía no hay ofertas publicadas", nunca precios de ejemplo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;SEO sin inventar&lt;/strong&gt;: sin &lt;code&gt;canonical&lt;/code&gt;, &lt;code&gt;og:url&lt;/code&gt; ni &lt;code&gt;og:image&lt;/code&gt; mientras no exista una URL pública confirmada; JSON-LD &lt;code&gt;GroceryStore&lt;/code&gt; solo con &lt;code&gt;name&lt;/code&gt; y &lt;code&gt;address&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Permisos del proyecto mínimos&lt;/strong&gt;: &lt;code&gt;.claude/settings.json&lt;/code&gt; solo habilita el navegador contra &lt;code&gt;127.0.0.1:4321&lt;/code&gt; para la revisión visual local.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sin acciones externas&lt;/strong&gt;: no se declaran pruebas de navegador ni puntuaciones Lighthouse que no se ejecutaron, y no se instala nada sin aprobación.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Registro de cada delegación&lt;/strong&gt; en &lt;code&gt;docs/agent-runs.md&lt;/code&gt;: fecha, agente, misión, entradas, salidas, validación y estado. Es el &lt;em&gt;trace&lt;/em&gt; del sistema.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Qué produjo una ejecución completa
&lt;/h2&gt;

&lt;p&gt;La ejecución completa quedó en el repositorio: specs, documentación intermedia, registro de agentes, reporte de QA y el sitio generado. Estos son los números, todos verificables en &lt;code&gt;docs/agent-runs.md&lt;/code&gt; y &lt;code&gt;docs/qa-report.md&lt;/code&gt;:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Resultados de la ejecución sobre el brief de Supermercado Los Álamos&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Etapa&lt;/th&gt;
&lt;th&gt;Resultado&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Análisis de negocio&lt;/td&gt;
&lt;td&gt;18 requisitos, 11 supuestos y 8 bloqueos explícitos&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Especificación (&lt;code&gt;/speckit.specify&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;4 historias de usuario, FR-001..019 trazados a REQ, SC-001..007; checklist 16/16, sin necesidad de &lt;code&gt;/speckit.clarify&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Diseño&lt;/td&gt;
&lt;td&gt;34 componentes especificados, tokens &lt;code&gt;@theme&lt;/code&gt;, ilustraciones SVG propias en lugar de fotos sin licencia&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Plan y tareas&lt;/td&gt;
&lt;td&gt;Investigación R-01..08, contratos C-01..03, 41 tareas organizadas por historia&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;/speckit.analyze&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;0 CRITICAL, 2 MEDIUM, 4 LOW; los relevantes se corrigieron en &lt;code&gt;tasks.md&lt;/code&gt; antes de implementar&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Implementación&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;astro check&lt;/code&gt; 0 errores / 0 warnings / 0 hints; build de 5 páginas; validador PASS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;QA independiente&lt;/td&gt;
&lt;td&gt;0 BLOCKER, 0 MAJOR, 8 MINOR&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Revisión visual&lt;/td&gt;
&lt;td&gt;5 páginas × 3 anchos (360/768/1440): 15/15 sin scroll horizontal&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Convergencia&lt;/td&gt;
&lt;td&gt;Converged; una tarea (cargar tipografías) bloqueada a la espera de aprobación&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  Lo que mostró el loop de QA
&lt;/h3&gt;

&lt;p&gt;El hallazgo más revelador fue QA-008: el &lt;code&gt;qa-reviewer&lt;/code&gt; detectó que &lt;strong&gt;el validador escrito por el &lt;code&gt;frontend-engineer&lt;/code&gt; era más estrecho que el contrato&lt;/strong&gt; que debía verificar. Buscaba algunos datos literales pero no todos, y su patrón no detectaba "compras online". El auditor no solo revisa el código: revisa los tests. Se corrigió en la primera iteración, con prueba positiva y negativa.&lt;/p&gt;

&lt;p&gt;El otro momento clave fue una parada correcta. El brief pedía tipografías específicas; cargarlas requería instalar paquetes &lt;code&gt;@fontsource&lt;/code&gt;. Como eso es una dependencia nueva, el sistema no la instaló: dejó la tarea T040 bloqueada, lo documentó como QA-001 y devolvió la decisión. Un agente que sabe detenerse vale más que uno que siempre termina.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Veredicto del propio sistema:&lt;/strong&gt; Aprobado para preview local con observaciones; no apto para producción hasta validar teléfono y horarios con el comercio, confirmar categorías, sumar fotos con licencia y definir dominio. Que el sistema diga esto de sí mismo es parte del resultado.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h3&gt;
  
  
  Límites honestos
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Es no determinista: otra ejecución con el mismo brief puede producir otro sitio que cumpla igualmente la spec. Lo reproducible es el proceso y los controles, no el HTML exacto.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;validate_content.py&lt;/code&gt; es heurístico: no reemplaza una revisión editorial ni una auditoría de seguridad.&lt;/li&gt;
&lt;li&gt;No incluye Playwright, Lighthouse ni despliegue automático. La prueba de teclado asistida quedó registrada como no ejecutada.&lt;/li&gt;
&lt;li&gt;Para varios clientes en paralelo conviene un repo o una rama por proyecto, para que no choquen &lt;code&gt;specs/&lt;/code&gt; ni el estado de &lt;code&gt;.specify/&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Principios de diseño para sistemas multiagente
&lt;/h2&gt;

&lt;p&gt;La conclusión no es que los agentes reemplacen a un equipo, sino que &lt;strong&gt;el trabajo de ingeniería se mueve un nivel de abstracción hacia arriba&lt;/strong&gt;. En lugar de escribir el sitio, escribimos el sistema que escribe sitios: sus reglas, sus roles, sus contratos y sus loops. Ese sistema se revisa en pull requests, se versiona y mejora entre ejecuciones.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Diseñá la topología antes que los prompts.&lt;/strong&gt; Orquestador único, especialistas sin comunicación lateral y coordinación por archivos es un punto de partida que escala y se puede auditar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tratá cada delegación como una llamada a una API&lt;/strong&gt;: misión, entradas, salidas, aceptación, restricciones y condición de parada.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;El contexto es un presupuesto.&lt;/strong&gt; Aislá contextos por agente, persistí en archivos y pasá rutas exactas, no "mirá el repo".&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Todo loop necesita una señal determinista y un límite.&lt;/strong&gt; Dos iteraciones y después una persona.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;El evaluador tiene que ser independiente&lt;/strong&gt;, y también tiene que auditar los tests.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mínimo privilegio por rol&lt;/strong&gt;: si un agente no necesita ejecutar comandos, no le des &lt;code&gt;Bash&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escribí dónde se detiene la autonomía&lt;/strong&gt;: dependencias, servicios externos, datos personales y despliegues pasan por una persona.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;El repositorio es público y tiene licencia MIT. Se puede clonar, completar &lt;code&gt;templates/brief-template.md&lt;/code&gt; con datos reales y correr &lt;code&gt;/website-factory briefs/mi-empresa.md&lt;/code&gt; desde Claude Code. Me interesa saber cómo están armando sus propios arneses: ¿qué loops cerraron con señales deterministas y cuáles siguen dependiendo de "me parece que está bien"?&lt;/p&gt;

&lt;h3&gt;
  
  
  Referencias
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://github.com/juliancardozo/website-factory-mvp" rel="noopener noreferrer"&gt;juliancardozo/website-factory-mvp&lt;/a&gt; — repositorio del caso, con la ejecución completa.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/github/spec-kit" rel="noopener noreferrer"&gt;GitHub Spec Kit&lt;/a&gt; — toolkit de Spec-Driven Development (en el repo, versión 1.4.1.dev0).&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.anthropic.com/engineering/building-effective-agents" rel="noopener noreferrer"&gt;Building effective agents&lt;/a&gt; — Anthropic: patrones orchestrator-workers, parallelization y evaluator-optimizer.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents" rel="noopener noreferrer"&gt;Effective context engineering for AI agents&lt;/a&gt; — Anthropic: el contexto como recurso finito.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://docs.claude.com/en/docs/claude-code/sub-agents" rel="noopener noreferrer"&gt;Subagents en Claude Code&lt;/a&gt; — documentación oficial de subagentes, herramientas y contexto aislado.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;Criterio práctico: en un sistema multiagente no se optimiza el prompt, se diseña la arquitectura. Topología clara, contratos de delegación, contexto acotado, loops con señales deterministas y límites, y personas en los puntos donde un error cuesta caro.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>spanish</category>
    </item>
    <item>
      <title>SaaS multitenant: diseñar para escalar, automatizar para operar y replicar para sobrevivir</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:11:09 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/saas-multitenant-disenar-para-escalar-automatizar-para-operar-y-replicar-para-sobrevivir-5b51</link>
      <guid>https://dev.to/julian_cardozo_dev/saas-multitenant-disenar-para-escalar-automatizar-para-operar-y-replicar-para-sobrevivir-5b51</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/saas-multitenant-iac-resiliencia/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Son las 03:17. Una región cloud deja de responder. Tres clientes financieros comparten la misma plataforma SaaS. La infraestructura está replicada, pero nadie verificó si el sistema de autenticación también puede recuperarse. No es un incidente real: es un experimento mental. Pero obliga a hacerse tres preguntas incómodas. ¿Estamos realmente aislando a nuestros tenants? ¿Podemos reconstruir la plataforma desde código? ¿Sabemos cuánto tardaríamos en recuperar el servicio completo, no solo la base de datos? La tesis de este artículo es que la resiliencia de un SaaS multitenant no depende de cuántos recursos duplicamos, sino de qué tan bien diseñamos el aislamiento, automatizamos la infraestructura y validamos nuestra capacidad real de recuperación.&lt;/p&gt;

&lt;h2&gt;
  
  
  Multitenancy: compartir infraestructura sin compartir riesgos
&lt;/h2&gt;

&lt;p&gt;Multitenancy suele presentarse como una decisión de costos: compartir infraestructura entre clientes para no pagar N copias de lo mismo. Es eso, pero sobre todo es una decisión de riesgo. Cada recurso compartido es un lugar donde un tenant puede afectar a otro: por seguridad, por rendimiento o por una falla. El diseño consiste en elegir, componente por componente, qué se comparte y qué no.&lt;/p&gt;

&lt;h3&gt;
  
  
  Pool, silo y bridge
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Pool&lt;/strong&gt;: infraestructura y datos compartidos, con aislamiento lógico. Un único cluster, una única base y un &lt;code&gt;tenant_id&lt;/code&gt; que atraviesa cada capa.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Silo&lt;/strong&gt;: recursos dedicados por tenant. Cuenta, cluster o base propios. Más caro y más lento de aprovisionar, pero con un blast radius acotado por diseño.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Bridge&lt;/strong&gt;: una combinación. Servicios sin estado compartidos y datos dedicados, o un pool por defecto con la opción de mover a un tenant grande a un silo.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Los casos documentados recientes muestran que la respuesta casi nunca es pura. Cognizant consolidó OrderServ, un SaaS de pedidos para cadenas de comida rápida, desde un cluster de Amazon ECS por marca hacia un cluster compartido: 21 servicios en lugar de 105 para cinco marcas, onboarding por configuración en minutos y la opción de que una marca de alto volumen vuelva a un cluster dedicado. El caso en sentido opuesto es una plataforma de ad-serving con estado en memoria, donde el ruido entre vecinos es contención de memoria: pasó de una cuenta por tenant a cuentas compartidas por tier, pero conservó un cluster ECS por tenant dentro de cada grupo. Las dos son arquitecturas bridge, con fronteras en lugares distintos porque sus riesgos son distintos.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Modelos de aislamiento: trade-offs típicos (no absolutos)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Dimensión&lt;/th&gt;
&lt;th&gt;Pool&lt;/th&gt;
&lt;th&gt;Bridge&lt;/th&gt;
&lt;th&gt;Silo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Aislamiento de seguridad&lt;/td&gt;
&lt;td&gt;Lógico: depende de identidad, código y políticas (RLS, IAM con contexto de tenant)&lt;/td&gt;
&lt;td&gt;Mixto: dedicado donde está el dato o el riesgo, lógico en el resto&lt;/td&gt;
&lt;td&gt;Físico o de cuenta: la frontera la impone la infraestructura&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Costo por tenant&lt;/td&gt;
&lt;td&gt;El más bajo; se amortiza con densidad&lt;/td&gt;
&lt;td&gt;Intermedio; depende de qué capas se dedican&lt;/td&gt;
&lt;td&gt;El más alto; capacidad ociosa por tenant&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Complejidad operativa&lt;/td&gt;
&lt;td&gt;Baja en cantidad de recursos, alta en disciplina de código&lt;/td&gt;
&lt;td&gt;La más alta: dos modelos conviviendo y migraciones entre ellos&lt;/td&gt;
&lt;td&gt;Alta en cantidad de recursos; exige automatización total&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Escalabilidad&lt;/td&gt;
&lt;td&gt;Escala con el sistema; sensible a noisy neighbors&lt;/td&gt;
&lt;td&gt;Permite escalar tenants grandes de forma independiente&lt;/td&gt;
&lt;td&gt;Lineal con tenants; los límites de cuenta y cuotas aparecen pronto&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Blast radius&lt;/td&gt;
&lt;td&gt;Toda la plataforma&lt;/td&gt;
&lt;td&gt;Acotado por tier o por tenant&lt;/td&gt;
&lt;td&gt;Un tenant&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Onboarding&lt;/td&gt;
&lt;td&gt;Configuración (minutos)&lt;/td&gt;
&lt;td&gt;Configuración o aprovisionamiento según tier&lt;/td&gt;
&lt;td&gt;Aprovisionamiento completo (requiere IaC)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  El aislamiento es una cadena, no una capa
&lt;/h3&gt;

&lt;p&gt;En un modelo pool, la frontera del tenant tiene que existir en cada capa: identidad (el tenant se deriva del token, no de un parámetro), aplicación (la librería de acceso a datos no construye una consulta sin tenant), base de datos (Row-Level Security como barrera cuando la aplicación se equivoca) y permisos de infraestructura (credenciales con alcance de tenant). OrderServ lo describe con claridad: una librería de tenancy que se niega a construir identificadores de recursos sin prefijo de tenant, y credenciales temporales con el tenant como session tag como segunda barrera. Ya escribí sobre &lt;a href="https://juliancardozo.github.io/blog/multi-tenancy-rls-frontera-datos/" rel="noopener noreferrer"&gt;por qué el aislamiento de datos no puede depender de un WHERE&lt;/a&gt;; la idea se generaliza: cada capa asume que la anterior puede fallar.&lt;/p&gt;

&lt;p&gt;El cómputo también es una frontera. Los contenedores comparten el kernel del host, y eso importa cuando un tenant ejecuta código propio o no confiable. AWS anunció el 9 de noviembre de 2026 Nitro Sandboxes para Amazon EKS, donde cada pod corre en su propia VM liviana sobre el sistema Nitro, con requisito de Kubernetes 1.36 o superior. Es demasiado nuevo para recomendarlo sin evaluar, pero marca una tendencia: el aislamiento fuerte deja de ser sinónimo de un cluster por cliente.&lt;/p&gt;

&lt;h3&gt;
  
  
  Noisy neighbor, blast radius y observabilidad por tenant
&lt;/h3&gt;

&lt;p&gt;Un vecino ruidoso no siempre es un tenant que abusa: puede ser un cliente con una campaña legítima. OrderServ documenta picos promocionales de 5 a 10 veces en minutos y responde con capas: escalado predictivo, escalado reactivo, margen de capacidad y rate limits por tenant en el API Gateway. Nada de eso es gestionable sin observabilidad tenant-aware: métricas, logs y trazas etiquetados con el tenant, para responder en minutos "¿a quién afecta esto?" y "¿cuánto cuesta este cliente?". Si el onboarding de un tenant no crea también sus dashboards, alertas y presupuestos, el tenant existe pero no se puede operar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Infrastructure as Code: la arquitectura tiene que ser reproducible
&lt;/h2&gt;

&lt;p&gt;Un diagrama describe la arquitectura que queremos. El código describe la que efectivamente tenemos, o al menos debería. Infrastructure as Code convierte la infraestructura en un artefacto de ingeniería: se versiona, se revisa, se prueba y se puede reconstruir. Terraform y OpenTofu, su fork bajo la Linux Foundation, comparten el mismo modelo: estado, plan y apply. La herramienta importa menos que la disciplina alrededor.&lt;/p&gt;

&lt;h3&gt;
  
  
  Separar por ciclo de vida, no por herramienta
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Global&lt;/strong&gt;: organización de cuentas, DNS, identidad, políticas base. Cambia poco y su blast radius es total.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Regional&lt;/strong&gt;: red, clusters, bases compartidas del pool, réplicas hacia la región de recuperación.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tenant&lt;/strong&gt;: namespaces, cuotas, identidad de workload, recursos dedicados para tenants silo, dashboards y alertas.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Cada capa con su propio estado remoto, con bloqueo y cifrado, y con permisos distintos para aplicarla. Un error en la capa de tenant no debería poder tocar el DNS global. Los secretos no viven en el código ni en el estado en texto plano: se referencian desde un gestor de secretos o un KMS.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Ejemplo ilustrativo (HCL, Terraform/OpenTofu). Los módulos ./modules/* son hipotéticos y encapsulan al proveedor&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight hcl"&gt;&lt;code&gt;&lt;span class="c1"&gt;# El catálogo de tenants es la fuente de verdad del onboarding:&lt;/span&gt;
&lt;span class="c1"&gt;# sumar un cliente es un cambio en este mapa, revisado en un Pull Request.&lt;/span&gt;
&lt;span class="n"&gt;variable&lt;/span&gt; &lt;span class="s2"&gt;"tenants"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="k"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;map&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;object&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;tier&lt;/span&gt;        &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;string&lt;/span&gt; &lt;span class="c1"&gt;# "pool" | "silo"&lt;/span&gt;
    &lt;span class="n"&gt;rpo_minutes&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;number&lt;/span&gt; &lt;span class="c1"&gt;# acordado con negocio, no elegido por infraestructura&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

  &lt;span class="n"&gt;validation&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;condition&lt;/span&gt;     &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;alltrue&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="n"&gt;in&lt;/span&gt; &lt;span class="nf"&gt;values&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tenants&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;contains&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"pool"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"silo"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tier&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;error_message&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"tier debe ser \"pool\" o \"silo\"."&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="n"&gt;variable&lt;/span&gt; &lt;span class="s2"&gt;"region"&lt;/span&gt;          &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;string&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;variable&lt;/span&gt; &lt;span class="s2"&gt;"recovery_region"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;string&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="n"&gt;locals&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;silo_tenants&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="n"&gt;in&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tenants&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tier&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"silo"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="c1"&gt;# Capa regional: una base compartida para el pool, con RLS y réplica.&lt;/span&gt;
&lt;span class="n"&gt;module&lt;/span&gt; &lt;span class="s2"&gt;"pool_database"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;source&lt;/span&gt;             &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"./modules/database"&lt;/span&gt;
  &lt;span class="n"&gt;name&lt;/span&gt;               &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"pool-${var.region}"&lt;/span&gt;
  &lt;span class="n"&gt;row_level_security&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
  &lt;span class="n"&gt;replica_region&lt;/span&gt;     &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;recovery_region&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="c1"&gt;# Recursos dedicados solo para tenants silo.&lt;/span&gt;
&lt;span class="n"&gt;module&lt;/span&gt; &lt;span class="s2"&gt;"silo_database"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;source&lt;/span&gt;         &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"./modules/database"&lt;/span&gt;
  &lt;span class="n"&gt;for_each&lt;/span&gt;       &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;local&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;silo_tenants&lt;/span&gt;
  &lt;span class="n"&gt;name&lt;/span&gt;           &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"tenant-${each.key}"&lt;/span&gt;
  &lt;span class="n"&gt;replica_region&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;recovery_region&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="c1"&gt;# Todos los tenants: namespace, cuotas, identidad de workload y alertas.&lt;/span&gt;
&lt;span class="n"&gt;module&lt;/span&gt; &lt;span class="s2"&gt;"tenant_runtime"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;source&lt;/span&gt;   &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"./modules/tenant-runtime"&lt;/span&gt;
  &lt;span class="n"&gt;for_each&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tenants&lt;/span&gt;

  &lt;span class="n"&gt;tenant_id&lt;/span&gt;      &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;each&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;
  &lt;span class="n"&gt;resource_quota&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;each&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tier&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"silo"&lt;/span&gt; &lt;span class="o"&gt;?&lt;/span&gt; &lt;span class="s2"&gt;"dedicated"&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"shared-default"&lt;/span&gt;
  &lt;span class="n"&gt;database_url&lt;/span&gt;   &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;try&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;module&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;silo_database&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;each&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;endpoint&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;module&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;pool_database&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;endpoint&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
  &lt;span class="n"&gt;labels&lt;/span&gt;         &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;tenant&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;each&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tier&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;each&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tier&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Lo importante del ejemplo no es la sintaxis, sino tres decisiones. El tier de un tenant es un dato, no una bifurcación del código. La validación rechaza configuraciones inválidas antes del plan. Y el RPO de cada tenant queda escrito junto a su definición, donde una política puede verificar que la estrategia de backup y réplica asignada es capaz de cumplirlo.&lt;/p&gt;

&lt;h3&gt;
  
  
  Del Pull Request a la observabilidad
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Pull Request&lt;/strong&gt;: el cambio, incluido el alta de un tenant, se propone como código.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Validaciones&lt;/strong&gt;: formato, &lt;code&gt;validate&lt;/code&gt;, linters y escaneo de seguridad de la configuración.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan&lt;/strong&gt;: el diff real contra el estado, publicado en el PR.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Policy as Code&lt;/strong&gt;: reglas evaluadas sobre el plan (OPA/Rego, Sentinel o Kyverno en Kubernetes): cifrado obligatorio, sin recursos públicos, tags de tenant presentes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Revisión&lt;/strong&gt;: una persona revisa el plan, no solo el código. Más aprobaciones cuanto mayor el blast radius de la capa.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Apply&lt;/strong&gt;: desde el pipeline, nunca desde una laptop, con credenciales de corta duración.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verificación&lt;/strong&gt;: smoke tests y checks de salud del tenant o de la región.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Observabilidad&lt;/strong&gt;: el cambio queda asociado a métricas y eventos para correlacionar regresiones.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;GitOps lleva la misma idea al runtime: un controlador en el cluster reconcilia continuamente lo declarado en Git con lo que corre. Ahí aparece el problema que la mayoría de los equipos subestima: el drift. El artículo de Qovery sobre provisión multi-cloud lo pone como línea divisoria entre herramientas: Crossplane revierte cambios fuera de banda de forma continua, plataformas como Spacelift o env0 corren chequeos de drift programados, y Terraform u OpenTofu solos lo muestran recién cuando alguien corre un plan. Vale leerlo sabiendo que es contenido de un proveedor, pero la clasificación es útil.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Límite:&lt;/strong&gt; IaC no garantiza por sí sola consistencia de datos, seguridad ni recuperación. Reconstruye recursos; no restaura el contenido de una base, no corrige una política mal diseñada y no prueba que el runbook funcione. Un &lt;code&gt;apply&lt;/code&gt; exitoso en la región de recuperación no dice nada sobre si los datos que llegaron son los correctos.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Replicación y continuidad operativa
&lt;/h2&gt;

&lt;p&gt;Los términos se usan como sinónimos y no lo son. Confundirlos lleva a pagar por una protección y creer que se tiene otra.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Conceptos que se confunden&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Concepto&lt;/th&gt;
&lt;th&gt;Qué resuelve&lt;/th&gt;
&lt;th&gt;Qué no resuelve&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Alta disponibilidad (HA)&lt;/td&gt;
&lt;td&gt;Fallas de componentes o de una zona, sin intervención humana (Multi-AZ, réplicas, balanceo)&lt;/td&gt;
&lt;td&gt;La pérdida de una región o la corrupción lógica de datos&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Disaster Recovery (DR)&lt;/td&gt;
&lt;td&gt;Recuperar una función de negocio ante un evento mayor, típicamente en otra región&lt;/td&gt;
&lt;td&gt;Nada, si no fue probado bajo condiciones reales&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Backup y restore&lt;/td&gt;
&lt;td&gt;Volver a un punto en el tiempo, incluso antes de un error humano o un ransomware&lt;/td&gt;
&lt;td&gt;El tiempo de recuperación: restaurar suele ser lento&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Replicación síncrona&lt;/td&gt;
&lt;td&gt;RPO cercano a cero: la escritura se confirma en ambos lados&lt;/td&gt;
&lt;td&gt;La latencia: penaliza cada escritura y escala mal entre regiones lejanas&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Replicación asíncrona&lt;/td&gt;
&lt;td&gt;Copias remotas sin penalizar la latencia&lt;/td&gt;
&lt;td&gt;La pérdida de datos en vuelo: existe un RPO mayor que cero&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Active-active&lt;/td&gt;
&lt;td&gt;RTO mínimo: las regiones ya sirven tráfico&lt;/td&gt;
&lt;td&gt;La consistencia: exige resolver conflictos de escritura&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Active-passive&lt;/td&gt;
&lt;td&gt;Diseño más simple: una región escribe&lt;/td&gt;
&lt;td&gt;El RTO: la región pasiva tiene que promoverse y escalar&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;RTO&lt;/strong&gt; es cuánto tiempo puede estar caída una función; &lt;strong&gt;RPO&lt;/strong&gt;, cuántos datos se pueden perder, medido en tiempo. &lt;strong&gt;Failover&lt;/strong&gt; es mover el servicio a la región de recuperación; &lt;strong&gt;failback&lt;/strong&gt;, volver, y suele ser más difícil porque hay que reconciliar lo que se escribió en el medio.&lt;/p&gt;

&lt;p&gt;La serie de AWS Architecture Blog publicada el 2 de noviembre de 2026 por Peter Garnepudi y Jay Desai propone empezar por tres decisiones de negocio antes que por el diagrama: definir el límite de recuperación alrededor de funciones de negocio y no de aplicaciones, anclar RTO y RPO a consecuencias de negocio, y contar la cadena de dependencias. Su ejemplo más claro: un objetivo de 1 hora para una aplicación quedaba limitado a 4 horas por un servicio de identidad compartido de otro equipo. Una aplicación se recupera tan rápido como su dependencia más lenta.&lt;/p&gt;

&lt;h3&gt;
  
  
  Escenario hipotético: caída regional a las 03:17
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Detección&lt;/strong&gt;: alertas por síntomas (tasa de error, latencia por tenant), no solo por recursos. Se declara incidente con un rol de comando definido.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Impacto por tenant&lt;/strong&gt;: ¿quiénes están afectados?, ¿qué tier tiene cada uno?, ¿qué RTO comprometimos con cada cliente? La observabilidad tenant-aware convierte esto en una consulta, no en una conversación.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Decisión de failover&lt;/strong&gt;: la toma quien estaba designado de antemano, con criterios escritos. Fallar hacia la otra región tiene costo: pérdida de datos en vuelo y un failback posterior.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Promoción de réplicas&lt;/strong&gt;: se verifica el lag de replicación de cada base antes de promoverla. Con replicación asíncrona, el último lag observado es la pérdida de datos real.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Redirección del tráfico&lt;/strong&gt;: DNS con health checks o un control de enrutamiento preparado. AWS advierte que crear o modificar registros DNS e IAM durante el evento depende de planos de control de una sola región: esos cambios se dejan resueltos antes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Autenticación y dependencias&lt;/strong&gt;: el Identity Provider, los secretos, las integraciones de pago y los proveedores externos. En el caso que describe AWS, la plataforma de autenticación compartida quedó fuera del alcance de recuperación y los logins fallaron.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Consistencia de datos&lt;/strong&gt;: conteos, sumas de control y reconciliación de los últimos eventos. En un SaaS financiero, saber qué transacciones quedaron en duda es parte del servicio.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Comunicación y recuperación&lt;/strong&gt;: estado público por tenant, actualizaciones periódicas, y después un postmortem que vuelve a las tres decisiones.&lt;/li&gt;
&lt;/ol&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Replicación no es backup:&lt;/strong&gt; Una réplica copia fielmente lo que pasa en el primario, incluido un &lt;code&gt;DELETE&lt;/code&gt; sin &lt;code&gt;WHERE&lt;/code&gt;, una migración defectuosa o datos cifrados por un ransomware. La recuperación ante errores lógicos necesita backups con retención, idealmente inmutables y en una cuenta separada, y restauraciones probadas.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Una arquitectura de referencia
&lt;/h2&gt;

&lt;p&gt;La siguiente propuesta es una referencia hipotética, no la descripción de un sistema real. Usa un modelo bridge: servicios y datos en pool por defecto, con recursos dedicados para tenants que lo requieren por contrato, regulación o volumen, y un esquema active-passive con capacidad mínima pre-aprovisionada en la región de recuperación.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;SaaS multitenant bridge con región de recuperación: el diagrama se puede ver en el &lt;a href="https://juliancardozo.github.io/blog/saas-multitenant-iac-resiliencia/" rel="noopener noreferrer"&gt;artículo original&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Las decisiones detrás del diagrama: el control plane vive fuera de las regiones de datos para poder operar durante una caída; el Identity Provider está dentro del alcance de DR; la mensajería se diseña para que los consumidores sean idempotentes, porque después de un failover se van a reprocesar mensajes; y los backups viven en una cuenta separada, para que una credencial comprometida en producción no pueda borrarlos.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Servicios posibles en AWS y OCI (opciones, no equivalencias funcionales)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Capacidad&lt;/th&gt;
&lt;th&gt;AWS&lt;/th&gt;
&lt;th&gt;OCI&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;DNS y tráfico global&lt;/td&gt;
&lt;td&gt;Route 53 (health checks, failover), Application Recovery Controller&lt;/td&gt;
&lt;td&gt;OCI DNS con Traffic Management Steering Policies&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Entrada&lt;/td&gt;
&lt;td&gt;Application Load Balancer, Amazon API Gateway&lt;/td&gt;
&lt;td&gt;OCI Load Balancer, OCI API Gateway&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kubernetes&lt;/td&gt;
&lt;td&gt;Amazon EKS&lt;/td&gt;
&lt;td&gt;Container Engine for Kubernetes (OKE)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Identidad&lt;/td&gt;
&lt;td&gt;Amazon Cognito, IAM Identity Center&lt;/td&gt;
&lt;td&gt;OCI IAM con Identity Domains&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Base relacional&lt;/td&gt;
&lt;td&gt;Aurora PostgreSQL (Global Database)&lt;/td&gt;
&lt;td&gt;OCI Database with PostgreSQL, Autonomous Database (Data Guard)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Object storage&lt;/td&gt;
&lt;td&gt;Amazon S3 con replicación entre regiones&lt;/td&gt;
&lt;td&gt;OCI Object Storage con políticas de replicación&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Mensajería&lt;/td&gt;
&lt;td&gt;Amazon SQS, SNS, EventBridge&lt;/td&gt;
&lt;td&gt;OCI Queue, OCI Streaming&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Claves y secretos&lt;/td&gt;
&lt;td&gt;AWS KMS, Secrets Manager&lt;/td&gt;
&lt;td&gt;OCI Vault&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Orquestación de DR&lt;/td&gt;
&lt;td&gt;Application Recovery Controller, AWS Resilience Hub&lt;/td&gt;
&lt;td&gt;OCI Full Stack Disaster Recovery&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Cada fila esconde diferencias reales de semántica de replicación, límites, cuotas y comportamiento ante fallas. Por ejemplo, el modelo de failover de una base global administrada no es el mismo que el de Data Guard. La tabla sirve para saber dónde buscar, no para migrar de una nube a otra.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lo que hay que medir
&lt;/h2&gt;

&lt;p&gt;Los indicadores conectan una decisión técnica con lo que siente el cliente y con el riesgo que asume el negocio. No hay benchmarks universales: el valor correcto de cada uno lo define el producto, el contrato y la regulación.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Indicadores y la pregunta que responde cada uno&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Indicador&lt;/th&gt;
&lt;th&gt;Pregunta que responde&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Availability / SLO por tenant&lt;/td&gt;
&lt;td&gt;¿El servicio cumple lo que prometimos, también para el cliente más chico?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Error budget&lt;/td&gt;
&lt;td&gt;¿Podemos seguir cambiando a esta velocidad o hay que frenar y estabilizar?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RTO objetivo vs. RTO observado&lt;/td&gt;
&lt;td&gt;¿Cuánto tardamos de verdad la última vez que lo probamos?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RPO objetivo vs. pérdida observada&lt;/td&gt;
&lt;td&gt;¿Cuántos datos perdimos en el último ejercicio, medido y no estimado?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MTTR&lt;/td&gt;
&lt;td&gt;¿Cuánto tardamos en restaurar el servicio ante un incidente cualquiera?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Change failure rate&lt;/td&gt;
&lt;td&gt;¿Qué proporción de cambios termina en incidente o rollback?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;% de recursos gestionados por IaC&lt;/td&gt;
&lt;td&gt;¿Qué parte de la plataforma no podríamos reconstruir desde código?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Configuration drift&lt;/td&gt;
&lt;td&gt;¿Cuántas diferencias hay entre lo declarado y lo que corre, y cuánto duran?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Costo por tenant&lt;/td&gt;
&lt;td&gt;¿Cada tier es rentable? ¿Cuánto cuesta la resiliencia que vendemos?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Incidentes multi-tenant&lt;/td&gt;
&lt;td&gt;¿Nuestro aislamiento contiene las fallas o las propaga?&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Los pares objetivo/observado son los más reveladores. En el caso que documenta AWS, una organización tenía un compromiso contractual de recuperación de 5 horas y su primer ejercicio tardó entre 9 y 11. El número del contrato era una aspiración; el del ejercicio era la realidad.&lt;/p&gt;

&lt;h2&gt;
  
  
  Los errores que conviene evitar
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Confundir backup con replicación.&lt;/strong&gt; Consecuencia: la corrupción se replica en segundos. Mitigación: backups con retención e inmutabilidad, y restauraciones periódicas medidas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Compartir recursos sin analizar aislamiento.&lt;/strong&gt; Consecuencia: un tenant degrada o expone a otro. Mitigación: decidir pool o silo por componente y por riesgo, con defensa en profundidad.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Automatizar despliegues sin automatizar recuperación.&lt;/strong&gt; Consecuencia: el día del incidente, el runbook es un documento que nadie ejecutó. Mitigación: runbooks como código y probados.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tener IaC sin detectar drift.&lt;/strong&gt; Consecuencia: la región de recuperación se construye desde un código que ya no describe producción. Mitigación: drift checks programados y cambios manuales prohibidos o reconciliados.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Diseñar multi-region sin validar dependencias.&lt;/strong&gt; Consecuencia: la aplicación vuelve y el IdP, un secreto o un proveedor externo no. Mitigación: mapear la cadena completa y pedir compromisos de recuperación por escrito a cada dueño.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No probar la recuperación de datos.&lt;/strong&gt; Consecuencia: un backup que nunca se restauró es una hipótesis. Mitigación: restores automatizados con verificación de integridad.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ignorar los costos de resiliencia.&lt;/strong&gt; Consecuencia: una arquitectura que el negocio no puede sostener y que se recorta en silencio. Mitigación: costo por tier visible y elegido.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Definir RTO/RPO sin el negocio.&lt;/strong&gt; Consecuencia: objetivos que nadie financió. Mitigación: cada objetivo nace de una consecuencia de negocio confirmada por alguien responsable de ella.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dejar el Identity Provider fuera de los ejercicios.&lt;/strong&gt; Consecuencia: la plataforma está arriba y nadie puede iniciar sesión. Mitigación: el IdP es parte del alcance de cada prueba.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;La segunda parte de la serie de AWS propone validar de forma progresiva: ejercicio de mesa, failover planificado, simulacro sin aviso y game day con inyección de fallas. Los autores aclaran que es un modelo de madurez propio, no una taxonomía formal, pero su síntesis es precisa: la mesa encuentra el paso sin dueño, el failover planificado la mala configuración, el simulacro la falla de coordinación y el game day la dependencia no modelada. Quedarse en el failover planificado deja ocultas las fallas de equipo y de proceso.&lt;/p&gt;

&lt;h2&gt;
  
  
  El rol de Platform Engineering
&lt;/h2&gt;

&lt;p&gt;Todo lo anterior se puede hacer con un equipo de infraestructura que recibe tickets. No escala. La alternativa es tratar la infraestructura como un producto interno: una plataforma que permite a los equipos crear ambientes de forma autónoma, desplegar bajo estándares definidos, heredar controles de seguridad, consultar métricas y costos por tenant, ejecutar procedimientos reproducibles y correr ejercicios de recuperación sin coordinar cinco equipos por mail.&lt;/p&gt;

&lt;p&gt;Los &lt;strong&gt;Golden Paths&lt;/strong&gt; son el camino recomendado y mantenido: un template de servicio que ya viene con observabilidad por tenant, policies y pipeline. Una &lt;strong&gt;Internal Developer Platform&lt;/strong&gt; es la superficie donde ese camino se consume. &lt;strong&gt;DevSecOps&lt;/strong&gt; es la condición para que la seguridad esté en el camino y no en una revisión al final. El objetivo no es prohibir desvíos, sino que el camino correcto sea el más fácil.&lt;/p&gt;

&lt;p&gt;La resiliencia, además, es un problema de colaboración. Product define qué funciones importan y cuánto vale una hora sin ellas. Security define qué no puede compartirse. Infrastructure construye la capacidad. Engineering diseña servicios que toleran reintentos y failovers. Si cualquiera de los cuatro falta en la conversación, el RTO es un número que nadie puede defender.&lt;/p&gt;

&lt;h2&gt;
  
  
  Diseñar para fallar, operar para recuperarse
&lt;/h2&gt;

&lt;p&gt;Volvamos a las 03:17. La infraestructura replicada no era el problema; el problema era una dependencia que nadie había incluido en el límite de recuperación, un objetivo que nadie había validado y un ejercicio que nunca se corrió con el IdP adentro. Ninguna de esas fallas se resuelve comprando más regiones.&lt;/p&gt;

&lt;p&gt;La disponibilidad no es una propiedad que se compra en la nube. Es una capacidad que los equipos construyen, automatizan y ponen a prueba: con fronteras de aislamiento elegidas por riesgo, infraestructura que se puede reconstruir desde código sin drift, y objetivos de recuperación que el negocio firmó y que un ejercicio confirmó.&lt;/p&gt;

&lt;p&gt;Y una pregunta para el debate: en tu plataforma, ¿cuál es la dependencia más lenta de recuperar, y quién es su dueño?&lt;/p&gt;

&lt;h3&gt;
  
  
  Referencias
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://aws.amazon.com/blogs/architecture/three-business-decisions-that-define-your-dr-success/" rel="noopener noreferrer"&gt;Three business decisions that define your DR success&lt;/a&gt; — Peter Garnepudi y Jay Desai, AWS Architecture Blog, 2 de noviembre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://aws.amazon.com/blogs/architecture/validating-your-dr-commitment-from-controlled-test-to-real-world-readiness/" rel="noopener noreferrer"&gt;Validating your DR commitment: From controlled test to real-world readiness&lt;/a&gt; — Peter Garnepudi y Jay Desai, AWS Architecture Blog, 2 de noviembre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.qovery.com/blog/automate-multi-cloud-provisioning-governance-without-hand-syncing" rel="noopener noreferrer"&gt;How to Automate Multi-Cloud Provisioning and Governance Without Hand-Syncing Four Copies of the Same Environment&lt;/a&gt; — Alessandro Carrano, Qovery Blog, 2 de noviembre de 2026 (contenido de proveedor).&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://aws.amazon.com/blogs/architecture/how-orderserv-achieved-up-to-64-cost-savings-with-multi-tenant-ecs/" rel="noopener noreferrer"&gt;How OrderServ achieved up to 64% cost savings with multi-tenant ECS&lt;/a&gt; — Chetan Yewale, Ashwini Kumar, Asit Singh, Rama Krishna Sanjeeva, Suddhasattwa Mukherjee y Urvashi Sharma, AWS Architecture Blog, 5 de noviembre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://aws.amazon.com/blogs/containers/aws-nitro-sandboxes-hardware-enforced-workload-isolation-on-amazon-eks/" rel="noopener noreferrer"&gt;AWS Nitro Sandboxes: Hardware-enforced workload isolation on Amazon EKS&lt;/a&gt; — Carlos Santana y Trishi Mehta, AWS Containers Blog, 9 de noviembre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://aws.amazon.com/blogs/architecture/building-hybrid-multi-tenant-architecture-for-stateful-services-on-aws/" rel="noopener noreferrer"&gt;Building hybrid multi-tenant architecture for stateful services on AWS&lt;/a&gt; — Vasu Raj, AWS Architecture Blog, 12 de mayo de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://docs.aws.amazon.com/wellarchitected/latest/saas-lens/saas-lens.html" rel="noopener noreferrer"&gt;AWS Well-Architected SaaS Lens&lt;/a&gt; — AWS.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://docs.aws.amazon.com/whitepapers/latest/disaster-recovery-workloads-on-aws/disaster-recovery-workloads-on-aws.html" rel="noopener noreferrer"&gt;Disaster Recovery of Workloads on AWS&lt;/a&gt; — whitepaper de AWS.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://opentofu.org/docs/" rel="noopener noreferrer"&gt;OpenTofu&lt;/a&gt; y &lt;a href="https://developer.hashicorp.com/terraform/docs" rel="noopener noreferrer"&gt;Terraform&lt;/a&gt; — documentación oficial.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://kubernetes.io/docs/concepts/security/multi-tenancy/" rel="noopener noreferrer"&gt;Kubernetes: Multi-tenancy&lt;/a&gt; — documentación oficial.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://docs.oracle.com/en-us/iaas/disaster-recovery/index.html" rel="noopener noreferrer"&gt;OCI Full Stack Disaster Recovery&lt;/a&gt; — documentación de Oracle Cloud Infrastructure.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;Criterio práctico: elegí la frontera de aislamiento por riesgo y no por costo, reconstruí la plataforma desde código y vigilá el drift, y no creas en un RTO que no viste cumplirse en un ejercicio con el Identity Provider adentro.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>cloud</category>
      <category>architecture</category>
      <category>infrastructure</category>
      <category>spanish</category>
    </item>
    <item>
      <title>Escribimos código más rápido. ¿Desarrollamos mejor software? DevEx, IA y Platform Engineering</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:06:03 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/escribimos-codigo-mas-rapido-desarrollamos-mejor-software-devex-ia-y-platform-engineering-l34</link>
      <guid>https://dev.to/julian_cardozo_dev/escribimos-codigo-mas-rapido-desarrollamos-mejor-software-devex-ia-y-platform-engineering-l34</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/developer-experience-ia-friccion-plataforma/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;El State of Developer Experience 2026 de Atlassian dejó un dato que vale la pena mirar despacio: el 87% de los desarrolladores dice que la IA le permite entregar trabajo más rápido, pero solo el 28% percibe una reducción notable de la fricción en su día a día. Escribimos código más rápido. Eso no significa que estemos desarrollando mejor software. Para quienes lideramos equipos de ingeniería, esa brecha es el problema interesante: la IA aceleró la parte del trabajo que casi nunca era el cuello de botella.&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué dice el reporte, y qué no
&lt;/h2&gt;

&lt;p&gt;El reporte se publicó el 20 de octubre de 2026 y se basa en una encuesta a 1.155 desarrolladores y 405 líderes de ingeniería, según la cobertura de InfoQ. Los números que más se repiten:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;87%&lt;/strong&gt; dice que la IA lo ayuda a entregar más rápido; &lt;strong&gt;28%&lt;/strong&gt; reporta notablemente menos fricción que antes de la IA. Atlassian lo resume así: el &lt;strong&gt;72%&lt;/strong&gt; vive la misma fricción o más.&lt;/li&gt;
&lt;li&gt;La proporción que dice ahorrar &lt;strong&gt;10 horas o más por semana&lt;/strong&gt; con IA cayó del &lt;strong&gt;68%&lt;/strong&gt; en 2025 a alrededor de un cuarto en 2026 (Atlassian publica 25%; InfoQ, 26%).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;65%&lt;/strong&gt; pasa tiempo corrigiendo lo que produce la IA y &lt;strong&gt;49%&lt;/strong&gt; dedica cuatro horas o más por semana a gestionar herramientas de IA.&lt;/li&gt;
&lt;li&gt;Las mayores fuentes de fricción no son de código: &lt;strong&gt;encontrar información (51%)&lt;/strong&gt;, &lt;strong&gt;reuniones (50%)&lt;/strong&gt;, &lt;strong&gt;cambio de contexto entre herramientas (45%)&lt;/strong&gt; y &lt;strong&gt;deuda técnica (44%)&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;Solo &lt;strong&gt;17%&lt;/strong&gt; de los desarrolladores y &lt;strong&gt;23%&lt;/strong&gt; de los líderes dice que su organización tiene una estrategia de IA clara e implementada. Entre quienes sí la tienen, el &lt;strong&gt;41%&lt;/strong&gt; reporta menos fricción, contra el &lt;strong&gt;22%&lt;/strong&gt; donde la estrategia es inconsistente.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Con qué cuidado leerlo:&lt;/strong&gt; Es investigación de un proveedor, con datos autodeclarados y una muestra que cambió respecto de 2025: InfoQ lo señala explícitamente. Sirve como señal de dirección, no como benchmark para comparar tu equipo.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Aun con esa cautela, el patrón es consistente: la IA comprime el tiempo de escribir código, y la fricción se mueve hacia lo que rodea al código. Encontrar quién sabe algo, esperar una aprobación, entender una política de seguridad, revisar una salida generada. Ninguna de esas cosas se resuelve con un modelo más rápido.&lt;/p&gt;

&lt;h2&gt;
  
  
  La fricción cambió de lugar
&lt;/h2&gt;

&lt;p&gt;Un desarrollador no debería necesitar tres reuniones, dos tickets y conocer a la persona indicada para desplegar un servicio. Tampoco debería reconstruir un pipeline desde cero, configurar la observabilidad a mano o descubrir las políticas de seguridad recién cuando intenta llegar a producción.&lt;/p&gt;

&lt;p&gt;Cuando la escritura de código se acelera, esas esperas pesan más, no menos. Si antes un cambio tardaba dos días en escribirse y uno en aprobarse, la espera era un tercio del ciclo. Si ahora se escribe en dos horas, la misma aprobación es casi todo el ciclo. Es la teoría de restricciones aplicada a la ingeniería: optimizar fuera del cuello de botella no mejora el sistema.&lt;/p&gt;

&lt;p&gt;El Technology Radar Vol. 35 de Thoughtworks, publicado en noviembre de 2026, lo dice desde otro ángulo: pone en "Caution" usar el throughput de código como medida de productividad, y advierte que, con más agentes trabajando en paralelo, la capacidad de revisión se vuelve el cuello de botella y la supervisión puede degradarse en "human-in-the-loop theater".&lt;/p&gt;

&lt;h2&gt;
  
  
  Mejorar DevEx no es sumar herramientas: es eliminar fricción
&lt;/h2&gt;

&lt;p&gt;Ahí es donde Platform Engineering genera impacto. Una Internal Developer Platform (IDP) bien diseñada transforma dependencias entre personas en capacidades reutilizables, seguras y disponibles por autoservicio. Los Golden Paths hacen que el camino recomendado sea también el más sencillo. DevSecOps integra los controles desde el diseño, en lugar de descubrirlos en la última milla. Y la observabilidad permite que los equipos sigan siendo autónomos después del despliegue.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;De la fricción reportada a la capacidad de plataforma (propuesta, no receta)&lt;/em&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Fricción&lt;/th&gt;
&lt;th&gt;Cómo se ve en el día a día&lt;/th&gt;
&lt;th&gt;Capacidad de plataforma&lt;/th&gt;
&lt;th&gt;Señal de que mejora&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Encontrar información&lt;/td&gt;
&lt;td&gt;"¿Quién es dueño de este servicio?", documentación desactualizada&lt;/td&gt;
&lt;td&gt;Catálogo de servicios con dueños, docs junto al código, scorecards&lt;/td&gt;
&lt;td&gt;Menos preguntas repetidas en canales; tiempo de onboarding&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Esperas y aprobaciones&lt;/td&gt;
&lt;td&gt;Tickets para crear un ambiente, una base o un permiso&lt;/td&gt;
&lt;td&gt;Autoservicio con políticas como código y aprobación solo donde hay riesgo&lt;/td&gt;
&lt;td&gt;Lead time de solicitudes internas&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cambio de contexto&lt;/td&gt;
&lt;td&gt;Cinco consolas para desplegar y diagnosticar&lt;/td&gt;
&lt;td&gt;Golden Paths con pipeline, observabilidad y alertas incluidas&lt;/td&gt;
&lt;td&gt;Tiempo hasta el primer deploy de un servicio nuevo&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Seguridad tardía&lt;/td&gt;
&lt;td&gt;Hallazgos en la revisión final, retrabajo&lt;/td&gt;
&lt;td&gt;Controles DevSecOps en el template y en el pipeline&lt;/td&gt;
&lt;td&gt;Hallazgos encontrados antes del merge vs. después&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Corregir salida de IA&lt;/td&gt;
&lt;td&gt;Revisiones largas de cambios generados sin contexto&lt;/td&gt;
&lt;td&gt;Contexto del repositorio y reglas del equipo disponibles para agentes; checks automáticos&lt;/td&gt;
&lt;td&gt;Tasa de cambios generados que pasan revisión sin retrabajo&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  La plataforma es un producto, no un proyecto de infraestructura
&lt;/h2&gt;

&lt;p&gt;Lo más importante no es la herramienta, es el modelo de gestión. Una plataforma tratada como proyecto se entrega y se mantiene. Una plataforma tratada como producto tiene usuarios, discovery, un roadmap priorizado por valor y métricas de resultado.&lt;/p&gt;

&lt;p&gt;Eso implica escuchar a los desarrolladores, entender dónde pierden tiempo, priorizar lo que genera valor y medir resultados: no solo cuántos servicios se desplegaron, sino cuánto mejoró el onboarding, cuánto disminuyó el tiempo de espera y cuánta autonomía ganaron los equipos.&lt;/p&gt;

&lt;p&gt;El reporte deja una pista sobre qué no medir. Según el análisis de Network Perspective sobre los datos de Atlassian, el 60% de los desarrolladores dice que el uso de IA se trata como señal de productividad, y el 81% de los líderes reconoce que medir el uso puede crear incentivos equivocados. Medir cuánto se usa una herramienta es medir actividad, no resultado.&lt;/p&gt;

&lt;h3&gt;
  
  
  Métricas que conectan plataforma y negocio
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Onboarding&lt;/strong&gt;: tiempo hasta el primer deploy o hasta el décimo pull request de una persona nueva. Atlassian publicó, a partir de datos de su plataforma DX, que la mediana hasta el décimo PR bajó a 30 días en el segundo trimestre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tiempo de espera&lt;/strong&gt;: cuánto tarda una solicitud interna (ambiente, permiso, base) desde que se pide hasta que está disponible.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Autoservicio&lt;/strong&gt;: proporción de esas solicitudes que se resuelven sin intervención humana.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Entrega&lt;/strong&gt;: las métricas DORA (frecuencia de despliegue, lead time, tasa de fallas, tiempo de recuperación) como contexto, no como objetivo individual.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Percepción&lt;/strong&gt;: una encuesta breve y periódica sobre fricción. Si la plataforma es un producto, sus usuarios tienen que poder decir si les sirve.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  El segundo usuario de la plataforma: los agentes
&lt;/h2&gt;

&lt;p&gt;La IA agrega una dimensión nueva: las plataformas ahora también tienen que ofrecer contexto, políticas y mecanismos de control a agentes que participan en el ciclo de desarrollo. Las novedades de noviembre de 2026 muestran que la industria se está moviendo en esa dirección.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Red Hat Developer Hub 2.1&lt;/strong&gt; (anunciado en KubeCon NA, cubierto por SD Times el 10 de noviembre): expone contexto y acciones de la organización por MCP, por ejemplo disparar un Golden Path o revisar un problema de despliegue en Kubernetes, y suma un catálogo de modelos, agentes y servidores MCP. El argumento del anuncio: un agente sin contexto organizacional duplica servicios existentes y elige tecnologías no aprobadas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;"Platform Engineering after the AI Hype: Why IDPs Must Become Intent-Driven"&lt;/strong&gt; (Daniel Bryant, KubeCon NA, 10 de noviembre): sostiene que "agregar MCP" no alcanza. Identifica tres modos de falla (demasiada superficie expuesta, agentes "confidently wrong" y nadie dueño del día 2) y propone APIs basadas en intención para consumidores humanos y agentes. Una de sus preguntas para equipos de plataforma: ¿podría un agente usar tu plataforma sin conocimiento institucional?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Platform Engineering Day&lt;/strong&gt; (9 de noviembre, co-located de KubeCon NA en Salt Lake City): incluyó entre sus ejes los patrones emergentes para integrar IA en los flujos de plataforma.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Technology Radar Vol. 35&lt;/strong&gt; (Thoughtworks, noviembre): "harness engineering at scale" como tema central. El entorno que rodea a un agente (contexto, memoria, feedback, guardrails) madura como disciplina y necesita dueño.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Un artículo de DevOpsCon de octubre resume bien el riesgo: los Golden Paths diseñados para personas pueden volverse "golden cages" si se aplican sin cambios a agentes. Un agente no navega un portal; necesita acceso programático a capacidades, contexto confiable y controles que no dependan de que "se porte bien": identidad no humana, permisos acotados, observabilidad y controles deterministas (CI, políticas, aprobaciones) entre una salida probabilística y una acción con consecuencias.&lt;/p&gt;

&lt;p&gt;La buena noticia es que una plataforma pensada como producto ya tiene la mayoría de esas piezas: catálogo, políticas como código, templates y observabilidad. Lo que cambia es que pasa a tener dos tipos de usuario con necesidades distintas, y los dos merecen el mismo rigor.&lt;/p&gt;

&lt;h2&gt;
  
  
  Por dónde empezar
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Medir la fricción antes de comprar herramientas.&lt;/strong&gt; Una encuesta corta y entrevistas a personas nuevas en el equipo muestran dónde se pierde el tiempo con más precisión que cualquier dashboard de uso de IA.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Elegir un solo Golden Path de alto tráfico&lt;/strong&gt;, típicamente "crear un servicio y llevarlo a producción", y hacerlo completo: pipeline, observabilidad, seguridad y documentación incluidas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hacer que el camino sea legible para agentes&lt;/strong&gt;: el mismo template, el catálogo y las reglas del equipo accesibles de forma programática, con permisos acotados.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Medir resultado, no actividad&lt;/strong&gt;: tiempo de onboarding, tiempo de espera y proporción de autoservicio, revisados con los equipos que usan la plataforma.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escribir la estrategia de IA.&lt;/strong&gt; El dato del reporte que más me interesa es la diferencia entre 41% y 22%: la claridad organizacional también es una capacidad de plataforma.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Talento en el negocio, no en los obstáculos
&lt;/h2&gt;

&lt;p&gt;Para mí, una buena Developer Experience se resume en una idea: que los equipos puedan concentrar su talento en resolver problemas de negocio, en lugar de invertirlo en superar obstáculos internos. La IA hace más visible esa diferencia, porque acelera todo lo que ya estaba bien resuelto y deja expuesto todo lo que no.&lt;/p&gt;

&lt;p&gt;Y una pregunta abierta: ¿dónde encuentran hoy la mayor fricción en sus equipos: onboarding, CI/CD, infraestructura, documentación o procesos?&lt;/p&gt;

&lt;h3&gt;
  
  
  Novedades de noviembre de 2026
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://sdtimes.com/open-source/red-hat-advances-red-hat-developer-hub-as-an-agent-ready-enterprise-developer-portal/" rel="noopener noreferrer"&gt;Red Hat Advances Red Hat Developer Hub as an Agent-Ready Enterprise Developer Portal&lt;/a&gt; — David Rubinstein, SD Times, 10 de noviembre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://speakerdeck.com/danielbryantuk/kubecon-na-platform-engineering-after-the-ai-hype-why-idps-must-become-intent-driven-final-v1" rel="noopener noreferrer"&gt;Platform Engineering after the AI Hype: Why IDPs Must Become Intent-Driven&lt;/a&gt; — Daniel Bryant, KubeCon + CloudNativeCon NA, 10 de noviembre de 2026 (slides).&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://events.linuxfoundation.org/kubecon-cloudnativecon-north-america/co-located-events/platform-engineering-day/" rel="noopener noreferrer"&gt;Platform Engineering Day North America&lt;/a&gt; — Linux Foundation / CNCF, 9 de noviembre de 2026, Salt Lake City.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.thoughtworks.com/radar" rel="noopener noreferrer"&gt;Technology Radar Vol. 35&lt;/a&gt; — Thoughtworks, noviembre de 2026.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Referencias
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://www.atlassian.com/blog/development/developer-experience-report-2026" rel="noopener noreferrer"&gt;AI is making developers faster. It’s also exposing what’s broken in software delivery&lt;/a&gt; — Andrew Boyagi, Atlassian, 20 de octubre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.infoq.com/news/2026/10/atlassian-devex-2026/" rel="noopener noreferrer"&gt;Developers Reporting Double-Digit Weekly Time Savings from AI Fell from 68% to 26%&lt;/a&gt; — Steef-Jan Wiggers, InfoQ, 27 de octubre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.networkperspective.io/post/ai-developer-productivity-atlassian-2026-devex-report" rel="noopener noreferrer"&gt;What Atlassian’s 2026 DevEx Report Confirms (and Misses) About AI and Developer Productivity&lt;/a&gt; — Anita Zbieg, Network Perspective, 22 de octubre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://devopscon.io/blog/internal-developer-platforms-ai-agents/" rel="noopener noreferrer"&gt;What Happens to an Internal Developer Platform When AI Agents Start Using It?&lt;/a&gt; — Natalia Torres Behar, DevOpsCon, 22 de octubre de 2026.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.datadoghq.com/blog/golden-paths-for-ai-agents/" rel="noopener noreferrer"&gt;Golden Paths for AI agents: What changes when platform users aren’t human?&lt;/a&gt; — Candace Shamieh, Shlomo Benyaminov y James Eastham, Datadog, 25 de agosto de 2026.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;Criterio práctico: si la IA acelera la escritura de código pero la fricción no baja, el cuello de botella está en otro lado. Medí dónde se pierde el tiempo, construí la plataforma como producto para personas y agentes, y evaluá resultados, no uso de herramientas.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>leadership</category>
      <category>devops</category>
      <category>ai</category>
      <category>spanish</category>
    </item>
    <item>
      <title>AWS Cloud Practitioner — Field Notes: 6 conceptos para entender, no memorizar</title>
      <dc:creator>Julián Cardozo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 02:05:58 +0000</pubDate>
      <link>https://dev.to/julian_cardozo_dev/aws-cloud-practitioner-field-notes-6-conceptos-para-entender-no-memorizar-256o</link>
      <guid>https://dev.to/julian_cardozo_dev/aws-cloud-practitioner-field-notes-6-conceptos-para-entender-no-memorizar-256o</guid>
      <description>&lt;p&gt;&lt;em&gt;Publicado originalmente en &lt;a href="https://juliancardozo.github.io/blog/aws-cloud-practitioner-field-notes/" rel="noopener noreferrer"&gt;juliancardozo.github.io&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Estas son mis notas de preparación para AWS Certified Cloud Practitioner. No reemplazan la documentación de AWS: la resumen con la intención de entender cuándo y por qué usar cada cosa, no solo cómo se llama. Cada concepto se explica, se ejemplifica, se compara con lo que suele confundirse y se cierra con el error más frecuente y una pregunta para comprobar si realmente quedó claro.&lt;/p&gt;

&lt;h2&gt;
  
  
  Infraestructura global: Regiones, Availability Zones y Edge Locations
&lt;/h2&gt;

&lt;h2&gt;
  
  
  Networking: VPC, subred pública/privada, Internet Gateway y NAT Gateway
&lt;/h2&gt;

&lt;h2&gt;
  
  
  Modelo de responsabilidad compartida
&lt;/h2&gt;

&lt;h2&gt;
  
  
  EC2, Lambda y contenedores: cómo elegir
&lt;/h2&gt;

&lt;h2&gt;
  
  
  S3, EBS, EFS y las principales bases de datos
&lt;/h2&gt;

&lt;h2&gt;
  
  
  Costos, observabilidad y seguridad
&lt;/h2&gt;




&lt;p&gt;&lt;strong&gt;Learning is better when shared: si estas notas te sirven para el CLF-C02, descargá el PDF, compartilo con quien esté estudiando y contame qué concepto te costó más.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>cloud</category>
      <category>architecture</category>
      <category>infrastructure</category>
      <category>spanish</category>
    </item>
  </channel>
</rss>
