Intensivo Grátis 21–22/11Intensivo gratuito de 2 dias em Vibecoding (21–22/11 às 16:00 MSK) · Turma 3 começa 23/11Inscrever-se grátis →Turma 3 (23/11)
IndústriaAnálise · No radarHabr AI→ original

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
LLMs escrevem Rust com sete categorias de erros ocultos que o compilador não detecta
Fonte: Habr AI. Colagem: Hamidun News.
Ouvir artigo
Ficha técnica e números-chave
ParâmetroDados
Fonte originalHabr AI ↗
Editor-chefe
Lifetime launderingvariáveis vivem mais do que o sistema de tipos do Rust permite. O resultado é use-after-free em runtime.
Mutex através de awaito lock fica retido durante uma espera assíncrona. Deadlock garantido.
Drop em transaçõeso modelo esquece de chamar drop quando um recurso precisa ser liberado (fechar um arquivo, fazer rollback de uma transação). O recurso vaza.

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.

História

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.

ZK
Zhemal Khamidun — CPO da Alpina Digital, gerente de produto do AlpinaGPT. Cria produtos de IA desde 2019. O Hamidun News é um projeto pessoal que virou um agregador em produção com mais de 6.000 leitores.
✦ Hands-On AI Engineering · Hamidun Academy

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.

Start 72h Free Trial →Vibe-Coding Intensive
O que você acha?
Carregando comentários…