Enquanto a IA reescrevia o curl em Rust, o projeto original recebeu 300 commits e 200 correções de bugs
Daniel Stenberg, autor do curl, comparou o ritmo das reescritas do projeto feitas por IA com o do trabalho normal de desenvolvimento. Em pouco mais de três semanas, agentes transformaram 185 mil linhas de C em 340 mil linhas de Rust. Nesse mesmo período, o curl de verdade recebeu mais de 300 commits, incluindo pouco mais de 200 correções de bugs. É como fazer um fork de uma biblioteca e deixar de receber os patches dela: os clones não têm essas correções. Ao escolher um clone gerado por IA no lugar de uma dependência madura, pergunte quem vai incorporar as correções.
Processado por IA de Simon Willison; editado por Hamidun News
Daniel Stenberg, criador e há muitos anos mantenedor do curl (programa e biblioteca de transferência de dados pela rede, embutidos em um número enorme de sistemas e dispositivos), comparou dois processos. No primeiro, agentes de IA reescreveram o curl de C para Rust: 185 mil linhas de C viraram 340 mil linhas de Rust. No segundo, a equipe real do curl simplesmente continuou trabalhando no original.
Imagine que você copiou uma biblioteca open source e deixou de receber as atualizações dela: em um mês, sua cópia não tem nenhuma correção nova. Foi mais ou menos isso que aconteceu com os clones do curl feitos por IA. Se você está avaliando trocar uma dependência madura por um clone rápido escrito por um agente, essa citação curta, destacada por Simon Willison, mostra bem o custo oculto da decisão.
O que exatamente Stenberg contou
Os dois processos correram em paralelo por pouco mais de três semanas. Nesse período, os agentes geraram 340 mil linhas de Rust a partir de 185 mil linhas de C. Segundo Stenberg, ele mesmo recontou as linhas. O código em Rust ficou quase duas vezes maior que o original, mas isso não mede qualidade: indica apenas a escala do que foi gerado.
No mesmo intervalo, o projeto curl de verdade recebeu mais de 300 commits. Pouco mais de 200 deles são correções de erros. Além disso, os mantenedores fecharam algumas vulnerabilidades. Stenberg ressalta que nenhuma das reescritas em Rust tem essas duzentas correções. Ele estima que, em um mês, surjam mais cerca de 200 correções de bugs e, possivelmente, mais algumas vulnerabilidades sejam fechadas. A pergunta com que ele encerra — “os clones conseguirão acompanhar?” — é retórica, mas vai ao ponto.
Por que portar o código é só o começo
Todo projeto maduro lembra uma casa antiga, em que cada detalhe estranho surgiu depois de algum defeito. Uma verificação a mais no código de rede provavelmente é o vestígio de um bug real: um servidor se comportou de forma fora do padrão, o cliente travou, alguém encontrou um jeito de atacar. Esse conhecimento não está na sintaxe, e sim no histórico de relatórios de bugs, discussões e testes acumulado ao longo dos anos.
Quando um agente reescreve o código, ele reproduz o comportamento que enxerga no código-fonte. Mas o original não fica parado: enquanto o clone é escrito, o projeto de verdade avança centenas de commits. Vira uma corrida em que quem está atrás precisa não só copiar o estado atual, mas também incorporar continuamente as novas correções.
Para a segurança, isso pesa ainda mais. Se uma vulnerabilidade foi corrigida no original e o clone não tem a correção, os usuários do clone continuam expostos, mesmo que a linguagem seja mais segura no trato com a memória.
O que isso significa na prática
Primeiro: não confunda o resultado da geração com um produto pronto. Um agente pode economizar semanas de trabalho manual de tradução de código, mas o critério de sucesso não é “compila e passa em parte dos testes”, e sim “o projeto recebe correções no mesmo ritmo do original”.
Segundo: se você planeja migrar para outra linguagem (com IA ou sem), decida antes quem vai manter o resultado. Uma migração pontual, sem equipe, sem rastreador de bugs e sem processo para lidar com vulnerabilidades, é um retrato de um momento, não uma base de código viva.
Terceiro: avalie um projeto pela dinâmica, não pelo volume de código. O número de commits, a rapidez de resposta a bugs e vulnerabilidades e a atividade dos mantenedores dizem mais sobre confiabilidade do que a quantidade de linhas na nova linguagem.
Há também limitações. É a opinião de uma só pessoa, e justamente a mais interessada no assunto. Ele fala de reescritas específicas do curl em Rust, não de qualquer migração feita com agentes, e não afirma que essas tentativas sejam inúteis. A citação também não mostra a qualidade do código gerado nem se os autores dos clones tentam trazer as correções do original. Mas a conta — 185 mil linhas contra 300 commits e 200 correções de bugs em três semanas — ilustra o principal risco: gerar código é barato, mas mantê-lo atualizado continua caro.
Para fundadores e gerentes de produto, a conclusão é simples. Se alguém propõe trocar uma dependência madura por um clone rápido gerado por IA, não pergunte “quão compatível ele é hoje”, e sim “quem vai corrigir os bugs daqui a seis meses”.
- 19 de nov. de 2026Nodul roda DeepSeek V4.1 Flash em 2 H200 em vez de 8 e acelera a geração para 36,4 tokens/s
- 19 de nov. de 202621 ferramentas open-source gratuitas para montar uma stack de agentes de IA
- 19 de nov. de 2026Base de conhecimento com RAG: 100 GB de arquivos viram 1,5 milhão de fragmentos e 9 horas de carga
- 19 de nov. de 2026O plano adicionou 11,6 p.p. de tarefas resolvidas ao modelo fraco, e o modelo forte se virou só com o terminal
Perguntas frequentes sobre a notícia
O que exatamente Stenberg contou?
Os dois processos correram em paralelo por pouco mais de três semanas. Nesse período, os agentes geraram 340 mil linhas de Rust a partir de 185 mil linhas de C. Segundo Stenberg, ele mesmo recontou as linhas. O código em Rust ficou quase duas vezes maior que o original, mas isso não mede qualidade: indica apenas a escala do que foi gerado. No mesmo intervalo, o projeto curl de verdade recebeu mais de 300 commits. Pouco mais de 200 deles são correções de erros.
Por que portar o código é só o começo?
Todo projeto maduro lembra uma casa antiga, em que cada detalhe estranho surgiu depois de algum defeito. Uma verificação a mais no código de rede provavelmente é o vestígio de um bug real: um servidor se comportou de forma fora do padrão, o cliente travou, alguém encontrou um jeito de atacar. Esse conhecimento não está na sintaxe, e sim no histórico de relatórios de bugs, discussões e testes acumulado ao longo dos anos. Quando um agente reescreve o código, ele reproduz o comportamento que enxerga no código-fonte.
O que isso significa na prática?
Primeiro: não confunda o resultado da geração com um produto pronto. Um agente pode economizar semanas de trabalho manual de tradução de código, mas o critério de sucesso não é “compila e passa em parte dos testes”, e sim “o projeto recebe correções no mesmo ritmo do original”. Segundo: se você planeja migrar para outra linguagem (com IA ou sem), decida antes quem vai manter o resultado.
Test Frontier LLMs & Autonomous Agents in One Workspace
Run Claude Opus 5.5, GPT-6, Gemini 3.1, and DeepSeek side-by-side in Nomad AI (nomadnet.ai) — unified model routing, deep research, and multimodal workflows under one subscription.
O essencial da IA — uma vez por semana
Sete histórias que realmente importaram, escolhidas a dedo. Sem ruído nem releases.
Pronto! Verifique seu e-mail para a confirmação.