Códigos de IA por 24 Horas. O Futuro está Aqui (e Imperfeito).

Cole Medin queria saber o que acontece quando você para de tratar a IA como um autocompletador de código e começa a tratá-la como um engenheiro júnior que nunca dorme. Então, ele ativou o novo "agente de longa duração" do Claude Code da Anthropic e fez uma IA trabalhar por 24 horas seguidas, sem pausas, sem botão de “terminei”. O resultado: um teste de estresse não do QI bruto do modelo, mas se sistemas agentes conseguem concluir um projeto de software real do início ao fim.

Em vez de pedir um aplicativo de lista de tarefas ou um único script em Python, Medin estabeleceu uma meta rigorosa: um clone funcional da web do claude.ai. Isso significa histórico de chat, fluxos de conversa, artefatos e uma interface de usuário responsiva que se comporte como o produto real, e não apenas uma página de aterrissagem estática. O objetivo era definir o sucesso como um aplicativo full-stack em funcionamento, e não apenas um trecho de código passageiro.

Medin estruturou o experimento em torno do desenvolvimento orientado a testes desde o início. Antes que a IA escrevesse uma linha de código, ele definiu testes automatizados de ponta a ponta que iniciam um servidor de desenvolvimento, lançam um navegador sem interface gráfica e clicam nos fluxos principais. O trabalho do agente: continuar editando o código até que esses testes sejam aprovados.

A estrutura de código aberto da Anthropic, que Medin retirou do GitHub, conecta tudo isso. Um agente “inicializador” define especificações, tarefas e suítes de testes, e então um agente de codificação edita repetidamente arquivos, executa testes e inspeciona falhas. Cada sessão se comporta como um mini sprint, e a estrutura agrupa dezenas desses sprints consecutivamente.

Em cerca de 24 horas, o sistema passou por mais de 50 sessões de codificação, envolvendo APIs de backend, componentes de frontend e fixtures de teste. Os testes no navegador atuaram como um juiz implacável: eles confirmavam se um recurso funcionava ou reencaminhavam o agente de volta para o editor. O progresso veio em explosões, enquanto a IA corrigia um fluxo com falha e, em seguida, enfrentava um novo caso limite de integração.

No final, um pouco mais da metade dos testes totais foram aprovados, o que foi suficiente para produzir uma interface reconhecível no estilo claude.ai, mas longe de ser uma cópia perfeita. O suporte demonstrou que "24 horas de IA" não se traduz magicamente em "SaaS pronto para produção", mas também provou que agentes modernos podem sustentar trabalhos de software não triviais e multilayer quando recebem estrutura, persistência e métricas rigorosas para o que está concluído.

O harness de código aberto da Anthropic transforma Claude de uma auto-completação falante em algo mais próximo de um engenheiro júnior que nunca tira folga. Em vez de um único comando e um bloco de código, o harness conecta Claude a uma estrutura que pode funcionar por horas, até dias, sem que alguém supervise cada passo.

No seu cerne, o harness impõe um ciclo: planejar → codificar → testar → refinar. Claude propõe uma alteração, edita arquivos, executa testes automatizados ou um servidor de desenvolvimento, inspeciona os resultados e, em seguida, decide o que fazer a seguir. Esse ciclo se repete dezenas de vezes, exatamente o que Cole Medin utiliza quando pede a Claude para buscar um clone do claude.ai por 24 horas consecutivas.

Os prompts de resposta única oferecem uma resposta definitiva com base em uma captura estática do contexto. Uma sessão de longo prazo e com estado continua acumulando o histórico do projeto: testes que falharam, diffs anteriores, decisões arquitetônicas, até mesmo comentários de TODO. Em mais de 50 sessões de codificação, o agente pode refatorar escolhas anteriores, desembaraçar regressões e seguir estratégias de múltiplos passos que seriam impossíveis em uma única janela de resposta.

O design da Anthropic divide isso em papéis distintos. Um agente inicializador é o primeiro a rodar, lendo o repositório, as especificações e os testes predefinidos, e então elaborando um plano de alto nível: pilha tecnológica, layout de diretório, marcos e quais testes definem "concluído". Ele pode até gerar ou refinar suítes de testes para que o sistema tenha um placar objetivo antes de escrever um código mais sério.

