Códigos de IA por 24 Horas. El Futuro está Aquí (y es Defectuoso).

Cole Medin quería saber qué sucede cuando dejas de tratar a la IA como un autocompletado de código y comienzas a tratarla como un ingeniero junior que nunca duerme. Así que activó el nuevo "arnés de agente de larga duración Claude Code" de Anthropic y obligó a una IA a trabajar durante 24 horas continuas, sin descansos ni botón de “he terminado”. El resultado: una prueba de estrés no del cociente intelectual bruto del modelo, sino de si los sistemas agentes pueden llevar a cabo un proyecto de software real de principio a fin.

En lugar de pedir una aplicación de lista de tareas o un único script de Python, Medin estableció un objetivo brutal: un clon web funcional de claude.ai. Eso significa historial de chat, flujos de conversación, artefactos y una interfaz de usuario receptiva que se comporte como el producto real, no solo una página de aterrizaje estática. El marco definió el éxito como una aplicación completa y funcional, no un fragmento de código pasajero.

Medin estructuró el experimento en torno al desarrollo guiado por pruebas desde el principio. Antes de que la IA escribiera una línea de código, definió pruebas automatizadas de extremo a extremo que levantan un servidor de desarrollo, lanzan un navegador sin cabeza y navegan a través de los flujos principales. La tarea del agente: seguir editando el código hasta que esas pruebas se aprueben.

El arnés de código abierto de Anthropic, que Medin obtuvo de GitHub, une todo esto. Un agente "inicializador" establece especificaciones, tareas y suites de pruebas, luego un agente de codificación edita repetidamente archivos, ejecuta pruebas e inspecciona fallos. Cada sesión se comporta como un mini sprint, y el arnés encadena docenas de estos sprints uno tras otro.

Durante aproximadamente 24 horas, el sistema pasó por más de 50 sesiones de codificación, tocando APIs de backend, componentes de frontend y fixtures de prueba. Las pruebas en el navegador actuaron como un árbitro implacable: o confirmaban que una función funcionaba o obligaban al agente a regresar al editor. El progreso se produjo en ráfagas a medida que la IA solucionaba un flujo que fallaba y luego se encontraba con un nuevo caso límite de integración.

Al final, un poco más de la mitad de las pruebas totales pasaron, suficiente para producir una interfaz reconocible al estilo de claude.ai, pero lejos de ser un clon pixel-perfecto. El arnés demostró que "24 horas de IA" no equivalen mágicamente a "SaaS listo para producción", sin embargo, también probó que los agentes modernos pueden sostener trabajo de software no trivial y multicapa cuando se les brinda estructura, persistencia y métricas claras para lo que está terminado.

El arnés de agente de código abierto de Anthropic convierte a Claude de un autocompletador conversacional en algo más parecido a un ingeniero junior que nunca se desconecta. En lugar de un solo aviso y un bloque de código, el arnés conecta a Claude en una estructura que puede funcionar durante horas, e incluso días, sin que alguien supervise cada paso.

En su esencia, el arnés impone un ciclo: planificar → codificar → probar → refinar. Claude propone un cambio, edita archivos, ejecuta pruebas automatizadas o un servidor de desarrollo, inspecciona los resultados y luego decide qué hacer a continuación. Ese ciclo se repite docenas de veces, exactamente lo que Cole Medin utiliza cuando le pide a Claude que persiga un clon de claude.ai durante 24 horas seguidas.

Los prompts de una sola vez te ofrecen una respuesta definitiva basada en una instantánea estática de contexto. Una sesión de estado prolongado sigue acumulando el historial del proyecto: pruebas fallidas, diferencias anteriores, decisiones arquitectónicas, e incluso comentarios de TODO. En más de 50 sesiones de codificación, el agente puede refactorizar elecciones anteriores, deshacer regresiones y seguir estrategias de múltiples pasos que serían imposibles en una sola ventana de respuesta.

