Claude Codificado por 24 Horas. Os Resultados São Surpreendentes.

O mais recente experimento de codificação da Anthropic soa como um desafio: conectar Claude a um "harness" de agente de longa duração, apertar o botão de iniciar e deixar que ele codifique por 24 horas seguidas. Sem café, sem pausas, apenas um modelo de IA trabalhando arduamente em uma enorme especificação de software enquanto você dorme. O objetivo: ver se um modelo moderno de codificação pode se comportar menos como um recurso de autocompletar e mais como uma incansável equipe de desenvolvedores juniores.

Tarefas longas geralmente quebram os agentes de IA de maneiras entediantes e previsíveis. Após algumas horas, eles sobrecarregam sua janela de contexto, esquecem decisões anteriores e ou alucinam estrutura ou simplesmente declaram o projeto "concluído" enquanto metade dos recursos existe apenas no comando. Ferramentas tradicionais reinicializam o estado, perdem o histórico de conversas e forçam os humanos a supervisionar cada grande reformulação.

A ferramenta de código aberto da Anthropic ataca esse modo de falha diretamente. Em vez de um único grande monólogo com o modelo, a ferramenta coordena múltiplos agentes, divide o trabalho em janelas de contexto separadas e persiste o estado no disco. Ela se baseia no desenvolvimento orientado a testes: define centenas de casos de teste e uma especificação detalhada do aplicativo antecipadamente, e então permite que os agentes iterem até que os testes finalmente sejam aprovados.

O experimento de Cole Medin leva esse sistema a um extremo: uma maratona de codificação de 24 horas para construir um clone funcional do próprio aplicativo web de Claude, completo com projetos, conversas, artefatos e uploads de arquivos. O sistema inicia um agente inicializador para gerar uma lista de recursos com aproximadamente 200+ casos de teste granulares, estrutura o projeto e configura o Git desde o início, de modo que cada mudança tenha um histórico. Depois disso, agentes de codificação se revezam por horas, implementando e corrigindo recursos com base nesses testes.

Enquadrado como um espetáculo do YouTube, isso ainda antecipa um futuro sério para a codificação agente. Agentes de IA de longa duração que silenciosamente constroem MVPs, protótipos de fundo e interfaces completas durante a noite podem comprimir semanas de configuração em um único dia de calendário. O truque de 24 horas apenas demonstra o que acontece quando você para de tratar a IA como uma caixa de bate-papo e começa a tratá-la como um processo.

A resistência, não o QI bruto, mata silenciosamente a maioria dos experimentos de codificação em IA. Agentes de longa duração desviam, sobrepõem seus próprios planos ou simplesmente “decidem” que terminaram assim que a janela de contexto fica cheia de código mal concebido e instruções vagas. A configuração da Anthropic ataca esse modo de falha diretamente: um arnês que lembra o que o agente não consegue.

Em vez de um novo agente inteligente, o harness atua como uma camada de coordenação envolta em sessões comuns de Claude Code. Ele rastreia arquivos, tarefas e resultados de testes ao longo de horas de execução, iniciando novas conversas sempre que uma thread se torna muito inchada para se manter coerente. Cada nova sessão começa com uma visão sintética do que é importante, e não com uma transcrição confusa de tudo o que veio antes.

Projetos massivos se transformam em listas de tarefas estruturadas. O processo começa a partir de uma especificação em texto simples ou PRD, e então se expande em uma lista de recursos com centenas de pequenos comportamentos testáveis. A execução de Cole Medin teve como alvo mais de 200 casos de teste para um clone no estilo Claude.ai, todos gerados previamente a partir daquela única especificação.

Essas funcionalidades não existem como pontos vagos. Elas se tornam objetos JSON com campos como descrição, arquivos afetados e critérios de aceitação específicos. O harness pode, então, selecionar uma funcionalidade de cada vez, fornecer o contexto relevante ao Claude e pedir para implementar ou corrigir apenas aquela parte do sistema.

Em vez de um mega-chat de 24 horas, o sistema executa dezenas ou centenas de "sprints" focados. Cada sprint é uma sessão de agente de curta duração com um objetivo específico: adicionar um componente, conectar uma chamada de API, fazer um teste passar. Quando a janela de contexto começa a ficar sobrecarregada, o sistema encerra essa sessão e inicia uma nova, com o estado atual do repositório e a lista de tarefas.

