Artigos aprofundados sobre a tecnologia que molda o que vem a seguir.

Assistentes de Código com IA: 5 Mitos, Testados

Assistentes de código com IA aceleram a digitação, não a qualidade do software. Testamos cinco mitos contra os gargalos reais: design e verificação.

Um braço robótico inunda o chão de fábrica com tijolos brilhantes que se acumulam em um único portão estreito de inspeção.
A geração ficou rápida. A inspeção não — e a vazão é definida pela etapa mais lenta.

Jonathan Blow — o designer por trás de Braid e The Witness, e um sujeito teimoso o bastante para passar uma década construindo a própria linguagem de programação — fez recentemente uma pergunta que deveria incomodar todo fornecedor que vende assistentes de código com IA: se a IA resolveu a programação, por que meu software continua igual? Os mesmos crashes. As mesmas atualizações inchadas. As mesmas reclamações de uma década atrás sobre apps que consomem RAM e fazem menos do que as ferramentas que substituíram. A resposta padrão — é só esperar seis meses — não cobre bem isso, e não acho que Blow esteja errado em cutucar a ferida.

Aqui vai minha posição, depois de anos construindo sistemas de ML e de ver essas ferramentas chegarem a times reais: os assistentes de código com IA estão genuinamente bons hoje, e genuinamente não mexeram no ponteiro do software que você e eu usamos todo dia. As duas coisas são verdade ao mesmo tempo, e são verdade porque essas ferramentas nunca miraram na restrição. A forma mais clara de ver isso é pegar as cinco crenças que mais ouço e testar cada uma.

Mito 1: Digitar É o Gargalo do Desenvolvimento de Software

A premissa é quase autoexplicativa: programar é produzir código, então uma máquina que produz código dez vezes mais rápido torna o software dez vezes mais rápido. É um silogismo arrumadinho com uma falha — ninguém trabalha assim de verdade. Existe uma regra de bolso antiga, popularizada por Clean Code, de que desenvolvedores passam bem mais de dez vezes mais tempo lendo código do que escrevendo. Essa proporção é anterior aos LLMs em quinze anos, mas toda análise séria de como as horas de engenharia são gastas chega ao mesmo lugar: entender o sistema existente, coordenar com outras pessoas e esperar decisões. Digitar é erro de arredondamento.

Dá para sentir isso na sua própria semana. O autocomplete economiza minutos reais — nunca abriria mão dele —, mas meus dias difíceis nunca foram difíceis porque eu não conseguia digitar rápido o bastante. Eram difíceis porque o serviço de pagamentos tinha uma invariante que ninguém escreveu, ou porque três times discordavam sobre o que a API deveria garantir. Acelerar a única etapa que não era lenta quase não muda a vazão total. Uma fábrica que estampa peças mais rápido do que a linha de inspeção consegue liberá-las não entrega mais produto. Entrega uma pilha maior de peças.

Há um lugar em que digitar é de fato o gargalo: trabalho greenfield, sem sistema existente a respeitar. Boilerplate, protótipos, scripts descartáveis, a primeira versão de qualquer coisa. Justamente por isso as demos parecem mágica — demos são sempre greenfield. Engenharia de produção é quase toda brownfield, e trabalho brownfield é trabalho de leitura.

Mito 2: Código Gerado por IA Chega Verificado

O fluxo otimista vai assim: descreva a tarefa, o modelo escreve, os testes passam, merge. A falha está no meio. Os testes passam só diz que os testes que você pensou em escrever concordam com o código que o modelo pensou em escrever. Os dois podem estar errados na mesma direção, e com saída de LLM muitas vezes estão — o modelo produz código fluente, idiomático e confiante, e fluência é exatamente o que desarma a revisão.

Aqui vai um pequeno exemplo que vi por aí, na essência se não na forma exata. Peça um agendador de jobs mensais e você vai receber algo assim:

from datetime import datetime
def next_monthly_run(day: int, hour: int = 9) -> datetime:
"""Next run time for a job that fires monthly on `day`."""
now = datetime.now()
candidate = now.replace(day=day, hour=hour, minute=0, second=0, microsecond=0)
if candidate <= now:
# Roll forward one month
month = now.month % 12 + 1
year = now.year + (1 if now.month == 12 else 0)
candidate = candidate.replace(year=year, month=month)
return candidate