El diseño de Anthropic divide esto en roles distintos. Un agente inicializador se ejecuta primero, leyendo el repositorio, las especificaciones y las pruebas predefinidas, y luego redacta un plan de alto nivel: stack tecnológico, estructura de directorios, hitos y qué pruebas definen que está “listo”. Incluso puede generar o refinar conjuntos de pruebas para que el sistema tenga un marcador objetivo antes de escribir código serio.

Una vez que el inicializador establece el escenario, un agente de codificación dedicado toma el control. Ese agente recorre tareas concretas: crear componentes de React, conectar rutas de API, ajustar esquemas de base de datos o solucionar una prueba fallida específica de Playwright. Cada ciclo utiliza herramientas expuestas por el arnés: comandos de edición de archivos, ejecutores de pruebas, verificaciones en navegadores sin cabeza, para realizar y verificar cambios.

Debido a que el arnés persiste el estado en el disco y lo incorpora de nuevo en las indicaciones, Claude puede razonar sobre las migraciones de ayer o sobre esa prueba de interfaz de usuario frágil que sigue fallando. La ejecución de 24 horas de Medin muestra el resultado: el arnés no solo genera código, sino que orquesta una negociación continua entre el plan y la realidad, medida en pruebas aprobadas en lugar de demostraciones atractivas.

Tus pruebas, no tus solicitudes, realmente impulsaron esta hazaña de 24 horas. Cole Medin trató el desarrollo guiado por pruebas (TDD) como el volante: define lo que significa "hecho" en código, luego deja que Claude Code trabaje hasta que la realidad coincida con la especificación. Sin buenas vibras, sin "me parece bien", solo rojo o verde.

Antes de que el agente escribiera una sola línea de interfaz de usuario, Cole conectó un conjunto completo de pruebas que abarcaba los flujos principales de claude.ai. La infraestructura conocía la creación de conversaciones, el historial de mensajes y los artefactos como requisitos explícitos, no como metas vagues. El éxito significaba que esas pruebas pasaban, o el agente continuaba trabajando.

Ese conjunto de pruebas actuó como un contrato entre el humano y el agente. En lugar de micromanejar cada componente, Cole simplemente dijo: aquí están los comportamientos, aquí están las afirmaciones, cúmplelas. La autonomía del agente vivía enteramente dentro de ese contrato, con el arnés asegurando su cumplimiento en cada ejecución.

El progreso dejó de ser subjetivo casi de inmediato. Después de cada sesión de codificación, el arnés ejecutaba las pruebas y producía un marcador simple: X de Y pasadas, además de rastros de pila para las fallas. A lo largo de aproximadamente 50 sesiones en 24 horas, ese número avanzó de cero a "un poco más de la mitad" de las pruebas aprobadas.

Las pruebas funcionaron como navegación y barandillas. Cuando una reestructuración rompió un flujo anterior, las pruebas en rojo hicieron retroceder al agente, obligándolo a reconciliar el nuevo código con las promesas antiguas. Ese ciclo de retroalimentación sustituyó la revisión del código humano por algo más frío y fiable: las verificaciones automatizadas.

Cole se apoyó fuertemente en pruebas de extremo a extremo que simulaban un usuario real en un navegador sin cabeza. Usando herramientas como Playwright o Puppeteer, el entorno haría lo siguiente: - Iniciar el servidor de desarrollo - Abrir una instancia de Chromium sin cabeza - Navegar a través del inicio de sesión, nuevo chat y creación de artefactos - Verificar el contenido del DOM, llamadas de red y estado persistente

Esas pruebas del navegador convirtieron requisitos abstractos en pasos concretos: “haga clic en este botón”, “escriba este aviso”, “espere esta forma de respuesta”. Cuando fallaban, el agente veía selectores exactos, mensajes de error y valores esperados frente a los reales, luego corregía el código y volvía a ejecutar la suite.

Al final, las pruebas aprobadas describieron un clon de claude.ai parcial pero real. Las que fallaron se correlacionaron precisamente con comportamientos ausentes o rotos, no con desilusiones vagas.