O estado vive em disco e no git, não na memória do modelo. O harness depende de: - A própria base de código - A lista de recursos em JSON - Um conjunto de testes crescente e logs

Ao externalizar o estado, o arnês transforma um agente instável e esquecível em algo que se comporta mais como um pipeline de construção determinístico—um que pode continuar codificando por 24 horas sem perder o foco.

A missão de 24 horas de Claude tinha um briefing brutalmente claro: reconstruir o aplicativo web Claude.ai do zero, sem copiloto humano, sem correções de course durante o processo. Não era um simples chat box, mas um clone funcional da interface que milhões de usuários acessam todos os dias. Mesmos fluxos principais, mesma sensação de polidez, rodando de ponta a ponta em um código escrito inteiramente por uma IA que nunca dorme.

Isso significa replicar toda a superfície de conversa. O agente teve que estabelecer uma gestão de conversas persistente com histórico de mensagens, tópicos de sidebar e roteamento adequado para diferentes projetos. Também precisou de envios de arquivos reais e anexos, não apenas referências—manipulando documentos, códigos e PDFs que fluem para o modelo e de volta como referências na interface do usuário.

Além disso, a especificação de Cole Medin exigia uma organização em nível de projeto e uma interface moderna e limpa. O clone precisava de: - Criação e troca de projetos - Conversas agrupadas por projeto - Suporte a "artefatos" ou saídas ricas - Um layout responsivo no estilo Claude, com um UX leve, e não com o Bootstrap bruto

Este é exatamente o tipo de coisa em que agentes de longa duração devem se destacar: uma mistura densa de trabalho em front-end com React ou Next.js, integração de API no back-end e código de ligação para manter o estado consistente. Isso força Claude a equilibrar roteamento, autenticação, persistência e estado da interface enquanto permanece alinhado com uma especificação de produto legível por humanos. Nenhum único comando pode cobrir isso; apenas um sistema que decomponha o trabalho e revisite o contexto repetidamente tem uma chance.

O próprio artigo da Anthropic Effective Harnesses for Long-Running Agents - Anthropic utiliza um clone no estilo Claude.ai como seu exemplo, completo com centenas de testes e um fluxo de trabalho multi-agente. No papel, o harness coordena agentes de inicialização e codificação, monta a estrutura necessária e passa por mais de 200 casos de teste até que o aplicativo seja aprovado. No YouTube, esse diagrama brilhante se transforma em uma pergunta brutal: esse mesmo arranjo pode realmente entregar um clone do Claude.ai em 24 horas sem edições humanas, ou o post do blog sutilmente se apoiou na afinação manual e capturas de tela selecionadas?

Esses interesses fazem deste mais do que um marco de novidade. Se um harness mais o Claude pode realmente construir um clone do Claude.ai próximo à produção de forma autônoma, isso sugere um futuro próximo onde "começar um novo aplicativo" significa escrever uma especificação, clicar em executar e voltar na manhã seguinte para um esqueleto de SaaS funcionando.

O Agente Inicializador atua como o arquiteto-chefe do projeto, mas sem ego e com paciência ilimitada. É o primeiro processo que o sistema da Anthropic inicia, e tudo que vem a seguir depende da qualidade do seu trabalho. Antes que qualquer funcionalidade seja codificada, esse agente estuda a especificação do aplicativo—o pseudo-PRD para o clone do Claude.ai—e a transforma em um plano totalmente estruturado.

Seu trabalho parece simples: “analisar requisitos e configurar o projeto.” Na prática, isso significa converter algumas páginas de texto em um plano que a máquina pode ler, que outros agentes podem seguir por 24 horas seguidas sem se desviar. Sem depuração, sem polimento de interface, sem refatoração—apenas configuração.

O harness força o Agente Inicializador a criar quatro artefatos essenciais que definem toda a construção:

• 1Um JSON de lista de recursos com mais de 200 casos de teste granulares.
• 2Um script de inicialização para iniciar o projeto
• 3Estrutura de código básica para o full stack
• 4Um repositório Git recém-inicializado

Essa lista de recursos em JSON faz o trabalho mais pesado de forma discreta. Ela explode a especificação do clone do Claude.ai em centenas de pequenos comportamentos verificáveis: iniciar uma nova conversa, fazer upload de um arquivo, trocar de projetos, renderizar artefatos, lidar com estados vazios e muito mais. Cada caso de teste se torna um alvo para agentes de codificação futuros, reforçando uma espécie de desenvolvimento orientado a testes nativo da IA.

