Existe uma pergunta que poucos fazem em voz alta: quanto custa escrever código hoje?
A resposta vai incomodar algumas pessoas.
Quase nada.
Código sempre foi o ativo mais superestimado de qualquer startup. A gente passa semanas em reuniões de arquitetura, meses refatorando abstrações, anos discutindo se aquele service layer estava bem posicionado — tudo isso para defender algo que, no fundo, é uma aposta sobre o passado.
Porque código é uma aposta. Quando você escreve um sistema, você está codificando o que entendia do problema naquele momento. Naquele dia, com aquelas hipóteses, com aquele nível de conhecimento sobre o domínio.
O problema é que o domínio não para. Os usuários não param. O negócio não para.
E o código, por definição, para.
Há algo de filosófico nessa equação.
Quanto mais você aprende sobre um problema, mais você percebe que o código que escreveu quando sabia menos não pode mais te representar. Não porque era ruim — era o melhor que você podia fazer naquele momento. Mas porque você cresceu, e o código não.
Software não envelhece como vinho. Envelhece como leite.
Você puxa um fio hoje, os testes passam, tudo parece bonito — mas daqui duas semanas você descobre que esse fio estava ligado num lugar completamente diferente do que você imaginava. E o lugar onde ele estava ligado? Ninguém lembra mais por quê.
E então chegou a IA.
Não para roubar empregos. Mas para tornar explícito algo que já estava acontecendo: o custo marginal de produzir código tende a zero.
Hoje, qualquer LLM competente escreve código melhor do que a maioria dos desenvolvedores, em menos tempo, com menos erros, sem ego, sem sprint planning, sem reunião de refinamento.
O valor do desenvolvedor não está mais no código que ele produz. Está no entendimento que ele tem do domínio. No julgamento sobre o que construir. Na capacidade de reconhecer o que não deveria existir.
O código em si virou commodity.
E como qualquer commodity — ferro, petróleo, trigo — quando o preço cai, os padrões de comportamento mudam completamente.
Quando código era caro, era racional defender o que existia.
Migrar um sistema legado envolvia meses, risco, equipe, custo. Fazia sentido acumular dívida técnica, fazer remendos, manter arquiteturas que já não serviam — porque a alternativa era cara demais.
Esse cálculo mudou.
Quando código é barato, a manutenção de um sistema ruim deixa de ser uma escolha pragmática e vira uma escolha emocional. Você não está preservando valor. Você está preservando familiaridade.
Existe um segundo fator que a maioria das pessoas ignora.
Quando você reescreve algo pela segunda vez, você sabe coisas que não sabia na primeira.
Você sabe quais abstrações eram prematuras. Quais problemas eram reais e quais eram hipóteses que nunca aconteceram. Você sabe o que os usuários realmente fazem, não o que você achava que fariam. Você sabe onde as exceções se acumulam, onde o sistema sofre, onde a equipe perde mais tempo.
Reescrever não é repetir o passado. É aplicar uma versão mais inteligente de você sobre um problema que você finalmente entende.
Aqui na AbacatePay, nossa codebase já está indo para a quarta versão.
Isso soa como confissão de falha. Não é.
Cada versão foi uma destilação. Cada versão aplicou mais conhecimento, mais clareza, mais entendimento do que importa e do que não importa. O resultado: menos linhas de código, mais garantias, mais performance, mais segurança, mais facilidade de manutenção.
Quando você joga fora, você não perde o que construiu. Você carrega o aprendizado e deixa os erros para trás.
Não existe romance em manter código antigo.
Existe um apego irracional que a gente disfarça de pragmatismo. “Não podemos jogar fora — vai custar muito.” Mas quanto custa manter? Quanto custa cada novo desenvolvedor que entra e passa semanas entendendo uma arquitetura que nem os veteranos conseguem mais explicar? Quanto custa cada bug que vive nas profundezas de um código que ninguém quer tocar?
O código que você tem medo de apagar é exatamente o código que você deveria apagar.
Velocidade é o único moat que importa para startups.
E velocidade não é sobre contratar mais devs. Não é sobre mais sprints, mais tickets, mais cerimônias de planning.
Velocidade é sobre quão rápido você consegue aprender com o real. Quão rápido você testa uma hipótese, abandona o que não funciona, e itera com o que funciona.
Uma codebase que você entende completamente, escrita com o conhecimento de hoje, usando as ferramentas de hoje — essa codebase itera mais rápido do que qualquer legado bem intencionado.
Então sim. Jogue tudo fora quando precisar.
Não como reflexo de ansiedade ou busca por novidade. Mas como decisão estratégica: quando o custo de manter supera o custo de reconstruir, quando o código não consegue mais expressar o que você entende do problema, quando a velocidade caiu a ponto de comprometer o negócio.
O código foi barato de escrever. Vai ser barato de reescrever.
O que não é barato é o conhecimento que você acumulou sobre o domínio. Esse vai contigo.
Precisa de ajuda? ajuda@abacatepay.com
Construiu algo legal? Marca a gente. @abacatepay em todas as redes.