El impulso surge casi de inmediato. Claude Code, conectado al sistema de agentes de larga duración de Anthropic, inicia un nuevo proyecto, instala dependencias y estructura una aplicación de pila completa antes de que un humano termine de esbozar la arquitectura. En la primera hora, genera un front end en React, una API básica de backend y la conexión necesaria para realizar pruebas de extremo a extremo contra un servidor de desarrollo local.

El trabajo de UI avanza rápido y con confianza. El agente recrea un diseño al estilo de claude.ai: una barra lateral para las conversaciones, un panel principal de chat y un panel de artefactos que puede renderizar bloques de código y texto con formato. Se esbozan componentes para burbujas de mensajes, áreas de entrada y listas de conversación, y luego se conectan a datos de marcador de posición para que la interfaz se sienta viva incluso antes de que la lógica real se implemente.

Debido a que Cole Medin realiza una serie de TDD en la fase inicial, el progreso cuenta con un marcador. Las pruebas tempranas abarcan los fundamentos: la aplicación se inicia sin bloquearse, la vista de chat se renderiza, los mensajes se muestran en orden y el enrutamiento básico funciona. Claude las aborda como un ingeniero senior en un sprint de campo nuevo, a menudo solucionando pruebas fallidas en una sola iteración.

Se sigue con la fontanería de bajo nivel. El agente conecta las rutas de la API para crear conversaciones, publicar mensajes y recuperar el historial, luego actualiza el front end para llamarlas. Los tipos de TypeScript, un manejo de errores simple y la configuración del entorno aparecen sin necesidad de ser solicitados, un efecto secundario de que la estructura esté ejecutando constantemente pruebas y mostrando trazas de pilas.

Durante esta ventana de "frutos al alcance de la mano", el sistema se asemeja inquietantemente a magia. Observas cómo se acumulan los commits: nuevos componentes, ajustes de CSS, funciones utilitarias, archivos de prueba. Cada prueba aprobada desbloquea la siguiente capa de ambición: flujos de múltiples mensajes, estados de carga, renderización de artefactos básicos—sin que un humano toque el teclado.

Durante unas pocas horas, el cuello de botella no es la inteligencia, sino la entrada y salida (I/O). El agente espera más en `npm install`, pruebas en el navegador y reinicios del servidor de desarrollo que en ideas, atravesando el fácil 30–40% de la suite de pruebas antes de que el trabajo se vuelva realmente difícil.

El impulso no falla con un colapso; se desvanece en la repetición. Después de aproximadamente una docena de horas y docenas de sesiones con agentes, el clon de Cole Medin en claude.ai deja de avanzar y comienza a dar vueltas en círculos. Nuevos commits siguen llegando, pero en su mayoría reordenan la lógica existente, ajustan los selectores o renombrar componentes sin desbloquear nuevas pruebas exitosas.

La complejidad deja de ser local y se convierte en sistémica. El agente ahora se enfrenta a problemas de múltiples saltos: flujos de navegador que dependen del estado de autenticación, hilos de conversación que deben persistir a través de recargas y renderización de artefactos que toca APIs de backend, enrutamiento del front-end y estado de la interfaz de usuario. Cada cambio soluciona un caso extremo mientras rompe silenciosamente otros dos.

Las pruebas inestables se convierten en el principal antagonista. Las verificaciones en navegadores sin cabeza ocasionalmente fallan debido a condiciones de carrera, problemas de temporización o diferencias menores en el DOM. El arnés trata fielmente cada prueba fallida como un verdadero error, por lo que el agente pasa corrida tras corrida persiguiendo fallas no deterministas que un humano rápidamente etiquetaría como "la prueba es mala, no la aplicación".