Uma vez que o inicializador prepara o cenário, um agente de codificação dedicado assume. Esse agente percorre tarefas concretas: criar componentes React, conectar rotas de API, ajustar esquemas de banco de dados ou corrigir um teste específico falho do Playwright. Cada iteração utiliza ferramentas disponibilizadas pela estrutura—comandos de edição de arquivos, executores de testes, verificações em navegadores headless—para fazer e verificar alterações.

Porque o harness persiste o estado no disco e o reintegra nos prompts, Claude pode raciocinar sobre as migrações de ontem ou aquele teste de UI frágil que continua falhando. A execução de 24 horas de Medin mostra o resultado: o harness não apenas gera código, mas orquestra uma negociação contínua entre plano e realidade, mensurada em testes bem-sucedidos em vez de demos bonitas.

Seus testes, não seus comandos, realmente impulsionaram essa ação de 24 horas. Cole Medin tratou o desenvolvimento orientado a testes (TDD) como o volante: defina o que “pronto” significa em código, e depois deixe Claude Code trabalhar até que a realidade corresponda à especificação. Sem vibrações, sem “parece bom para mim”, apenas vermelho ou verde.

Antes que o agente escrevesse uma única linha de interface, Cole preparou uma suíte de testes completa que capturava os fluxos principais do claude.ai. O sistema conhecia a criação de conversas, o histórico de mensagens e artefatos como requisitos explícitos, e não como metas vagas. O sucesso significava que aqueles testes passavam, ou o agente continuava funcionando.

Esse conjunto de testes atuou como um contrato entre o humano e o agente. Em vez de gerenciar cada componente de forma minuciosa, Cole apenas disse: aqui estão os comportamentos, aqui estão as afirmações, atenda a elas. A autonomia do agente vivia inteiramente dentro desse contrato, com o suporte garantindo isso a cada execução.

O progresso deixou de ser subjetivo quase imediatamente. Após cada sessão de codificação, o sistema executava os testes e produzia um placar simples: X de Y testes aprovados, além de rastreamentos de pilha para as falhas. Ao longo de aproximadamente 50 sessões em 24 horas, esse número subiu de zero para “um pouco mais da metade” dos testes aprovados.

Os testes funcionavam como navegação e barreiras de proteção. Quando uma reestruturação quebrou um fluxo anterior, os testes vermelhos trouxeram o agente de volta, forçando-o a reconciliar o novo código com as antigas promessas. Esse ciclo de feedback substituiu a revisão de código manual por algo mais frio e confiável: verificações automatizadas.

Cole se apoiou fortemente em testes end-to-end que simulavam um usuário real em um navegador sem interface gráfica. Usando ferramentas como Playwright ou Puppeteer, o conjunto de testes realizava as seguintes ações: - Inicializar o servidor de desenvolvimento - Abrir uma instância do Chromium sem interface gráfica - Navegar pelo login, novo chat e criação de artefatos - Fazer verificações no conteúdo do DOM, chamadas de rede e estado persistido

Esses testes de navegador transformaram requisitos abstratos em etapas concretas: “clique neste botão”, “digite este prompt”, “espere este formato de resposta.” Quando falhavam, o agente via seletores exatos, mensagens de erro e valores esperados vs. valores reais, então corrigia o código e executava novamente o conjunto de testes.

No final, os testes realizados descreveram um clone parcial, mas real do claude.ai. Os testes fracassados mapearam precisamente comportamentos ausentes ou quebrados, sem decepções vagas.

O momento acontece quase imediatamente. Claude Code, conectado ao sistema de agentes de longa duração da Anthropic, inicia um novo projeto, instala dependências e estrutura um aplicativo full-stack antes que um humano consiga terminar de esboçar a arquitetura. Dentro da primeira hora, ele gera um front end em React, uma API backend básica e as conexões necessárias para executar testes de ponta a ponta em um servidor de desenvolvimento local.

O trabalho de UI é rápido e confiante. O agente recria um layout no estilo claude.ai: barra lateral para conversas, painel principal de chat e um painel de artefatos que pode renderizar blocos de código e texto formatado. Ele esboça componentes para bolhas de mensagens, áreas de entrada e listas de conversas, em seguida, conecta-os a dados de espaço reservado para que a interface pareça viva mesmo antes que a lógica real seja implementada.

Porque Cole Medin realiza uma bateria de verificações TDD logo no início, o progresso tem um placar. Os testes iniciais cobrem os fundamentos: o aplicativo inicia sem travar, a visualização do chat é renderizada, as mensagens são exibidas na ordem correta e o roteamento básico funciona. Claude passa por estes como um engenheiro sênior em um sprint de campo verde, frequentemente corrigindo testes com falha em uma única iteração.

