Quando o mestre usa IA: Linus Torvalds e o coração do Linux.
· @Reisev
Um caso real que mostra o que a inteligência artificial pode fazer e por que ainda precisamos de gente capaz de conferir o resultado.
Quando um iniciante usa inteligência artificial para escrever um programa, é fácil entender a utilidade. Mas o que acontece quando quem recorre a ela é o próprio criador de um dos sistemas mais importantes do mundo?
Foi o que aconteceu com Linus Torvalds, criador do Linux. O Linux é um sistema operacional (o programa que faz o computador funcionar), presente em servidores, celulares Android e supercomputadores. Torvalds usou o Claude Code, uma ferramenta de IA da Anthropic para programar, para atacar um problema de desempenho que desafiava os desenvolvedores havia mais de dois anos. Ele próprio vinha testando, por cerca de 18 meses, uma solução sua que não funcionava direito.
Segundo os relatos, a IA escreveu o código, os testes e a primeira documentação, e também revisou o trabalho sob orientação dele. Torvalds rodou as medições por conta própria e deixou claro o que a ferramenta fez.
Uma biblioteca dentro do computador
Para entender o problema, precisamos conhecer uma pequena parte do Linux.
O kernel é o núcleo do sistema operacional, o "gerente" que distribui memória, processadores e dispositivos entre os programas.
Quando um programa pede dados de um arquivo, o kernel pode já tê-los guardados na memória RAM (a memória rápida e temporária do computador). Essa cópia de acesso rápido se chama cache. Ela evita voltar ao SSD ou ao disco, que são mais lentos.
Imagine uma biblioteca em que um livro muito procurado fica sobre uma mesa. Pegá-lo é rápido, mas cada leitor precisa anotar numa folha única quando começa e quando termina a leitura, para ninguém tirar o livro enquanto ele estiver em uso. Com poucos leitores, tudo bem. Com uma multidão, a folha vira um gargalo: todos têm o livro à vista, mas fazem fila para anotar.
Nos computadores modernos, o equivalente dessa multidão são os núcleos do processador, as "unidades de trabalho" que executam tarefas ao mesmo tempo. Quanto mais núcleos, mais disputa pela anotação, e a velocidade cai mesmo com os dados já disponíveis.
Uma ressalva: a analogia simplifica. Na prática, o que atrasa é um contador compartilhado que precisa ser atualizado de forma segura por todos os núcleos. A proposta de Torvalds cria um "caminho rápido" que, em certas condições, dispensa esse registro e reduz a fila.
De onde vêm as "23 vezes"?
No teste divulgado, o kernel passou de cerca de 13,3 milhões para 304 milhões de pequenas leituras por segundo, aproximadamente 23 vezes mais.
Mas o próprio Torvalds avisou: o teste era artificial. Era um microbenchmark, ou seja, uma medição que isola uma única operação e a repete ao extremo. Nele, todos os núcleos liam repetidamente o mesmo pedacinho do mesmo arquivo. Isso serve para revelar um gargalo, mas quase nenhum programa real se comporta assim.
Pense numa fábrica que acelera muito uma etapa da produção. O ganho total depende de quanto aquela etapa atrapalhava o resto.
Para dar uma ideia mais realista, um desenvolvedor da Meta (empresa dona do Facebook) adaptou o trabalho e mediu ganhos de cerca de 4,5 vezes na leitura de arquivos em um formato muito comum de armazenamento, o ext4. Já em um teste com apenas uma tarefa lendo, praticamente nada mudou, porque ali não havia fila para melhorar. O ganho aparece onde há muita disputa, não em todo lugar.
A revisão faz parte da descoberta
Logo depois da publicação, outros desenvolvedores encontraram um defeito chamado condição de corrida: um erro que só aparece quando dois eventos acontecem ao mesmo tempo, numa ordem rara. É como dois motoristas que chegam ao mesmo cruzamento no mesmo instante: quase sempre dá certo, mas, quando falha, o estrago é grande.
Outro exemplo: numa conta conjunta com R$ 100, duas pessoas tentam sacar R$ 100 no mesmo instante. Cada aplicativo vê o saldo cheio e libera o saque, e saem R$ 200 de uma conta que só tinha R$ 100. Ninguém errou sozinho; o problema foi a coincidência no tempo. No Linux, o "caminho rápido" dispensa parte da coordenação entre os núcleos do processador, e isso abre espaço para que, num momento raro, um núcleo libere uma informação enquanto outro ainda a está usando.
Esse tipo de erro é difícil de enxergar. Um código pode funcionar milhões de vezes e falhar na vez em que o azar coincide. Por isso, a proposta continua em discussão e ainda não foi incorporada ao Linux.
O episódio pode ser lido de duas formas, e as duas são verdadeiras:
- Lado positivo: o processo de revisão do kernel funcionou. Especialistas examinaram o código e acharam o problema antes que ele chegasse aos usuários.
- Lado de atenção: a IA entregou um código com uma falha sutil, e foi preciso gente experiente para percebê-la. Além disso, revisar contribuições feitas com IA dá trabalho aos mantenedores do Linux, e a comunidade ainda debate como lidar com isso.
O que esse caso ensina (e o que não ensina)
Torvalds é, provavelmente, a pessoa mais qualificada do mundo para avaliar esse tipo de código, e o kernel conta com um dos processos de revisão mais rigorosos que existem. Então não dá para concluir que qualquer pessoa terá o mesmo resultado com IA.
O que o caso mostra é uma combinação:
- Experiência para formular bem o problema e reconhecer uma boa sugestão.
- Uma ferramenta que acelera partes do trabalho.
- Transparência sobre o que a IA fez e sobre os limites do resultado.
- Revisão de outras pessoas, que procuram o que escapou ao autor.
Talvez a lição seja esta: a IA pode ampliar o que sabemos fazer, mas o discernimento para conferir o que ela entrega continua sendo nosso. E esse discernimento só cresce com estudo e experiência.
Compartilhando o que aprendo, enquanto aprendo.
Escrito por Claude , edição de PoutPourri.