Puedes ver la meseta en los números. Después de 24 horas, el arnés informa que un poco más de la mitad de las pruebas de extremo a extremo están aprobadas; impresionante para un sistema automatizado, pero un techo duro en lugar de una curva suave. Las primeras horas eliminan las victorias obvias; las horas posteriores se enfrentan a pruebas de integración que codifican la sutileza del producto, no solo la corrección de la sintaxis.

A medida que las tareas se vuelven más difusas, la intuición arquitectónica comienza a importar y el agente no tiene ninguna. Puede refactorizar componentes de React, reorganizar controladores de API y ajustar tipos de TypeScript, pero carece de un modelo mental sólido de toda la aplicación al estilo de claude.ai. Cuando los flujos del navegador no se alinean con las suposiciones del backend, el agente reacciona localmente en lugar de rediseñar el flujo.

Los ingenieros senior manejan esta fase al dar un paso atrás y cambiar la forma del sistema. Ellos: - Colapsan abstracciones permeables - Introducen límites más claros entre la UI, el estado y la API - Reescriben pruebas frágiles que codifican el contrato incorrecto

El agente no hace nada de eso por su cuenta. Trata cada fallo como un defecto corregible, no como una señal de que la arquitectura o el conjunto de pruebas necesitan ser replanteados. Eso lo convierte en un implementador poderoso—un joven desarrollador incansable que nunca deja de codificar—pero no es la persona que deseas que decida cómo debería funcionar realmente tu aplicación.

Este plateau, más que la impresionante demostración de la primera hora, muestra dónde se encuentra realmente la codificación autónoma de vanguardia: brillante en la ejecución, aún ingenua en el diseño.

Al llegar a la hora 24, el experimento de Cole Medin terminó con una métrica muy poco propia de Silicon Valley: solo "un poco más de la mitad" de las pruebas automatizadas pasaron. Sin celebración, sin un clon pulido de claude.ai, solo un arnés que informaba silenciosamente que aproximadamente el 50-60% de sus propios requisitos se habían cumplido.

En otras palabras, un agente de codificación de IA mayormente no supervisado pasó todo un día trabajando en una verdadera aplicación de pila completa y envió algo que realmente funciona, enruta y renderiza. Para un sistema autónomo, es un avance sorprendente en comparación con la era de la "aplicación CRUD de juguete en un solo aviso", sin embargo, aún está muy lejos del software de calidad para producción.

Las pruebas aprobadas se agruparon en torno a lo que los modelos actuales sobresalen: estructura, plantillas y flujos predecibles. Las verificaciones de renderización de la interfaz, diseño de componentes, navegación básica y puntos finales de API simples en su mayoría mostraron resultados positivos, ya que se alinean claramente con patrones que los modelos de lenguaje grande ya conocen.

Los fracasos se acumulaban donde existía un estado desordenado e interconectado. La compleja creación de conversaciones, las reglas del ciclo de vida de los artefactos, los flujos de múltiples pasos y el manejo de errores en casos extremos producían un cementerio de pruebas fallidas, revelando cuán frágil se vuelve el refactorizado autónomo cuando cada cambio puede romper tres subsistemas diferentes. El agente a menudo solucionaba una prueba fallida solo para resucitar una anterior.

El arnés de Cole se basó en gran medida en pruebas de extremo a extremo basadas en navegador, iniciando un entorno sin cabeza y navegando a través de la interfaz falsa de claude.ai. Esas pruebas validaron un comportamiento real—botones, modales, llamadas de red—en lugar de solo firmas de funciones, lo que hizo que cada prueba aprobada fuera más significativa y cada falla más difícil de ignorar.

En términos de costos, el sistema se comportó menos como un chorro infinito de tokens y más como un servidor de CI limitado por la CPU. Las ejecuciones de prueba en el mundo real, no la longitud del aviso, dominaron el tiempo de reloj, por lo que obtuviste docenas de iteraciones completas sin cruzar en el territorio absurdo de un millón de tokens por hora.