A seguir, o encanamento de baixo nível. O agente conecta rotas da API para criar conversas, postar mensagens e buscar histórico, e então atualiza a interface para chamá-las. Tipos TypeScript, tratamento de erros simples e configuração de ambiente aparecem sem aviso, um efeito colateral do suporte que está constantemente reexecutando testes e revelando rastros de pilha.

Durante essa janela de "frutos fáceis", o sistema parece estranhamente mágico. Você observa os commits se acumularem: novos componentes, ajustes em CSS, funções utilitárias, arquivos de teste. Cada teste verde desbloqueia a próxima camada de ambição—fluxos de múltiplas mensagens, estados de carregamento, renderização de artefatos básicos—sem que uma pessoa toque no teclado.

Por algumas horas, o fator limitante não é a inteligência, mas a entrada/saída. O agente espera pelo `npm install`, testes de navegador e reinicializações do servidor de desenvolvimento mais do que espera por ideias, passando rapidamente pelos 30–40% mais fáceis da suíte de testes antes que o trabalho se torne realmente difícil.

O impulso não falha com um colapso; ele se esgota em repetição. Após cerca de uma dúzia de horas e dezenas de sessões com agentes, o clone de Claude.ai de Cole Medin para de avançar e começa a andar em círculos. Novos commits ainda chegam, mas eles, na maioria das vezes, reorganizam a lógica existente, ajustam seletores ou renomeiam componentes sem desbloquear novos testes aprovados.

A complexidade deixa de ser local e se torna sistêmica. O agente agora lida com problemas multifásicos: fluxos de navegador que dependem do estado de autenticação, tópicos de conversa que precisam persistir entre recargas e renderização de artefatos que envolvem APIs de backend, roteamento de front-end e estado da interface. Cada mudança corrige um caso particular enquanto silenciosamente quebra outros dois.

Testes instáveis tornam-se o principal antagonista. Verificações com navegador sem cabeça ocasionalmente falham devido a condições de corrida, problemas de temporização ou pequenas diferenças no DOM. O sistema se dedica a tratar cada teste vermelho como um verdadeiro bug, de modo que o agente passa execução após execução perseguindo falhas não determinísticas que um humano rapidamente classificaria como “teste ruim, não aplicativo.”

Você pode ver o platô nos números. Após 24 horas, o sistema de monitoramento reporta um pouco mais da metade dos testes de ponta a ponta passando—impressionante para um sistema automatizado, mas um teto rígido em vez de uma curva suave. As primeiras horas eliminam as vitórias óbvias; nas horas seguintes, enfrenta-se os testes de integração que capturam a nuance do produto, não apenas a correção da sintaxe.

À medida que as tarefas se tornam mais nebulosas, a intuição arquitetônica começa a ser importante e o agente não possui nenhuma. Ele pode refatorar componentes React, reorganizar manipuladores de API e ajustar tipos TypeScript, mas carece de um modelo mental forte do aplicativo no estilo claude.ai como um todo. Quando os fluxos do navegador não se alinham com as suposições do backend, o agente reage localmente em vez de redesenhar o fluxo.

Engenheiros seniores lidam com essa fase afastando-se e mudando a forma do sistema. Eles: - Colapsam abstrações falhas - Introduzem limites mais claros entre UI, estado e API - Reescrevem testes frágeis que codificam o contrato errado

O agente não faz nada disso por conta própria. Ele trata cada falha como um defeito corrigível, não como um sinal de que a arquitetura ou a suíte de testes precisa ser repensada. Isso o torna um implementador poderoso—um desenvolvedor júnior incansável que nunca para de codificar—mas não a pessoa que você quer decidindo como seu aplicativo deve realmente funcionar.

Este patamar, mais do que a demonstração chamativa da primeira hora, mostra onde a codificação autônoma de ponta realmente se encontra: brilhante na execução, ainda ingênua no design.

Ao final da 24ª hora, o experimento de Cole Medin terminou com uma métrica muito pouco "Silicon Valley": apenas "um pouco mais da metade" dos testes automatizados passaram. Sem volta por cima, sem um clone polido do claude.ai, apenas um sistema silenciosamente relatando que aproximadamente 50-60% de suas próprias especificações haviam sido atendidas.