Leia como leria o pull request de um colega. É idiomático. Trata a virada de ano. A docstring até está correta. Agora rode com day=31 em 15 de abril: now.replace(day=31) lança ValueError, porque abril não tem dia 31. A função quebra justamente no pedido de agendamento mais comum — fim do mês — e só em meses mais curtos, então pode ficar parecendo saudável em produção por semanas antes de alguém perceber. Um teste que percorre um ano inteiro de valores de now pega isso em segundos. Um revisor humano atento pega talvez metade das vezes. Essa diferença é o problema de verificação em miniatura.

É por isso que continuo argumentando que, em um fluxo muito apoiado em IA, a escolha entre checagens de compreensão e testes não é acadêmica — é o jogo inteiro. Ler código que você não escreveu já é mais difícil do que escrevê-lo. Ler código que nenhum humano escreveu, no volume que essas ferramentas produzem, inverte por completo a economia da revisão. Os times com que converso não estão mais com falta de código. Estão com falta de gente que entenda o que o código faz e esteja disposta a assinar embaixo.

Uma lupa revela uma rachadura capilar atravessando uma placa de mármore polida.
Código plausível falha como mármore: ao longo de uma rachadura que você só vê se olhar com atenção.

Mito 3: Código Mais Barato Torna o Design de Software Barato

Uma crença mais sutil: se o código é quase de graça, a arquitetura importa menos, porque sempre podemos reescrever. Abstração ruim? Gere de novo. Modelo de dados errado? Gere de novo também. Já ouvi engenheiros seniores dizerem isso com a cara mais séria, e isso confunde o custo de mudar texto com o custo de mudar decisões.

A parte difícil do software nunca foi o código. É decidir o que vale a pena construir, modelar um domínio humano bagunçado em algo que uma máquina consiga executar e fazer apostas arquiteturais que não desmoronem quando os requisitos mudarem — e eles sempre mudam. São problemas de intenção e valores, não de completar padrões. Um modelo treinado no corpus de software existente consegue dizer como sistemas parecidos com o seu costumam ser. Não consegue dizer como o seu deveria ser, porque essa resposta está nos seus usuários, nas suas restrições e no apetite de risco da sua organização. Nesse ponto praticamente não avançamos, e eu diria que não é uma lacuna de capacidade da qual dá para escapar escalando. É um erro de categoria.

Reescritas também não são de graça. A maior parte do dinheiro de engenharia é gasto mudando sistemas que já existem, e mudar um sistema significa antes fazer engenharia reversa da intenção embutida nele — as invariantes que ninguém documentou, o caso de borda que acaba sendo essencial para um cliente importante. O modelo não conhece essa intenção. Muitas vezes, nem o time conhece. Esse é o gap entre especificação e implementação, onde os bugs de fato moram, e gerar mais implementação só alarga esse gap, a menos que alguém segure a especificação com firmeza.

Fred Brooks tinha um termo para o que torna um software coerente: integridade conceitual — a sensação de que uma mente, ou algumas mentes alinhadas, tomou as decisões. A geração fluente de código não nos aproxima disso. No máximo, torna baratas mil microdecisões desalinhadas, e é assim que se chega a sistemas que parecem projetados e dão a sensação de montados às pressas.

Mito 4: Software Que Não Mudou Prova Que a Codificação com IA Falhou

Agora o contraponto, porque o enquadramento de Blow também não é à prova de balas. Olhe para além do software comercial de massa e as coisas estão se mexendo. A cena indie produziu jogos de estratégia com engines próprias — de times minúsculos — que há uma década precisariam do quadro de funcionários da Blizzard. Mais impressionante, para mim, é a ascensão silenciosa do software pessoal: gente construindo os próprios clientes de e-mail, apps de calendário, controladores financeiros e frontends de git, moldados exatamente ao jeito como pensam. Essas ferramentas são rústicas e nunca sobreviveriam a ser lançadas para dez mil desconhecidos. Mas existem, são usadas todo dia e simplesmente não compensava construí-las antes.

