<\> Casa do Dev
Notícias abrir
Ferramentas abrir
Vagas abrir
Aprender abrir
Comunidade abrir
Guia de Compras abrir

Vibe coding, brainrot e dívida técnica: o checklist antes do merge

DA

12 min

Vibe coding, brainrot e dívida técnica: o checklist antes do merge

Relatos no r/learnprogramming e no r/webdev expõem o custo escondido do código aceito sem revisão e o risco na due diligence. Veja o checklist que separa velocidade de competência.

Neste artigo

A pergunta mais incômoda da semana no r/learnprogramming não pedia ajuda de sintaxe nem indicava biblioteca. Um dos tópicos mais comentados dos últimos dias perguntou, sem rodeios, o que significa ser competente em programação hoje: quando alguém pode dizer com confiança que sabe programar, que domina uma linguagem, que constrói software de verdade. Será que competência se resume ao que você consegue entregar? A thread que abriu a discussão chega no momento exato em que relatos da mesma semana no r/learnprogramming e no r/webdev mostram um júnior entregando ticket sem conseguir explicar o que construiu, veteranos admitindo que pararam de ler o código gerado e um projeto descobrindo que código aceito sem revisão pode quebrar uma venda inteira.

Este guia junta o diagnóstico e o método na mesma peça. Primeiro, o que os relatos da semana dizem sobre a crise de competência e sobre a dívida técnica invisível que o vibe coding acumula. Depois, uma definição operacional do que ainda faz um dev competente quando a IA escreve uma parte cada vez maior da base. Por fim, o checklist adversarial de revisão antes do merge, desenhado para rodar em minutos no seu fluxo atual, usando a própria IA como revisora e registrando o porquê de cada mudança.

A semana em que competência virou pergunta

Três relatos, publicados quase ao mesmo tempo, desenham o quadro completo. O primeiro vem do r/learnprogramming: um profissional com origem em hardware e sistemas embarcados precisou transformar um pipeline em fluxo assíncrono, e o relato descreve o procedimento com uma honestidade rara. Sob a pressão de um prazo de deploy de uma semana, ele gerou com IA o conteúdo dos tickets em pânico e só depois tentou entender, parcialmente, o que havia colhido. Agora precisa explicar o mecanismo que ajudou a construir, e a pergunta que fez ao sub resume o problema: alguém tem material para eu aprender o que estou entregando?

O segundo relato vem do r/webdev, na discussão sobre um vídeo recente de um desenvolvedor conhecido tratando do que a comunidade começou a chamar de brainrot de IA. O ponto que mobilizou os comentários não foi o conteúdo do vídeo em si, mas o espelho que ele vira: desenvolvedores experientes demonstrando, em situações públicas, que fazem pouca tentativa de entender o código que a ferramenta escreve, chegando ao extremo de usar a IA para resumir o resumo do próprio código. A conversa que se seguiu tratou o fenômeno como risco real de atrofia de habilidade, inclusive entre quem já tem anos de estrada.

O terceiro relato é o que transforma filosofia em dinheiro. Também no r/webdev, um autor que constrói ferramentas como projeto paralelo descreveu o cálculo que ninguém quer fazer: construir rápido com IA é excelente para tirar um protótipo do papel, mas empilhar trechos gerados e aceitos sem verificação acumula código desorganizado, difícil de manter e de explicar. Quando chega a hora de vender o projeto ou passar a responsabilidade para outra pessoa, esse acúmulo aparece na due diligence, no momento em que alguém finalmente lê o que foi escrito, e pode inviabilizar o negócio inteiro. Três relatos, uma única conclusão: a entrega existe, o entendimento nem sempre.

O que ainda faz um dev competente

A discussão da semana no r/learnprogramming não produziu um veredito único, mas o desenho do consenso emergente é claro: competência deixou de ser decorar sintaxe e passou a ser a capacidade de responder pelo código que existe no repositório, independentemente de quem o escreveu. Não importa se a linha foi digitada por você, gerada por um modelo ou herdada de quem saiu da empresa. Se ela está lá e tem o seu nome no pull request, ela é sua.