De outra forma, um agente de codificação de IA em sua maioria não supervisionado passou um dia inteiro trabalhando em um aplicativo real de full-stack e entregou algo que realmente funciona, roteia e renderiza. Para um sistema que requer pouco ou nenhum envolvimento, isso é um progresso impressionante em comparação com a era do "aplicativo CRUD de brinquedo em um comando", mas ainda fica bem aquém do software de nível de produção.

Os testes realizados se agruparam em torno do que os modelos atuais se destacam: estrutura, padrões e fluxos previsíveis. As verificações de renderização de UI, layout de componentes, navegação básica e endpoints de API simples, na maioria, passaram, pois se encaixam perfeitamente em padrões que os grandes modelos de linguagem já conhecem.

Falhas se acumularam onde vivia um estado bagunçado e interconectado. A complexa interconexão de conversas, regras de ciclo de vida de artefatos, fluxos de múltiplas etapas e o tratamento de erros em casos extremos resultaram em um cemitério de testes com falhas, expondo quão frágil o refatoramento autônomo se torna quando cada mudança pode quebrar três outros subsistemas. O agente frequentemente consertava um teste com falha apenas para ressuscitar um anterior.

O harness da Cole dependia fortemente de testes de ponta a ponta baseados em navegador, criando um ambiente headless e interagindo com a interface falsa do claude.ai. Esses testes validavam comportamentos reais—botões, modais, chamadas de rede—em vez de apenas assinaturas de funções, o que tornava cada teste aprovado mais significativo e cada teste falho mais difícil de contornar.

Em termos de custo, o sistema se comportou menos como um fluxo infinito de tokens e mais como um servidor de CI limitado pela CPU. Execuções de testes no mundo real, e não o comprimento do prompt, dominaram o tempo real, permitindo que você realizasse dezenas de iterações completas sem ultrapassar o território absurdo de um milhão de tokens por hora.

Esse trade-off expõe uma limitação importante para agentes de longa duração: a latência em tempo real cria um limite natural para a queima de tokens, mas também limita quantas vezes o sistema pode explorar, falhar e se recuperar. Não se pode simplesmente “escalar para mais tokens” e esperar que os 40% restantes dos testes—muitas vezes os casos de integração mais complicados—caiam como dominós.

Agentes de código não precisam de vibrações, eles precisam de testes. A maratona de 24 horas de Claude Code de Cole Medin permaneceu sã somente porque todo comportamento importante para o clone claude.ai existia primeiro como verificações automatizadas. O trabalho do agente não era "construir um aplicativo", mas "fazer esses testes ficarem verdes", o que transformou um pedido vago em um contrato concreto.

Aquele conjunto de testes funcionava como trilhos para um sistema, de outra forma, estocástico. Cada ciclo de codificação era igual: propor edições, executar a suíte de testes, inspecionar falhas, repetir. Ao longo de mais de 50 sessões, esse ritmo criou algo raro em experimentos de codificação de IA: progresso repetível em vez de uma pilha de códigos não relacionados.

TDD também forneceu ao agente uma armadura contra regressões. Quando Claude refatorou o front end em React ou reestruturou os manipuladores de API, o harness reexecutou imediatamente os testes de ponta a ponta no navegador que navegavam por conversas, artefatos e fluxos de barra lateral. Se um "conserto" quebrasse o histórico de mensagens ou a renderização de artefatos, um teste vermelho puxava o agente de volta antes que o bug se espalhasse.

Essa rede de segurança incentivou mudanças agressivamente arriscadas que você nunca confiaria em um fluxo de trabalho puramente "prompt-and-ship". O agente poderia remover componentes inteiros, reorganizar rotas ou renomear estruturas de dados porque os testes preservavam o comportamento. A intenção residia nas asserções; a implementação se tornou um detalhe intercambiável que o modelo poderia continuar embaralhando.

TDD também separou de forma clara intenção de implementação, o que se alinha quase perfeitamente à forma como os LLMs operam. Engenheiros humanos codificaram as expectativas do produto como testes Jest e Playwright: “Quando envio uma mensagem, ela aparece na conversa”, “Artefatos abrem em um painel com metadados.” Claude só precisou pesquisar no código maneiras de satisfazer essas afirmações.

Essa externalização é importante porque os modelos criam requisitos fictícios quando as solicitações permanecem em um nível abstrato. Aqui, a intenção existia fora da janela de contexto do modelo, registrada no disco como código. Mesmo depois de milhares de tokens e dezenas de chamadas de ferramentas, a verdade fundamental para “concluído” permaneceu a mesma: passar no conjunto de testes, e não agradar o solicitante.