Ese compromiso expone una limitación importante para los agentes de larga duración: la latencia en tiempo real crea un limitador natural en la quema de tokens, pero también limita cuántas veces el sistema puede explorar, fallar y recuperarse. No puedes simplemente "escalar a más tokens" y esperar que el restante 40 por ciento de las pruebas—frecuentemente los casos de integración más complicados—caigan como fichas de dominó.

Los agentes de código no necesitan buenas vibras, necesitan pruebas. El maratón de 24 horas de Claude Code de Cole Medin solo mantuvo su cordura porque cada comportamiento importante para el clon de claude.ai existió primero como verificaciones automatizadas. La tarea del agente no era “construir una aplicación”, sino “hacer que estas pruebas se aprobaran”, lo que convirtió un aviso vago en un contrato concreto.

Ese arnés de pruebas actuó como rieles para un sistema que, de otro modo, sería estocástico. Cada ciclo de codificación se veía igual: proponer ediciones, ejecutar la suite de pruebas, inspeccionar fallos, repetir. A lo largo de más de 50 sesiones, ese ritmo creó algo raro en los experimentos de codificación de IA: un progreso repetible en lugar de un montón de volcado de código sin relación.

TDD también le proporcionó al agente un blindaje contra regresiones. Cuando Claude reorganizó el front end de React o reconfiguró los controladores de API, el arnés inmediatamente volvió a ejecutar las pruebas de extremo a extremo en el navegador que recorrían conversaciones, artefactos y flujos de barra lateral. Si una "corrección" rompía el historial de mensajes o la representación de artefactos, una prueba fallida regresaba al agente antes de que el error se propagara.

Esa red de seguridad fomentaba cambios arriesgados y agresivos en los que nunca confiarías en un flujo de trabajo puramente de "solicitar y enviar". El agente podía eliminar componentes enteros, reorganizar rutas o renombrar estructuras de datos porque las pruebas preservaban el comportamiento. La intención residía en las afirmaciones; la implementación se convirtió en un detalle intercambiable que el modelo podía seguir reorganizando.

TDD también separó claramente la intención de la implementación, lo que se mapea casi perfectamente a cómo operan los LLMs. Los ingenieros humanos codificaron las expectativas del producto como pruebas de Jest y Playwright: "Cuando envío un mensaje, aparece en el hilo", "Los artefactos se abren en un panel con metadatos". Claude solo tuvo que buscar en la base de código maneras de satisfacer esas declaraciones.

Esa externalización importa porque los modelos alucinan requisitos cuando las indicaciones son de alto nivel. Aquí, la intención existía fuera de la ventana de contexto del modelo, fijada en el disco como código. Incluso después de miles de tokens y docenas de llamadas a herramientas, la verdad esencial para "terminado" seguía siendo la misma: pasar la suite, no complacer al que da la indicación.

Compáralo con el habitual código de pedir y esperar que la gente intenta en las interfaces de chat. Pega una especificación difusa, obtienes un bloque de TypeScript, lo miras de reojo y luego descubres, tres promociones después, que un "pequeño ajuste" rompió silenciosamente la autenticación o la gestión del estado. Sin controles de regresión automatizados, sin un objetivo estable, solo impresiones y clics manuales.

El experimento de Medin hace evidente la compensación. TDD estructurado más un arnés produjeron una aplicación al estilo claude.ai con más de la mitad de las pruebas aprobadas después de 24 horas. Los flujos de trabajo solo con prompts rara vez sobreviven 24 minutos sin colapsar en un código inconsistente e irreproducible.

El esfuerzo humano en el experimento de 24 horas de Cole Medin no se destinó a escribir componentes de React ni a ajustar clases de Tailwind. Se enfocó en definir el sistema que la IA habitaría: la estructura del repositorio, el conjunto de características al estilo de claude.ai y las reglas de interacción que el agente debía seguir. Una vez que ese andamiaje existió, Claude Code se convirtió más en un contratista muy rápido y muy literal que en un colega.

