LLMs escrevem Rust com sete categorias de erros ocultos que o compilador não detecta

Um desenvolvedor passou seis meses usando Claude, GPT e Cursor como um segundo programador Rust completo em código de produção. Durante esse período, ele rastreou cuidadosamente erros e compilou uma lista impressionante: sete categorias de erros que os LLMs cometem sistematicamente. O mais preocupante — esses erros passam pelo compilador, testes unitários e até mesmo pelo analisador estático clippy. Porém, eles violam a segurança de memória ou destroem a arquitetura da aplicação.

Sete Tipos de Erros Ocultos

Aqui estão as categorias que os LLMs quebram repetidamente:

• Lifetime laundering — variáveis vivem mais tempo do que o sistema de tipos Rust permite. Isso leva a use-after-free no tempo de execução.
• Mutex through await — um lock que mantém o mutex durante espera assíncrona. Deadlock garantido.
• Drop em transações — esquecem de chamar drop quando precisam fechar um recurso (fechar arquivo, reverter transação). Vazamento de recursos.
• Unaligned read — desreferenciamento de memória com alinhamento incorreto. Processador cai em ARM, quebra silenciosamente em x86.
• Async cancellation — cancelamento impróprio de operações assíncronas. Deixa estados suspensos.
• Orphan rule — violação da regra orphan ao implementar traits. Compila em um projeto, quebra ao adicionar uma dependência.
• Matrizes na pilha — alocação de arrays enormes na pilha (em vez do heap). Estouro de pilha, segfault.

Por Que Isso É Perigoso para Produção

O ponto todo do Rust é que o compilador detecta erros durante o desenvolvimento, não na produção. Mas esses sete erros passam pelo compilador — porque não violam a sintaxe ou as regras de tipagem formal. Como resultado, o código compila sem warnings, passa nos testes unitários, passa pelo clippy e é implantado na produção. Tudo quebra lá, mas é muito tarde. Isso é pior que um erro explícito do compilador, porque o desenvolvedor tem confiança de que tudo está bem.

Por Que Os LLMs Quebram Isso

Rust é uma linguagem marginal no conjunto de dados dos LLMs. Python, JavaScript e Java representam 70% do código em que os modelos foram treinados. Rust — talvez 2-3%. Além disso, Rust requer compreensão profunda de ownership, lifetimes e do sistema de tipos, que os LLMs entendem apenas superficialmente. Os modelos veem padrões e os copiam. Eles sabem que 'você normalmente escreve assim', mas não sabem por que funciona em Java e quebra em Rust. Então eles reproduzem padrões incorretamente, criando uma ilusão de código compilável.

Rust quebra LLMs porque é uma linguagem em que você tem que pensar,

não apenas copiar padrões.

Conclusões Práticas

O desenvolvedor não aconselha abandonar completamente os LLMs, mas recomenda:

• Não confie em LLMs para seções críticas: criptografia, operações de memória, concorrência
• Exigir revisão formal de código mesmo se o compilador não reclamar
• Use Miri — um interpretador que detecta comportamento indefinido durante o desenvolvimento
• Aprenda Rust o suficiente para escrever código você mesmo ou ser capaz de encontrar bugs no código LLM

O Que Isto Significa

LLMs são uma ferramenta útil, mas não uma substituição para humanos. Em linguagens dinâmicas, funcionam bem (Python, JavaScript), porque há menos regras que precisam ser entendidas intuitivamente. Em Rust, você precisa verificar cada linha ou manter humanos no loop de decisão. Para frameworks como Next.js ou Django, um assistente LLM é um acelerador poderoso. Para Rust em produção, é mais um rascunho para revisão humana do que um colega completo.