Compare isso ao usual código solicitar e torcer que as pessoas tentam em interfaces de chat. Você cola uma especificação confusa, recebe um bloco de TypeScript, dá uma olhada e, então, descobre três solicitações depois que uma "pequena alteração" quebrou silenciosamente a autenticação ou o gerenciamento de estado. Sem verificações de regressão automatizadas, sem um alvo estável, apenas intuições e cliques manuais.

O experimento de Medin torna a troca óbvia. TDD estruturado mais um ambiente de testes produziu um aplicativo no estilo claude.ai com mais da metade dos testes passando após 24 horas. Fluxos de trabalho baseados apenas em prompts raramente sobrevivem 24 minutos sem colapsar em códigos inconsistentes e irreproduzíveis.

O esforço humano no experimento de 24 horas de Cole Medin não foi investido em escrever componentes React ou ajustar classes Tailwind. Foi direcionado para definir o sistema que a IA habitava: a estrutura do repositório, o conjunto de funcionalidades no estilo do claude.ai e as regras de engajamento que o agente tinha que seguir. Uma vez que essa estrutura existiu, o Claude Code tornou-se mais como um contratado muito rápido e muito literal do que um colega.

As movimentações mais alavancadas de Medin ocorreram antes da primeira linha de código escrita por IA. Ele escolheu a pilha de tecnologia, conectou o harness de longa duração do repositório GitHub da Anthropic e decidiu que "pronto" significava passar uma série de testes automatizados. Essa base ditou tudo o que o agente poderia e não poderia fazer ao longo dessas 24 horas.

O próprio sistema de harness codificou efetivamente uma nova descrição de trabalho para os humanos. Um agente “inicializador” definia especificações, tarefas e testes; um “agente de codificação” iterava sobre a base de código, executava a suíte e buscava marcações verdes. O papel de Medin era projetar esse ciclo, não micromanipular cada função ou regra de CSS.

Os futuros desenvolvedores que prosperarão neste mundo vão se concentrar na definição de problemas, não na sintaxe. Eles irão definir:

• 1O espaço do problema: o que o aplicativo deve fazer, quais fluxos são importantes e quais casos extremos devem ser considerados.
• 2As restrições: escolhas de stack, orçamentos de desempenho, regras de segurança, pontos de integração.
• 3Os critérios de sucesso: testes de ponta a ponta, limites de aceitação e comportamentos não negociáveis.

Essas decisões moldaram o motivo pelo qual Claude conseguiu fazer “um pouco mais da metade” dos testes passarem e também por que parou por aí. Testes ausentes ou ambíguos significavam que o agente não tinha incentivo para corrigir certos bugs de integração. Objetivos excessivamente amplos o deixavam lutando em fluxos complexos de interface em vez de priorizar a funcionalidade central.

O valor se desloca para a engenharia do próprio harness: os prompts, ferramentas e sinais de feedback que mantêm os agentes direcionados para a colina certa. Isso inclui escrever suítes de testes rigorosas, projetar a observabilidade em torno das execuções dos agentes e decidir quando redefinir o contexto ou refatorar a especificação. Os humanos se tornam arquitetos de IA, responsáveis pelo projeto e pela fita métrica, enquanto o modelo lida com a drywall e a fiação.

A codificação agentiva não vive mais apenas em artigos de pesquisa e vídeos de demonstração. O desafio de 24 horas de Cole Medin coloca o harness de agente da Anthropic diretamente na mesma conversa que GitHub Copilot, Codeium e Replit Ghostwriter — exceto que este recurso não apenas completa automaticamente uma função, mas executa um ciclo de desenvolvimento de software inteiro por conta própria. O sistema estrutura um clone do claude.ai, conecta fluxos de interface do usuário e testa de ponta a ponta durante todo um dia.

Esse salto de “autocomplete inteligente” para “trabalhador persistente” é a verdadeira história. Ferramentas como o GitHub Copilot funcionam no nível das teclas: elas preveem a próxima linha, talvez o próximo bloco. A configuração de Medin opera no nível da tarefa: “implementar artefatos, organizar conversas, satisfazer esses 40+ testes”, e então passar por dezenas de sessões de agentes até que a realidade corresponda à especificação—pelo menos até a metade.

Os frameworks de agentes costumavam parecer brinquedos exclusivos da DeepMind, escondidos atrás de pilhas de orquestração interna. O claude-code-harness de código aberto da Anthropic inverte essa dinâmica. Um desenvolvedor solo agora pode criar: - Um agente inicializador que define especificações e testes - Um agente de codificação que edita código e executa navegadores - Um ciclo de feedback que continua por mais de 50 sessões