Traduzido em habilidades, isso vira uma lista de quatro itens que a IA acelera, mas não substitui:

  1. Ler e questionar. Percorrer o código gerado com a mesma desconfiança que você teria com uma contribuição de um estagiário desconhecido. O que essa função assume? Onde ela falha? O que acontece quando a entrada vem vazia, duplicada ou com formato inesperado?
  2. Explicar e defender decisões. Se você não consegue explicar, em duas frases, por que o caminho escolhido é melhor que as alternativas, a decisão não foi tomada por você. O relato do pipeline assíncrono é exatamente a ausência dessa habilidade sob pressão.
  3. Verificar comportamento com testes. Código que compila não é código correto. Competência hoje inclui escrever ou revisar os testes que provam que o comportamento esperado acontece nos casos de borda, e não só no caminho feliz que o modelo costuma gerar.
  4. Saber desfazer. Parte de responder pelo código é saber reverter: desfazer um commit, reverter uma migração, desligar uma funcionalidade atrás de uma chave. Quem gera rápido precisa conseguir desfazer com a mesma velocidade.

A IA muda a distribuição do trabalho, não a lista. O que a ferramenta acelera e o que continua sendo intransferível do dev cabe numa tabela:

A IA aceleraContinua sendo do dev
Produzir a primeira versão de trechos repetitivosDecidir se aquele trecho deveria existir
Sugerir refatorações e variantes de implementaçãoAvaliar trade-offs e defender a escolha
Apontar possíveis falhas quando instruída a procurarVerificar com testes que o comportamento é real
Gerar descrição do que foi feitoGarantir que a descrição corresponde ao código
Propor correção para um bug descritoEntender a causa raiz antes de aceitar a correção

A dívida técnica que ninguém vê

Dívida técnica sempre existiu, mas o vibe coding muda a natureza dela. Antes, o codeiro assumia dívida de forma semi consciente: sabia que escreveu atalho, registrou o preço, planejava voltar. Agora, o relato dominante é outro: o trecho gerado é aceito porque parece correto, passa no primeiro teste e entra na base sem ninguém ter lido as partes que importam quando a coisa quebra. O resultado é uma dívida sem registro, sem data de vencimento conhecida e sem histórico de decisão que explique por que ela existe.

O custo cobrado não é abstrato. O relato da venda de projeto que morre na due diligence descreve a cobrança em formato mais cru possível: um comprador potencial lê a base, encontra trechos que ninguém consegue explicar, perde a confiança no estado real do produto e desiste. O mesmo vale internamente. O colega que recebe o seu código depois, o analista que investiga o incidente e o dev novo que tenta entender por que aquela função duplica o trabalho de outra função estão sempre pagando a fatura, com juros. É a constatação que a casa já registrou: a IA acelera a escrita de código, mas não entrega software por si só, e a diferença entre os dois é exatamente o espaço que este checklist ocupa.

⚠️ Atenção: usar a mesma IA que gerou o código como única revisora fecha um ciclo cego. A ferramenta tende a repetir as próprias suposições e a aprovar o que ela mesma escreveria. A revisão com IA ajuda e deve ser usada, mas como adversária provocada, e não como auditora final.

O checklist adversarial antes do merge

A revisão adversarial inverte a lógica usual do code review. Em vez de pedir à IA que confirme que o código está bom, você pede que ela tente derrubar a mudança. O checklist abaixo organiza essa revisão em seis passos que cabem entre o push e o merge:

  1. Explique o diff em voz alta. Antes de abrir o pull request, descreva a mudança como se estivesse treinando um colega novo: o que muda, por que muda e o que não muda. Se você travar em algum trecho, esse trecho é o primeiro a revisar. É o teste que o relato do pipeline assíncrono teria reprovado.
  2. Provoque a IA contra o código. Peça explicitamente que ela ataque a mudança: liste entradas capazes de quebrá-la, efeitos colaterais em outras partes do sistema e suposições não verificadas. Instrua a resposta no formato de falhas encontradas, não de elogios ao código.
  3. Exija testes que falhem primeiro. Para cada comportamento novo, o teste precisa provar que a mudança faz diferença: com o código antigo ele falha, com o novo passa. Se a suíte inteira passa antes e depois da mudança, ela pode estar apenas afeiando o código sem alterar nada que importe.
  4. Leia as fronteiras linha por linha. O centro da lógica gerada pode esperar, mas as bordas não: contratos com APIs externas, consultas que tocam dados sensíveis, regras de autorização e qualquer alteração em migração de banco. É onde o dano potencial é maior e onde o modelo mais erra com confiança.
  5. Confirme o caminho de volta. Cada mudança precisa ter rota de fuga conhecida: commit reverso claro, migração reversível, chave que desliga a funcionalidade sem novo deploy. Quem gerou em minutos deve conseguir desfazer em minutos.
  6. Registre o porquê. Mensagem de commit explicando a decisão, descrição do pull request com as alternativas descartadas e, para mudanças estruturais, uma linha de registro de decisão no repositório. O porquê escrito hoje é a única documentação que a base tem amanhã.