O script de inicialização conecta o ambiente para que futuros agentes não desperdicem tokens reinventando etapas de configuração. Ele codifica decisões como escolha de framework, gerenciadores de pacotes e comandos de desenvolvimento—pense em `npm install`, inicializações de banco de dados e equivalentes de `npm run dev` capturados em um ponto de entrada reproduzível.

A estruturação oferece aos agentes de codificação um mapa da base de código antes mesmo de tocarem em um único componente. Você obtém diretórios pré-definidos para o frontend, backend, rotas da API e utilitários compartilhados, além de arquivos de exemplo que sugerem a arquitetura: roteamento, gerenciamento de estado e pontos de integração para o chat do Claude, artefatos e manipulação de arquivos.

O Git é a última peça não negociável. O Agente Inicializador cria um novo repositório, estabelecendo um histórico de versões desde a primeira linha, permitindo que agentes subsequentes comitem, comparem e revertam com segurança. Para sistemas de codificação agente de longa duração, esse histórico é a única coisa que impede uma sessão de 24 horas de colapsar em caos.

A codificação depende de seu principal responsável: o Agente de Codificação. Uma vez que o Agente Inicializador esboça o plano, este agente entra em um ciclo incessante, acordando com uma nova janela de contexto, relendo o estado do projeto e avançando pelas funcionalidades uma a uma. Sem conversas, sem brainstorming—apenas um ciclo de feedback rigoroso de testes, edições e commits.

No centro está uma rígida disciplina de desenvolvimento orientado a testes (TDD). Antes que uma única linha de código de produção seja alterada, o sistema já sabe como é o “pronto” através de uma extensa lista de recursos em JSON, frequentemente com mais de 200 casos de teste granulares. O trabalho do Agente de Codificação não é ser criativo; é fazer com que esses testes sejam aprovados.

Cada ciclo começa com o agente carregando um artefato de progresso: um arquivo estruturado que rastreia quais recursos existem, quais testes passam e o que quebrou recentemente. A partir daí, ele escolhe o próximo alvo - por exemplo, "suporte para o upload de múltiplos arquivos a um projeto" ou "renderizar o histórico de conversas com artefatos" - com base na prioridade e nas dependências. Essa escolha acontece dentro do prompt, mas o estado que a orienta reside no disco.

Antes de tocar na base de código, o agente executa o conjunto completo de testes de regressão. Isso significa que cada iteração começa por revalidar tudo o que foi construído até agora, capturando regressões imediatamente em vez de horas depois. Se um teste que anteriormente passava falhar, o agente se concentra em corrigir isso antes de adicionar qualquer novidade.

Somente após os testes de regressão serem concluídos com sucesso é que o agente implementa a nova funcionalidade. Ele edita arquivos de origem, atualiza componentes, ajusta manipuladores de API e conecta o comportamento da interface do usuário, tudo através da mesma interface da ferramenta. Em seguida, ele executa novamente os testes, iterando até que o novo caso seja aprovado ou até atingir um limite configurado de tentativas.

Quando a funcionalidade funciona, o sistema obriga o agente a externalizar sua memória. Ele atualiza o arquivo de progresso com detalhes: qual funcionalidade foi implementada, quais testes agora passam, limitações conhecidas e próximos passos lógicos. Este arquivo se torna um changelog compacto e legível por máquina para a próxima sessão.

Todo loop termina com um commit no Git. O harness trata o Git não como uma ideia secundária, mas como um substrato de memória fundamental: os diffs informam a próxima instância do Coding Agent exatamente o que mudou, as mensagens de commit resumem a intenção e o histórico protege contra erros catastróficos. Combinados com o arquivo de progresso, esses commits permitem que uma nova janela de contexto "lembre" 18 horas de trabalho sem precisar reler todo o código.

Ferramentas de linha de comando como o Claude Code parecem poderosas, mas este experimento de 24 horas contorna silenciosamente essas opções. Em vez de se conectar a um CLI, o sistema se comunica diretamente com Claude por meio do Claude Agents SDK em Python, tratando o modelo como um componente de software de primeira classe, em vez de um comando de terminal sofisticado.