Essa acessibilidade muda quem pode experimentar com agentes autônomos. Você não precisa mais de uma equipe de infraestrutura personalizada para executar ferramentas de longa duração que chamam CLIs, iniciam navegadores sem interface e gerenciam o estado do projeto. Você precisa de um repositório no GitHub, uma suíte de testes e um cartão de crédito.

Setores de atuação apontam para uma nova camada na pilha: “pipelines de construção de IA” que ficam ao lado de CI/CD. Copilotos de IDE ajudam os humanos a digitar mais rápido; agentes aproveitados executam roteiros, refatoram bases de código durante a noite ou se dedicam a testes de integração instáveis. A corrida de 24 horas de Medin parece bagunçada e incompleta, mas antecipa um futuro próximo em que toda organização de engenharia séria terá pelo menos um repositório onde o principal colaborador é um bot.

A maioria dos desenvolvedores não precisa de uma maratona de IA de 24 horas rodando em um painel tmux. A verdadeira melhoria vem da adoção dos hábitos agentes por trás da façanha de Cole Medin: codifique seus objetivos como testes, forneça ferramentas ao modelo e deixe-o trabalhar em um ciclo de feedback enquanto você supervisiona a nível de sistema.

Comece com um único recurso, não com uma clonagem completa do claude.ai. Escolha algo como "adicionar login via OAuth", "implementar importação de CSV" ou "construir uma página de configurações", e defina de 3 a 10 testes automatizados que descrevem "pronto" de forma mais precisa do que qualquer solicitação jamais fará.

Envolva esse recurso em um ciclo de teste e refinamento rigoroso. Peça ao seu AI de escolha para escrever a implementação, executar os testes e, em seguida, solicitá-lo que conserte o que falhar. Resista à tentação de consertar imediatamente; em vez disso, trate-se como o arquiteto que ajusta especificações, esclarece casos extremos e, ocasionalmente, reescreve uma função complicada.

Os próprios repositórios da Anthropic oferecem um ponto de partida concreto. O agente de longa duração que Cole utilizou está disponível em github.com/anthropics/claude-agentic-coding, e os exemplos mais amplos do Claude Code mostram como conectar a edição de arquivos, os executores de teste e a automação de navegador em um único loop.

Você não precisa copiar as mais de 50 sessões de codificação do Cole nem criar uma fazenda de navegadores headless no primeiro dia. Você pode obter 80% dos benefícios permitindo que um agente chame repetidamente `pytest`, `npm test` ou scripts do Playwright, e só intervir quando for óbvio que o desempenho estagnou ou começou a cair.

Uma receita prática de início é assim: - Escreva uma especificação curta e testes para um recurso - Dê ao IA seu repositório, a especificação e o comando de teste - Deixe-o iterar até que os testes passem ou o progresso estagne - Aprimore os testes, a arquitetura ou os prompts e repita

Usado dessa forma, o desenvolvimento orientado a agentes não te substitui; ele amplia seu alcance. Você pode tentar recursos que teria deixado de lado como "grandes demais para esta sprint", explorar refatorações mais ambiciosas e manter um padrão mais elevado de qualidade, pois os testes, e não sua paciência, o impõem.

O que é um harness para agente de IA?

Um agente de IA é uma estrutura que fornece a um modelo de IA ferramentas, memória e um loop estruturado (planejar, programar, testar, refinar) para executar tarefas complexas e de longa duração de forma autônoma, como codificar um aplicativo inteiro.

A IA conseguiu construir o aplicativo em 24 horas?

A IA fez progressos significativos, completando mais da metade dos testes necessários para um clone do claude.ai. No entanto, não finalizou completamente o projeto, destacando as limitações atuais dos agentes de IA em tarefas de integração complexas.

É uma maneira prática de construir software hoje?

Embora ainda seja experimental, a abordagem guiada por testes mostrada é altamente prática. Ela demonstra que definir o sucesso com testes automatizados permite que a IA funcione de forma mais confiável e produza melhores resultados do que simples solicitações de conversação.

Qual modelo de IA foi utilizado no experimento?

O experimento utilizou o modelo Claude Code da Anthropic, que é especificamente otimizado para tarefas de desenvolvimento de software, dentro de seu sistema de agente de código aberto de longa duração.