O passo do registro merece destaque porque é o que mais muda a conversa de manutenção. Um trecho de código sem contexto é uma adivinhação; o mesmo trecho acompanhado da frase que explica a decisão vira ponto de partida. Seis meses depois, quando alguém precisar mexer ali, a diferença entre descobrir do zero e relembrar é literalmente a mensagem que você escreveu no dia do merge.

Competência é o que sobra quando a ferramenta para

A resposta para a pergunta da semana termina de se montar sozinha. Velocidade de geração é provisória: amanhã vem um modelo mais rápido e o seu tempo de resposta deixa de ser diferencial. O que sobra é exatamente a lista das quatro habilidades: ler e questionar, explicar e defender, verificar com testes e desfazer com segurança. São as mesmas habilidades que o relato do júnior sem explicação, o veterano sem leitura e o vendedor de projeto reprovado na due diligence não conseguiram usar quando precisaram.

Se você quer aprofundar o lado do fluxo de trabalho, o guia da evolução do vibe coding ao harness engineering mostra para onde a prática está convergindo, e a análise de produtividade com IA: código mais rápido, depuração mais difícil detalha a conta que o checklist acima tenta equilibrar. Para quem quer estruturar o uso profissional das ferramentas com método, o curso de desenvolvimento assistido por IA da casa cobre exatamente a transição do uso amador para o profissional.

Perguntas frequentes

O que é vibe coding?

É a prática de gerar código com IA a partir de instruções em linguagem natural, aceitando e iterando o resultado sem leitura profunda de cada trecho. Acelera protótipos, mas transfere o risco do código para a fase em que ele é testado, mantido ou vendido, o que aparece nos relatos da semana como dívida técnica acumulada e reprovada em due diligence.

Usar a IA para revisar o próprio código gerado por IA faz sentido?

Faz, desde que como provocação e não como aprovação. Peça que a ferramenta ataque a mudança, liste entradas capazes de quebrá-la e suposições não verificadas, e trate o resultado como pista de investigação. A revisão humana nas fronteiras do sistema, como autorização, dados e integrações, continua indispensável.

Quais partes do código merecem leitura linha por linha?

As fronteiras: chamadas a serviços externos, acesso a dados sensíveis, regras de autorização, migrações de banco e qualquer ponto onde um erro se propaga para além do sistema. O miolo da lógica gerada pode ser revisado com apoio da IA, mas as bordas concentram o dano potencial.

Como provar que meu teste vale alguma coisa?

Um teste útil falha sem a mudança e passa com ela. Rode a suíte com o código antigo para confirmar a falha, aplique a mudança e confirme o sucesso. Teste que passa nos dois cenários não protege nada e só dá a sensação de cobertura.

Vibe coding condena a carreira de quem começou agora?

Não, mas redefine o que separa um dev competente. Quem aprende a gerar rápido e também a ler, explicar, testar e desfazer entra no mercado com uma combinação que os relatos da semana mostram ser rara. Quem só aprende a gerar herda o risco que os três relatos descrevem.

Produtos relacionados

Este conteúdo tem links de afiliado: se você comprar por eles, podemos receber uma comissão sem custo extra para você. A escolha dos produtos segue critérios próprios e não é influenciada por comissão.

O que você achou deste artigo?

Responda a Pergunta do Dia Teste seu conhecimento e mantenha sua streak. Crie seu Dev Card público Perfil dev compartilhável em um único link.

Depois dessa formação...

Veja vagas em tecnologia →

Vagas relacionadas

Ver todas as vagas →
DA

Escrito por

Dagmar

Publicado em

Ver perfil do autor

COMPARTILHAR