O sistema da Anthropic gera agentes, agenda tarefas e inspeciona o estado do git completamente por meio de chamadas de SDK. O processo Python orquestra tudo: cria sessões, faz chamadas de ferramentas em tempo real, lê e escreve arquivos e até reinicia agentes quando eles travam. Nenhum humano digita `claude code` em um prompt uma vez que a execução começa.

O acesso direto ao SDK também transforma a escolha do modelo em um detalhe de configuração, em vez de uma reconstrução. O mesmo conjunto poderia chamar: - Claude Sonnet 4.5 para iterações econômicas - Claude Opus 4.5 para refatorações mais complexas - Modelos de terceiros como Code Llama ou programadores no estilo GPT através de APIs compatíveis

A troca de modelos se torna uma alteração de uma linha em um inicializador de cliente, não um novo fluxo de trabalho inteiro. O sistema já trata "Claude" como uma abstração: um agente de codificação com ferramentas, contexto e um contrato. Por trás disso, esse contrato pode apontar para qualquer modelo que fale JSON e respeite o protocolo.

É por isso que os SDKs parecem ser o verdadeiro futuro da codificação agentiva. As CLIs se destacam em correções rápidas ou depuração interativa; elas falham quando você precisa de um estado persistente, trabalhos em segundo plano ou coordenação entre agentes. Sistemas de longa duração como esse aproveitam ganchos programáticos para registro, tentativas, métricas e controles de segurança.

O próprio Guia Rápido de Programação Autônoma - Repositório GitHub da Anthropic incorpora essa suposição. O repositório é apenas Python, prompts e fiações em torno do Agents SDK, fazendo com que tudo pareça menos uma ferramenta de desenvolvimento e mais um microsserviço extensível para a criação de software.

Executar seu próprio codificador Claude 24 horas por dia começa com o sistema de código aberto da Anthropic disponível no GitHub. Acesse o guia rápido de codificação autônoma no repositório claude-quickstarts, especificamente no diretório `autonomous-coding`, e clone-o localmente. Você recebe uma estrutura pronta: prompts, conexão de agentes e scripts para iniciar agentes de codificação Claude que rodam por longos períodos.

A configuração parece mais próxima de configurar uma ferramenta de desenvolvimento do que de uma demonstração simples. Você instala as dependências (Python, Node e pacotes do projeto via `npm install` ou `pnpm install`), coloca suas variáveis de ambiente em um arquivo `.env` e aponta a estrutura para suas credenciais do Claude. O repositório vem com configurações de exemplo para a clone do Claude.ai, de modo que você pode principalmente ajustar em vez de inventar.

O controle de custos se torna o recurso matador não óbvio. Cole Medin destaca um truque crucial do vídeo: use um token de assinatura do Claude (o mesmo que seu navegador usa para o Claude Code) em vez de uma chave de API metrificada. Se você conectar isso a uma chave de pagamento por uso e deixar funcionando 24 horas, corre o risco de acordar com uma conta de três ou quatro dígitos.

Iniciar todo o processo se resume a um único comando a partir da raiz do repositório, algo como:

- `python main.py --app-spec=app_spec.txt`

Depois que você pressiona enter, nada emocionante acontece por 10 a 20 minutos. É o Agente Inicializador silenciosamente gerando mais de 200 casos de teste, organizando o projeto, escrevendo o script de inicialização e criando um repositório git antes que qualquer interface visual apareça.

Tudo vive ou morre no seu arquivo de especificação do aplicativo. O sistema da Anthropic espera um arquivo de texto estilo PRD brutalmente detalhado, descrevendo páginas, fluxos, casos extremos, papéis e requisitos não funcionais. Se você entregar um parágrafo vago sobre um "clone de aplicativo de chat", você receberá um produto vago.

Uma especificação robusta de aplicativo para um clone do Claude.ai se assemelha a algo que você entregaria a uma equipe humana: estrutura de URL, estados de conversa, limites de upload de arquivos, comportamento de artefatos, atalhos de teclado, mensagens de erro e até design de estados vazios. O Agente Inicializador detalha isso em testes granulares, de modo que cada sentença vaga em sua especificação se transforme em uma funcionalidade vaga ou ausente 12 horas depois.

À meia-noite, o comando é executado e o sistema muda silenciosamente de configuração para execução. O Agente Inicializador inicia sua primeira sessão, puxando a especificação do aplicativo, gerando o extenso feature_list.json com cerca de 200 casos de teste detalhados e configurando a estrutura inicial no estilo Next.js, além de um novo repositório git. Assim que cria esses artefatos, o controle é transferido para o verdadeiro trabalhador: o loop do Agente de Codificação.