Los movimientos más apalancados de Medin ocurrieron antes de la primera línea de código escrito por IA. Él eligió la pila tecnológica, configuró el harness de larga duración del repositorio de GitHub de Anthropic y decidió que "terminado" significaba pasar una serie de pruebas automatizadas. Esa base dictó todo lo que el agente podía y no podía hacer durante esas 24 horas.

El arnés en sí mismo codificó efectivamente una nueva descripción de trabajo para los humanos. Un agente "iniciador" establecía especificaciones, tareas y pruebas; un agente "de codificación" iteraba en la base de código, ejecutaba la suite y perseguía marcas de verificación verdes. El papel de Medin era diseñar ese bucle, no micromanagear cada función o regla de CSS.

Los futuros desarrolladores que prosperen en este mundo se obsesionarán con la definición de problemas, no con la sintaxis. Definirán:

• 1El espacio de problema: lo que la aplicación debe hacer, cuáles flujos importan, qué casos extremos cuentan.
• 2Las limitaciones: opciones de pila, presupuestos de rendimiento, reglas de seguridad, puntos de integración.
• 3Los criterios de éxito: pruebas de extremo a extremo, umbrales de aceptación y comportamientos no negociables.

Esas decisiones moldearon por qué Claude pudo hacer pasar “un poco más de la mitad” de las pruebas y también por qué se estancó allí. Pruebas faltantes o ambiguas significaban que el agente no tenía incentivos para corregir ciertos errores de integración. Objetivos demasiado amplios lo dejaban atrapado en flujos de interfaz de usuario complejos en lugar de priorizar la funcionalidad central.

El valor se desplaza hacia la ingeniería del arnés en sí: los mensajes, herramientas y señales de retroalimentación que mantienen a los agentes enfocados en la colina correcta. Esto incluye escribir suites de pruebas rigurosas, diseñar la observabilidad en torno a las ejecuciones de los agentes y decidir cuándo restablecer el contexto o refactorizar la especificación. Los humanos se convierten en arquitectos de IA, responsables del plano y de la cinta métrica, mientras que el modelo se encarga del panel de yeso y del cableado.

La codificación de agentes ya no vive solo en artículos de investigación y demostraciones. El desafío de 24 horas de Cole Medin coloca el arnés de agente de Anthropic directamente en la misma conversación que GitHub Copilot, Codeium y Replit Ghostwriter—excepto que esta herramienta no solo autocompleta una función, sino que ejecuta un sprint de software completo por sí sola. El sistema construye un clon de claude.ai, ordena flujos de interfaz de usuario y trabaja en pruebas de extremo a extremo durante todo un día.

Ese salto de "autocompletado inteligente" a "trabajador persistente" es la verdadera historia. Herramientas como GitHub Copilot operan a nivel de pulsaciones: predicen la siguiente línea, tal vez el siguiente bloque. La configuración de Medin opera a nivel de tareas: “implementar artefactos, gestionar conversaciones, satisfacer estas 40+ pruebas”, luego avanzar a través de docenas de sesiones de agentes hasta que la realidad coincida con las especificaciones, al menos a mitad de camino.

Los marcos de agentes solían parecer juguetes exclusivos de DeepMind, ocultos detrás de pilas de orquestación internas. El claude-code-harness de Anthropic cambia esa dinámica. Ahora, un desarrollador individual puede crear: - Un agente inicializador que define especificaciones y pruebas - Un agente de codificación que edita código y ejecuta navegadores - Un bucle de retroalimentación que continúa durante más de 50 sesiones

Esa accesibilidad cambia quién puede experimentar con agentes autónomos. Ya no necesitas un equipo de infraestructura personalizado para ejecutar herramientas de larga duración que llaman a CLIs, inician navegadores sin cabeza y gestionan el estado del proyecto. Solo necesitas un repositorio de GitHub, un conjunto de pruebas y una tarjeta de crédito.