Até as instituições estão mudando de formas que a métrica de manchete não captura. Conheço organizações cujo plano de modernização é, na essência: expor o sistema legado por meio de APIs decentes e deixar a equipe construir seus próprios endpoints e interfaces por cima, com uma ferramenta de código agêntica. Isso não é "meu software continua igual". É software se dissolvendo em algo mais pessoal — invisível se você só olhar para os gráficos da loja de apps.

A razão mais profunda pela qual a observação de Blow parece verdadeira é, porém, organizacional, não técnica. O software comercial é moldado pelo que as empresas otimizam — engajamento, lock-in, cadência de lançamentos, custo de suporte — e a IA dá mais do que você já quer, mais rápido. Ela não muda o que você quer. Uma empresa que lançava software inchado porque o inchaço não estava na planilha de custos agora vai lançar software inchado em um ciclo de desenvolvimento mais curto. A barra de qualidade para software distribuído a milhares de usuários é definida por incentivos, disciplina de testes e bom gosto — nada disso é saída de modelo.

Há também um argumento simples de defasagem. Codificação com IA genuinamente confiável tem talvez um ano; o período anterior era instável, e antes disso era um brinquedo. Produtos levam anos para ser concebidos, construídos e lançados. Julgar hoje o efeito dessas ferramentas no software lançado é como julgar um arado novo pela colheita de um mês depois de ele ter sido inventado.

Mito 5: O Próximo Modelo Vai Fechar a Lacuna

A versão mais forte do argumento otimista: todas as objeções acima descrevem os modelos de hoje, e os modelos de hoje são os piores que vamos usar. Em parte, é verdade. As janelas de contexto vão crescer, as APIs alucinadas vão diminuir, os agentes vão ficar melhores em rodar os próprios testes. Espero ganhos reais, especialmente em tarefas bem especificadas.

Mas repare em quais gargalos são problemas de capacidade e quais não são. A verificação fica mais fácil conforme os modelos ficam mais confiáveis — isso é capacidade. Decidir o que vale a pena construir, manter a integridade conceitual, mudar o que uma organização otimiza — nada disso está em nenhum roteiro de modelo, porque não são problemas de modelo. E cuidado com o progresso em benchmarks como evidência: benchmarks deixam de fora a maior parte do que é trabalho real, e trabalho real é justamente o tipo mal especificado e carregado de intenção.

Então aqui vai minha aposta, registrada: as ferramentas vão ficar muito melhores para construtores individuais e pequenos times com bom gosto, e o software de massa vai melhorar marginalmente, se é que vai — porque a restrição ali nunca foi o código. Se isso soa pessimista, não é. Significa que a alavanca está nas suas mãos e no seu organograma, não no próximo lançamento de um laboratório.

Um jardineiro poda uma árvore bonsai em uma bancada ensolarada, com ferramentas manuais.
A qualidade do software ainda é um problema de cuidado contínuo, não de produção.

O Que Realmente Melhora a Qualidade do Software

Se geração é barata e verificação é cara, a resposta racional é redirecionar o investimento. Na prática:

  • Trate testes e tipos como infraestrutura de produção. Testes baseados em propriedades, checagens de invariantes e CI rápido são o que transforma geração barata em geração barata e correta. Oriente o orçamento para isso da mesma forma que orça computação.
  • Escreva a especificação antes do prompt. A especificação agora é o artefato de maior alavancagem que um time produz, porque é o que o modelo não consegue fornecer e o que os revisores conferem.
  • Use IA onde ela é genuinamente forte: protótipos greenfield, migrações, boilerplate, ferramentas pessoais, exploração rápida de um espaço de design. Desconfie dela em caminhos legados críticos onde a intenção não está documentada.
  • Proteja o tempo de design. Quando a velocidade de geração triplica, a pressão é para preencher o roadmap três vezes. Resista. Decidir é o trabalho.

O gargalo nunca foi a digitação. Sempre foi decidir — e provar.

A pergunta de Blow tem resposta, e é uma resposta esperançosa se você a ler direito. O software continua igual porque a qualidade sempre foi limitada por decidir, verificar e se importar — e os assistentes de código com IA, por mais úteis que sejam, aceleram a parte que nunca foi lenta. Ou seja, as ferramentas para tornar o software melhor são as mesmas de sempre: bom gosto, especificação e disciplina para provar as coisas. Os modelos só tornaram impossível continuar fingindo o contrário.