Seu terminal deixa de parecer um console de desenvolvimento normal e começa a ser lido como um log de sistema ao vivo de um programador alienígena. Chamadas de ferramentas aparecem a cada poucos segundos: `read_file`, `write_file`, `run_tests`, `git diff`, `git commit`. Você observa diretórios como `app/`, `components/` e `lib/` se encherem com TypeScript, componentes React e manipuladores de rotas de API, todos criados por Claude sem que você precisasse dar prompts depois do primeiro `npm start`.

As linhas de saída se acumulam a um ritmo que nenhum humano conseguiria sustentar. Em um momento, o agente está criando uma barra lateral para projetos, no próximo está conectando threads de conversa, depois corrigindo um teste instável no painel de artefatos. O sistema mantém as sessões pequenas, rotacionando o contexto e iniciando novas execuções do Agente de Codificação, enquanto preserva o estado através do sistema de arquivos, histórico do git e a lista de recursos em JSON.

As mãos ficam longe do teclado por design. Sem botões de “aprovar”, sem tentativas manuais, sem ajustes de prompt no meio do caminho. Uma vez que você inicia `node run_harness.mjs`, o sistema controla as próximas 24 horas: planejamento, codificação, execução de testes e compromisso de código. A única atividade humana é observar a rolagem e ocasionalmente verificar as métricas do sistema para garantir que a máquina em si não derreta.

A segurança e a validação permeiam quase todas as ações. O harness envolve comandos de shell para bloquear qualquer coisa perigosa, restringe gravações de arquivos ao diretório do projeto e usa Puppeteer através de um servidor MCP para verificar visualmente o clone do Claude.ai em um navegador sem interface. O agente pode:

• 1Inicie o servidor de desenvolvimento
• 2Abra o localhost no Chromium.
• 3Clique através de projetos, conversas e envios de arquivos.
• 4Compare a interface renderizada com suas especificações e expectativas de teste.

Cada passagem do Puppeteer retroalimenta o ciclo como outro sinal: o aplicativo realmente se comportou ou o próximo commit precisa retirar e reescrever metade da interface?

Vinte e quatro horas e centenas de ciclos de agente depois, Claude emergiu com algo real: um aplicativo web funcional e completo no estilo Claude.ai. Não é um brinquedo, nem um protótipo estático, mas uma front end em React, um backend de API e um conjunto de testes conectados ao mesmo sistema que impulsionou a construção. Cole Medin navega por ele em vídeo como qualquer produto SaaS normal, porque funcionalmente, é isso que ele é.

Visualmente, o clone chega surpreendentemente perto. O layout da barra lateral, as conversas em chat, a lista de projetos e a estética geral do Claude aparecem: leve, clean e familiar. Você pode iniciar conversas, renomeá-las e vê-las sendo exibidas em um painel de histórico persistente.

A interação principal também funciona. O aplicativo envia mensagens para Claude, transmite respostas e preserva o contexto ao longo das trocas em uma conversa. O envio de arquivos funciona para casos de uso básicos, anexando documentos a um chat e exibindo-os na interface do usuário, embora casos extremos envolvendo arquivos grandes ou incomuns ainda causem problemas.

Os artefatos, a característica distintiva de "aplicativos inline" de Claude, chegam em forma parcial. O clone pode renderizar artefatos simples, exibi-los em um painel dedicado e mantê-los vinculados a uma conversa. Fluxos mais avançados—sessões com múltiplos artefatos, ferramentas complexas com estado ou edição de artefatos no local—ou falham silenciosamente ou se comportam de maneira inconsistente.

A gestão de projetos se posiciona em algum lugar no meio. O agente movido por harness implementa: - Criação e exclusão de projetos - Atribuição de conversas a projetos - Filtragem básica de chats por projeto

No entanto, operações em massa, pesquisa robusta e visualizações interprojetos continuam instáveis ou ausentes, frequentemente apresentadas como botões não implementados ou estados de interface inoperantes.

Nos bastidores, a estratégia guiada por testes vale a pena. De cerca de 200 testes gerados, uma grande maioria é aprovada ao final das 24 horas, com as falhas concentradas na polidez avançada de UX e no tratamento de erros obscuros. O sistema continua em execução até que o progresso se estabilize, não quando Claude fica "cansado" ou decide que está concluído.