En términos de industria, esto apunta hacia una nueva capa en la pila: "canalizaciones de construcción de IA" que se sitúan junto a CI/CD. Los copilotos de IDE ayudan a los humanos a escribir más rápido; los agentes aprovechados ejecutan hojas de ruta, refactorizan bases de código durante la noche o se enfocan en pruebas de integración inestables. La ejecución de 24 horas de Medin parece desordenada e incompleta, pero adelanta un futuro cercano en el que cada organización de ingeniería seria tiene al menos un repositorio donde el principal contribuyente es un bot.

La mayoría de los desarrolladores no necesitan un maratón de IA de 24 horas corriendo en un panel de tmux. La verdadera mejora proviene de adoptar los hábitos agénticos detrás de la hazaña de Cole Medin: codifica tus objetivos como pruebas, proporciona al modelo herramientas y déjalo trabajar a través de un bucle de retroalimentación mientras supervisas a nivel de sistema.

Comienza con una sola característica, no con un clon completo de claude.ai. Elige algo como "agregar inicio de sesión OAuth", "implementar importación de CSV" o "crear una página de configuración", y define de 3 a 10 pruebas automatizadas que describan "listo" de manera más precisa de lo que cualquier indicación podría hacerlo.

Envuelve esa función en un ciclo de prueba y refinamiento. Haz que tu IA elegida escriba la implementación, ejecute las pruebas y luego pídele que corrija lo que falle. Resiste la tentación de realizar parches manuales de inmediato; en su lugar, considérate el arquitecto que ajusta las especificaciones, aclara los casos límite y, de vez en cuando, reescribe una función complicada.

Los propios repositorios de Anthropic te ofrecen un punto de partida concreto. El agente de larga duración que utilizó Cole se encuentra en github.com/anthropics/claude-agentic-coding, y los ejemplos más amplios de Claude Code muestran cómo conectar la edición de archivos, los ejecutores de pruebas y la automatización del navegador en un solo bucle.

No tienes que copiar las más de 50 sesiones de codificación de Cole ni crear una granja de navegadores sin cabeza en el primer día. Puedes obtener el 80% del beneficio permitiendo que un agente llame repetidamente a `pytest`, `npm test` o scripts de Playwright, y solo intervenir cuando evidentemente se estabilice o empiece a fallar.

Una receta práctica para comenzar se ve así: - Escribe una especificación breve y pruebas para una característica - Proporciona a la IA tu repositorio, la especificación y el comando de prueba - Deja que itere hasta que las pruebas pasen o el progreso se detenga - Refina las pruebas, la arquitectura o las indicaciones, y luego repite

Usado de esta manera, el desarrollo impulsado por agentes no te reemplaza; amplía tu alcance. Puedes intentar funcionalidades que habrías dejado de lado como "demasiado grandes para este sprint", explorar refactorizaciones más ambiciosas y mantener un estándar más alto de calidad porque las pruebas, y no tu paciencia, lo exigen.

¿Qué es un arnés de agente de IA?

Un arnés de agente de IA es un marco que proporciona a un modelo de IA herramientas, memoria y un bucle estructurado (planificar, codificar, probar, refinar) para realizar tareas complejas y de larga duración de manera autónoma, como codificar una aplicación completa.

¿La IA logró construir la aplicación en 24 horas?

La IA logró un progreso significativo, completando más de la mitad de las pruebas requeridas para un clon de claude.ai. Sin embargo, no completó del todo el proyecto, lo que resalta las limitaciones actuales de los agentes de IA en tareas de integración complejas.

¿Es esta una forma práctica de construir software hoy en día?

Aunque todavía es experimental, el enfoque basado en pruebas que se muestra es altamente práctico. Demuestra que definir el éxito con pruebas automatizadas permite que la IA funcione de manera más confiable y produzca mejores resultados que un simple impulso conversacional.

¿Qué modelo de IA se utilizó en el experimento?

El experimento utilizó el modelo Claude Code de Anthropic, que está específicamente optimizado para tareas de desarrollo de software, dentro de su arnés de agente de código abierto de larga duración.