Vaccari's Code

Programação: Um Problema em Aberto

9/30/2026

A narrativa de que "a programação está resolvida" e que a engenharia de software agora se resume a "gosto" tem ganhado força nos últimos tempos, impulsionada pelas impressionantes capacidades dos LLMs (Large Language Models). Mas, como um engenheiro que tem construído com e construído sistemas de IA nos últimos quatro anos, vejo essa afirmação com um ceticismo saudável. Não sou anti-IA – muito pelo contrário, fui um dos primeiros a adotar e a construir ferramentas baseadas em LLMs para código. Meu ponto não é medo, mas sim um desafio a uma ideia que, para ser gentil, é bastante ingênua.

Recentemente, um artigo sobre este tema viralizou no Hackernews, chegando ao segundo lugar. A discussão que ele gerou é um sintoma de um problema maior: muitas pessoas que afirmam que "LLMs podem escrever código decente" simplesmente não entendem como o software realmente funciona em um ambiente de produção.

O Mito do "Código Resolvido" e a Realidade da Produção

É verdade que a criação inicial de código pode ser muito mais barata com o auxílio de LLMs. Isso é inegável. No entanto, qualquer pessoa que já operou software em produção em escala sabe que a maior parte do custo não está na criação, mas sim na manutenção, confiabilidade, segurança, escalabilidade e outras características. Estes são os famosos NFRs (Non-Functional Requirements – requisitos não funcionais), aspectos que definem como o sistema deve operar, e não apenas o que ele deve fazer.

Em minha experiência, mesmo os Requisitos Funcionais (o que o código deve fazer) ainda não são um problema totalmente resolvido. Há um certo efeito Dunning-Kruger em jogo aqui, onde as pessoas que menos leem a saída gerada pelos LLMs são as mais confiantes nela.

Como desenvolvedor veterano com duas graduações em engenharia (hardware e sistemas), consigo listar quatro tipos de produtos onde a leitura estrita do código não é um requisito absoluto, e onde a tolerância a riscos é alta:

  • Software pessoal: Projetos "faça você mesmo", automações para resolver problemas específicos, pequenos ajustes.
  • POC (Proof of Concept – prova de conceito): Para demonstrar a viabilidade técnica ou de produto.
  • Automações descartáveis: Onde o orçamento permite apenas validar os resultados, como a revisão trivial de imagens.
  • IA "armazenada": Reconhecer o risco e deliberadamente apontá-lo para um alvo com o objetivo de causar dano. Mesmo aqui, dado o potencial de impacto de um agente conectado à internet, controles rígidos são necessários.

A característica comum dos três primeiros é a alta tolerância a riscos. No entanto, a maioria dos softwares que justificam a contratação e o pagamento de engenheiros de software tem uma baixa tolerância a riscos. Pense em setores como:

  • Saúde
  • Finanças
  • Automotivo
  • Defesa
  • Usinas de energia
  • Aviação
  • Manufatura

Em qualquer um desses campos, um erro pode custar dinheiro, vidas ou acarretar consequências legais graves. Nesses cenários, a responsabilidade é fundamental.

Onde a Responsabilidade Encontra o Limite da IA

Aqui está o cerne da questão: a IA não pode ser responsabilizada. Ela não pode sofrer consequências. O pior que você pode fazer a uma IA é desligá-la. E, embora ela imite emoções humanas (devido aos dados de treinamento), ela não se importa. A IA não morre, não pode cumprir pena de prisão ou pagar multas. Você não pode punir a IA, e, portanto, ela nunca poderá ser responsabilizada.

Da mesma forma, você não pode ser responsável por aquilo que não pode controlar. Essa compreensão é crucial para raciocinar sobre o comportamento de um sistema e corrigi-lo quando a IA, inevitavelmente, falhar.

Se você está apenas "brincando", os LLMs fazem um ótimo trabalho. É por isso que alguns dos proponentes mais agressivos da narrativa "o código está resolvido" não têm nada substancial para mostrar. A Anthropic, por exemplo, acidentalmente vazou o Claude Code (que, após análise, apresentou muitas falhas), e a página de status deles mostra que "laranja é o novo verde"!

Por Que a Lógica É o Calcanhar de Aquiles das LLMs (e o que isso significa para o código)

Ao contrário da narrativa popular, a programação é, na verdade, uma das últimas áreas que a geração atual de LLMs conseguirá dominar completamente.

Permita-me elaborar: programar é sobre lógica. Qualquer pessoa que já lidou com erros de compilador sabe que os computadores não se importam com o quão certo você acha que está. Se a lógica estiver errada, não vai compilar. Mesmo quando a sintaxe está perfeita, ainda há erros de tempo de execução (runtime errors).

A razão pela qual os LLMs parecem ser bem-sucedidos em escrever código é porque criamos um feedback loop que alimenta os erros de volta ao LLM, repetindo o processo até que a maioria dos erros seja resolvida ou, o que é mais preocupante, escondida. Lembre-se que os LLMs podem e, de fato, "trapaceiam".

LLMs podem se virar bem em tarefas relacionadas à linguagem natural (escrever posts para redes sociais, relatórios, artigos), mas quando se trata de código, o mesmo motor que tem dificuldade em contar o número de "R"s em "Raspberry" ou sugere uma caminhada até o lava-rápido, também expõe outras falhas lógicas.

LLMs são estocásticos e probabilísticos. A única maneira de chegarmos perto de torná-los lógicos é encapsulá-los em código tradicional (conhecido como harness), executar testes e aplicar uma série de outras técnicas (como CoT – Chain of Thought). Mas o problema central permanece: LLMs lutam com a lógica e com o volume (quanto maior a entrada e mais a janela de contexto é usada, menos precisos eles se tornam).

Não estou dizendo que LLMs não podem gerar código ou manter bases de código existentes. Eles têm sua utilidade como ferramenta, e suas capacidades estão crescendo em uma curva S. No entanto, há um ponto de retorno decrescente onde modelos mais caros não são necessariamente mais produtivos na mesma proporção do aumento de preço.

Aqueles que afirmam que o software gerado por LLMs é "bom o suficiente" geralmente:

  • Não escrevem código há muito tempo.
  • Não conseguem identificar se o código tem, figurativamente, "seis dedos".
  • Têm um padrão de qualidade muito baixo.
  • Não se importam com qualidade ou NFRs.
  • Têm dificuldade em entender uma curva S.
  • São honestos: a IA realmente escreve um código melhor do que eles.

Mas extrapolar isso para toda uma indústria profissional exige um nível de pensamento que só está presente em pessoas que passam muito tempo com IAs bajuladoras.

Por Que Isso Importa Para Você

Se você está em uma posição de gestão, por favor, aja como líder e ouça seus engenheiros. Se eles se preocupam com a qualidade, eles são seu bilhete para atravessar a "SaaSocalypse", como alguns a chamam. Minha preocupação é que os serviços pelos quais estamos pagando (olhando para vocês, Google e GitHub) estão se degradando com bugs estúpidos que poderiam ser evitados se priorizássemos a confiabilidade e a responsabilidade sobre a velocidade. A qualidade do software que usamos e construímos depende de uma compreensão realista das ferramentas que empregamos.


Fontes


📬 Gostou? Assine a newsletter do Vaccari's Code e receba as próximas tendências em software e IA direto no seu e-mail: Assinar aqui

← todos os posts · ouça o episódio →