Medin chama o arnês de “legítimo” em câmera, e não parece ser apenas uma hype. Ele enfatiza que esta não é uma engenharia de nível de produção ainda, mas como uma prova de que a codificação autônoma pode montar de forma autônoma um aplicativo web complexo e multifuncional em um dia, a demonstração é impactante. Juntamente com os avanços mais amplos da Anthropic em agentes de longa duração e modelos como o Claude Opus 4.5 detalhado em Introduzindo Claude Opus 4.5 - Anthropic, a conclusão é direta: esse fluxo de trabalho é inicial, mas já funciona.

Seu atual "programador par de IA" está prestes a parecer ultrapassado. Harnesses de longa duração, como o harness de código aberto da Anthropic, transformam modelos como o Claude de assistentes falantes em trabalhadores de fundo que silenciosamente analisam um acúmulo de tarefas por 24 horas ou mais, sem perder o foco no meio de uma reformulação.

Em vez de ficar monitorando uma janela de prompt, você pode entregar a um agente um PRD, um repositório e uma suíte de testes, e depois voltar a um protótipo funcional. O experimento de Cole Medin com o Claude mostra isso de forma concreta: uma instância Claude Code coordenada pelo harness cria uma interface no estilo do Claude.ai, conecta projetos e conversas, e passa por centenas de testes ao longo de um dia inteiro de computação.

Para os desenvolvedores, isso parece menos uma novidade e mais uma nova camada de infraestrutura. Pense nos agentes como: - Construtores de protótipos noturnos - Daemons de refatoração contínua - Bots de geração de testes e cobertura - Assistentes de documentação e migração

Dê a um desses sistemas 24 horas e uma lista de recursos em JSON com mais de 200 casos, e ele irá perseguir incansavelmente os checks verdes enquanto você dorme.

Nada disso parece estar “pronto para produção” ainda. O harness no repositório quickstart da Anthropic é experimental, frágil em relação a testes inconsistentes e propenso às mesmas alucinações de qualquer LLM. Mas as estratégias que ele codifica—promptings orientados por testes, critérios de sucesso rigorosos, Git como fonte da verdade, coordenação multi-agente—se traduzem diretamente em como você fortalece sistemas de IA no mundo real.

Você já pode incorporar esses padrões à sua pilha. Use um agente inicializador para gerar especificações, estruturação e testes; restrinja um agente de codificação a modificar apenas certos diretórios; conecte a CI para executar as mesmas verificações orientadas por harness antes da mesclagem. Cada passo faz com que seus ajudantes de IA sejam menos como preenchimento automático e mais como trabalhadores determinísticos ligados ao seu pipeline.

A engenharia agentiva mudará o que significa "escrever software". Engenheiros humanos definem arquiteturas, restrições e portões de revisão, enquanto frotas de agentes especializados lidam com implementação, testes e integração ao longo de dezenas de horas. O experimento do clone Claude é um esboço aproximado desse futuro: bases de código moldadas menos por toques de teclado e mais pela orquestração de legiões de colaboradores incansáveis e obcecados por testes.

O que é o Harness Antropocêntrico para agentes de longa duração?

É uma camada de coordenação de código aberto que permite que agentes de codificação de IA trabalhem em tarefas complexas por longos períodos (horas ou dias), gerenciando janelas de contexto e dividindo o trabalho em partes menores e testáveis.

Este arnês pode ser usado com modelos além do Claude?

Sim. O sistema é independente de modelo. Como é um sistema de prompts e arquivos de artefato, você pode trocar o Claude Code por outros modelos, como os da OpenAI ou alternativas de código aberto, adaptando o SDK do cliente.

Este sistema de codificação autônoma está pronto para uso em produção?

Não, ainda é altamente experimental. É mais apropriado para prototipagem rápida, geração de provas de conceito e exploração do futuro da engenharia agentiva, em vez de construir aplicativos prontos para produção.

Como o arnês evita as limitações da janela de contexto?

Ele cria uma nova e fresca janela de contexto para cada sessão do agente de codificação. O agente se atualiza em relação ao progresso lendo arquivos de artefato principais, como um resumo de progresso, uma lista de funcionalidades e a base de código existente, garantindo que só precisa do contexto relevante para a próxima tarefa granular.