LLMs escrevem Rust com sete categorias de erros ocultos que o compilador não detecta
Durante seis meses, um desenvolvedor usou Claude, GPT e Cursor como um segundo programador em Rust. Nesse período, ele catalogou sete tipos de erros ocultos: lifetime laundering, Mutex em código async, Drop em transações, unaligned read, async cancellation, orphan rule e arrays na stack. Todos passam por cargo build e cargo test, mas comprometem a segurança.
Processado por IA de Habr AI; editado por Hamidun News
Um desenvolvedor passou seis meses usando Claude, GPT e Cursor como um segundo programador completo em Rust, em código de produção. Durante esse período, ele registrou os erros com cuidado e montou uma lista impressionante: sete categorias de erros que os LLMs cometem de forma sistemática. O pior é que esses erros passam pelo compilador, pelos testes unitários e até pelo analisador estático clippy. Mesmo assim, eles corrompem a memória ou destroem a arquitetura da aplicação.
Sete tipos de erros ocultos
Estas são as categorias que os LLMs erram repetidamente:
- Lifetime laundering: variáveis vivem mais do que o sistema de tipos do Rust permite. O resultado é use-after-free em runtime.
- Mutex através de await: o lock fica retido durante uma espera assíncrona. Deadlock garantido.
- Drop em transações: o modelo esquece de chamar drop quando um recurso precisa ser liberado (fechar um arquivo, fazer rollback de uma transação). O recurso vaza.
- Unaligned read: desreferenciamento de memória com alinhamento incorreto. O processador trava no ARM e quebra silenciosamente no x86.
- Async cancellation: cancelamento incorreto de operações assíncronas, que deixa estados pendurados.
- Orphan rule: violação da orphan rule na implementação de traits. Compila em um projeto e quebra quando uma dependency é adicionada.
- Arrays na stack: alocação de arrays enormes na stack (em vez do heap). Resultado: stack overflow e segfault.
Por que isso é perigoso em produção
A grande vantagem do Rust é que o compilador pega os erros durante o desenvolvimento, e não em produção. Só que o compilador deixa passar esses sete erros, porque eles não violam a sintaxe nem as regras formais de tipagem.
Na prática, o código compila sem warnings, passa nos testes unitários, atravessa o clippy e vai para produção. Lá tudo quebra, mas aí já é tarde. Isso é pior do que um erro explícito de compilação, porque o desenvolvedor acredita que está tudo certo.
Por que os LLMs erram nisso
Rust é uma linguagem marginal nos datasets dos LLMs. Python, JavaScript e Java respondem por 70% do código usado no treinamento dos modelos. Rust talvez represente 2-3%. Ao mesmo tempo, Rust exige compreensão profunda de ownership, lifetimes e do type system, que os LLMs entendem apenas superficialmente.
Os modelos enxergam padrões e os copiam. Eles sabem que "normalmente se escreve assim aqui", mas não sabem por que isso funciona em Java e quebra em Rust. Por isso, reproduzem os padrões de forma incorreta e criam a ilusão de código que compila.
Rust quebra os LLMs porque é uma linguagem em que é preciso pensar, e não apenas copiar padrões.
Lições práticas
O desenvolvedor não recomenda abandonar os LLMs por completo, mas sugere:
- Não confiar em LLMs para trechos críticos: criptografia, manipulação de memória, concurrency
- Exigir formal code review mesmo quando o compilador não reclama
- Usar o Miri, um interpretador que detecta undefined behavior durante o desenvolvimento
- Aprender Rust o suficiente para escrever o código por conta própria ou conseguir encontrar bugs no código gerado por LLMs
O que isso significa
LLMs são uma ferramenta útil, mas não substituem um humano. Em linguagens dinâmicas como Python e JavaScript, eles funcionam bem, porque há menos regras que precisam ser compreendidas intuitivamente. Em Rust, é preciso revisar cada linha ou manter um humano no ciclo de decisão.
Para frameworks como Next.js ou Django, um assistente baseado em LLM acelera bastante o trabalho. Para Rust em produção, ele está mais para um rascunho que depende de human review do que para um colega de pleno direito.
- 20 de nov. de 2026Proton lança Lumo Desktop: agente de IA com acesso a arquivos e shell sob o seu controle
- 20 de nov. de 2026Linear chega a US$ 100 milhões de ARR sem SDRs: agentes já criam mais de 50% das tarefas, contra 3% há um ano
- 19 de nov. de 2026Amazon e Google ficarão com 28,4% da Anthropic após o IPO, mas sem direito a voto
- 19 de nov. de 2026Social Department trocou uma semana assistindo a séries por quatro consultas do QuickSearch na AWS
Perguntas frequentes sobre a notícia
O que se sabe sobre Sete tipos de erros ocultos?
Estas são as categorias que os LLMs erram repetidamente: Lifetime laundering: variáveis vivem mais do que o sistema de tipos do Rust permite. O resultado é use-after-free em runtime. Mutex através de await: o lock fica retido durante uma espera assíncrona. Deadlock garantido. Drop em transações: o modelo esquece de chamar drop quando um recurso precisa ser liberado (fechar um arquivo, fazer rollback de uma transação). O recurso vaza. Unaligned read: desreferenciamento de memória com alinhamento incorreto.
Por que isso é perigoso em produção?
A grande vantagem do Rust é que o compilador pega os erros durante o desenvolvimento, e não em produção. Só que o compilador deixa passar esses sete erros, porque eles não violam a sintaxe nem as regras formais de tipagem. Na prática, o código compila sem warnings, passa nos testes unitários, atravessa o clippy e vai para produção. Lá tudo quebra, mas aí já é tarde. Isso é pior do que um erro explícito de compilação, porque o desenvolvedor acredita que está tudo certo.
Por que os LLMs erram nisso?
Rust é uma linguagem marginal nos datasets dos LLMs. Python, JavaScript e Java respondem por 70% do código usado no treinamento dos modelos. Rust talvez represente 2-3%. Ao mesmo tempo, Rust exige compreensão profunda de ownership, lifetimes e do type system, que os LLMs entendem apenas superficialmente. Os modelos enxergam padrões e os copiam. Eles sabem que "normalmente se escreve assim aqui", mas não sabem por que isso funciona em Java e quebra em Rust.
Build & Ship Production AI Agents Without Boilerplate Code
Start your free 72-hour trial at Hamidun Academy (academy.hamidun.com) — interactive lessons on Claude Code & Cursor, live Tech Radar, and production agent templates.
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.