À medida que a AI escreve mais código, por que ainda precisamos entendê-lo

Usei AI para criar um produto que ajuda as pessoas a entender código.

Mas algo interessante aconteceu: quanto mais complexo o produto ficava, menos eu mesmo o entendia.

Comecei a desenvolver o FiboCode por volta de julho de 2025. Vibe Coding estava crescendo, e todos falavam em usar AI para ajudar as pessoas a escrever código e reduzir o custo do desenvolvimento de software. Uma ideia surgiu naturalmente:

Se a AI pode ajudar as pessoas a escrever código, ela também poderia ajudá-las a entendê-lo?

O custo de escrever código continua caindo, mas compreender um projeto desconhecido ainda é difícil. Isso é especialmente verdadeiro diante de uma base de código que existe há anos, com estrutura de diretórios complexa, dependências entre módulos, decisões históricas de design e muitas convenções. Muitas vezes, só descobrir por onde começar leva bastante tempo.

O FiboCode nasceu dessa ideia simples: usar AI para analisar código e gerar documentos e diagramas de relações correspondentes, permitindo então navegar entre código, documentos e diagramas.

Naquele momento, era apenas uma ferramenta de análise de código.

Mais tarde, para facilitar perguntas sobre o código, adicionei um Agent simples. Para melhorar a leitura, integrei o Monaco Editor. Com um editor, navegação de código, referências de símbolos e diagnósticos de linguagem também pareciam necessários, então acrescentei suporte a LSP.

Depois de oferecer leitura, editar era o próximo passo natural.

Quando o FiboCode passou a modificar código, comecei a pensar em como fazer o Agent entender realmente um projeto, em vez de julgá-lo pelos poucos arquivos abertos. Aos poucos adicionei MCP e Skills, esperando dar à AI acesso às convenções de design, ao contexto arquitetônico e ao histórico do projeto.

Depois percebi que muitos desenvolvedores já estavam confortáveis com Agent CLI como Claude e Codex. Talvez não precisassem de outro Agent integrado, mas de uma interface criada para revisar os resultados do trabalho de um Agent.

Por isso o FiboCode ganhou um terminal e melhorias específicas para a saída de Agent CLI, conectando referências de arquivos, alterações de código e etapas de execução no terminal ao código, aos documentos e aos diagramas de relações.

Assim, um simples módulo de análise de código cresceu, peça por peça, até se tornar um sistema cada vez mais complexo.

Comecei a esquecer o projeto que eu havia criado

Programar com auxílio de AI é realmente conveniente.

Embora os primeiros modelos não fossem tão capazes quanto hoje, eu revisava cuidadosamente o código gerado, muitas vezes várias vezes. Observava como os módulos eram divididos, como os dados fluíam e por que a arquitetura havia sido projetada daquela forma.

O projeto passou por muitas refatorações. Algumas foram extensas, mas como eu conhecia os detalhes do design na época, nenhuma acabou quebrando o projeto.

Então os modelos ficaram mais capazes, a geração acelerou e a base de código começou a crescer rapidamente.

Pouco a pouco percebi que já não conseguia lembrar os detalhes de design do código que havia revisado apenas uma ou duas semanas antes.

No início, isso me assustou um pouco.

Era meu próprio projeto. Cada funcionalidade tinha vindo de mim, mas eu já não lembrava por que cada módulo havia sido desenhado daquele jeito nem como cada lógica funcionava.

Com o tempo, percebi que talvez fosse apenas algo que eu precisava aceitar.

Já não era o pequeno projeto do início. Em um sistema suficientemente complexo, ninguém consegue lembrar todos os detalhes de implementação. O que importa talvez não seja guardar cada linha na cabeça, mas saber onde está o núcleo, como os módulos colaboram, quais partes podem ser confiadas à AI com segurança e quais precisam ser compreendidas com cuidado.

Eu precisava aprender a escolher.

Tinha de encontrar os caminhos críticos em meio ao código, construir uma visão mental ampla do sistema e então fornecer à AI requisitos e restrições mais precisos.

Visto assim, o FiboCode também estava me ajudando a construir o FiboCode.

Eu usava AI para desenvolver o produto; o produto se tornava mais útil e, por sua vez, me ajudava a entendê-lo e aprimorá-lo mais rápido. Esse ciclo positivo era realmente empolgante e uma razão importante para eu continuar trabalhando nele por tanto tempo.

Mas, além da empolgação, eu me perguntava com frequência:

O que restava para mim nesse processo de desenvolvimento?

Quando entreguei cada vez mais do meu pensamento à AI

Durante muito tempo, desenvolvi gradualmente um hábito.

Sempre que havia um requisito, eu o entregava primeiro à AI.

Sempre que havia um problema, pedia primeiro à AI que investigasse.

Depois que ela propunha uma solução, eu verificava. Se falhasse, devolvia o resultado e pedia nova análise e correção.

Às vezes um dia inteiro passava enquanto eu descrevia requisitos, explicava o estado de um bug e devolvia resultados de testes repetidamente.

Parecia que a AI realizava quase todo o trabalho intelectual difícil, enquanto meu papel se reduzia a definir requisitos e devolver resultados.

Naquele período, senti algo com muita força:

Parecia que eu já não tinha muito valor.

Mas, ao continuar, descobri que não era bem assim.

Desenvolvendo com AI, encontrei tecnologias que antes não teria escolhido estudar e muitas abordagens de implementação. Passei a observar deliberadamente o design e a arquitetura antes da implementação concreta.

Em algumas tarefas, eu percebia rapidamente que o escopo era pequeno e que a AI poderia concluí-las diretamente.

Mas, quando uma tarefa atravessava vários módulos ou afetava a estrutura central, eu sabia que não era tão simples. A AI podia ver apenas o requisito atual, sem entender por que um design histórico existia nem quais áreas seriam afetadas indiretamente.

Também havia código que eu precisava entender quase por completo, mesmo que a AI pudesse escrevê-lo, pois uma falha ali teria consequências difíceis de controlar.

Parei de insistir em entender todos os detalhes, mas fiquei mais atento aos limites, dependências, riscos e mudanças do sistema.

Talvez o trabalho humano não tenha desaparecido; ele apenas esteja mudando.

No passado, entendíamos um sistema implementando seu código nós mesmos.

No futuro, talvez gastemos menos esforço com implementação repetitiva e mais atenção com arquitetura, processo, restrições, verificação e evolução de longo prazo.

O fato de a AI conseguir escrever não significa que podemos confiar

Não sei se a AI realmente poderá substituir especialistas humanos e fazer todo o trabalho de programação no futuro.

Essa certamente é uma questão técnica, mas acredito que também seja uma questão de confiança.

Mesmo que um dia a AI gere sozinha um sistema muito complexo, isso não significa que estaremos dispostos a confiar nele sem reservas.

Quando o sistema se comportar de forma inesperada, saberemos por quê?

Conseguiremos localizar o erro?

Conseguiremos verificar a correção?

Outra pessoa conseguirá assumir o sistema?

Se ele causar danos graves, quem será responsável?

Essas questões não são resolvidas completamente apenas elevando a precisão do modelo de 99% para 99,9%.

Para aplicações de baixo risco e fáceis de substituir, podemos tolerar mais caixa-preta. Se a função funciona e o desenvolvimento é rápido o bastante, talvez não precisemos nos importar com cada detalhe.

Mas, para software fundamental como sistemas operacionais e bancos de dados, ou sistemas financeiros, elétricos e de outras áreas com grande impacto social, é difícil aceitar uma caixa-preta que não possa ser compreendida, auditada ou assumida.

Esses sistemas ainda precisam de pessoas para mantê-los.

Elas não precisam escrever cada linha, mas alguém deve saber aproximadamente como o sistema funciona, onde estão os riscos críticos e por onde começar quando algo dá errado.

Por isso acredito cada vez mais que a compreensão de código não desaparecerá com a ascensão da programação por AI.

Ela apenas assumirá outra forma.

No passado, precisávamos entender código para escrevê-lo.

No futuro, talvez precisemos entendê-lo para verificar, manter, assumir e continuar evoluindo sistemas criados por AI.

As tarefas iniciais que estão desaparecendo

Compreender código tem outro significado.

A AI está reduzindo alguns cargos iniciais centrados em implementação repetitiva e tarefas básicas. Mesmo quando os empregos não desaparecem, grande parte do trabalho antes dado a iniciantes é automatizada primeiro pela AI.

Isso não é favorável a quem está começando.

O caminho tradicional de crescimento de um engenheiro costuma começar com tarefas simples: corrigir um bug, ler uma pequena parte do código, concluir uma funcionalidade pequena e então participar gradualmente de módulos e projetos de sistema mais complexos.

Os iniciantes constroem pouco a pouco sua compreensão de projetos reais por meio dessas tarefas aparentemente sem importância.

Mas agora a AI pode concluir diretamente essas tarefas fundamentais.

Se restarem menos portas de entrada para treinar iniciantes, de onde virão os engenheiros seniores do futuro?

Essa foi outra razão pela qual criei o FiboCode.

Eu também sou novo na profissão. Na primeira vez em que enfrentei uma base de código legada e complexa, muitas vezes me senti completamente perdido.

Havia arquivos e diretórios demais. Serviços chamavam uns aos outros, enquanto tipos, interfaces e configurações estavam espalhados. Você sabia que a resposta estava em algum lugar do código, mas não onde começar, quais partes importavam ou quais eram apenas detalhes.

Muitas vezes, a dificuldade real não era entender uma linha específica, mas não ter um mapa completo.

Eu sempre quis uma ferramenta que primeiro analisasse a estrutura de todo um projeto e dissesse onde estavam os módulos centrais, como o código se conectava e quais áreas uma mudança poderia afetar.

Assim, iniciantes não dependeriam inteiramente de alguém guiando passo a passo nem precisariam tatear repetidamente por bases desconhecidas.

Uma ferramenta assim não substitui o processo de crescimento, mas reduz a barreira de entrada em um sistema complexo.

À medida que a AI corta o antigo caminho de crescimento, espero que o FiboCode possa reconectar uma rota.

Não necessariamente um atalho que pule todos os fundamentos, mas algo como um mapa, um sistema de navegação e um caminho que ajude iniciantes a construir mais rápido um modelo mental do sistema.

O código registra apenas o presente

Durante o desenvolvimento, descobri outro problema.

Entregar uma tarefa diretamente à AI e deixá-la explorar o repositório sozinha pode levar a um raciocínio incompleto.

A AI vê o código atual, mas talvez não saiba por que um módulo foi desenhado de certo modo nem que está indiretamente ligado a outros arquivos aparentemente sem relação.

O código geralmente mostra como um sistema é agora, mas tem dificuldade em explicar por que ele se tornou assim.

No início, considerei colocar todas essas informações em comentários do código.

Depois decidi que não era adequado.

Grandes quantidades de contexto de design, raciocínio histórico e explicações de mudanças tornariam os arquivos inchados e poderiam fornecer à AI muito contexto irrelevante para a tarefa atual. Comentários explicam bem a lógica local, mas não carregam facilmente toda a evolução de um projeto.

Por isso criei uma série de Fibo Skills.

Elas registram convenções, designs, o processo de implementação e explicações dos diff, deixando um rastro mais completo de cada mudança.

Espero que, quando a AI modificar código no futuro, ela veja não apenas o estado atual, mas também entenda o que aconteceu antes e por que certos designs foram preservados.

Quando a história de evolução de um projeto se torna rastreável, a AI pode compreendê-lo de forma mais completa.

Isso também se tornou uma das direções do FiboCode:

Ele foi criado para ajudar pessoas a entender código. Depois, começou também a ajudar a AI a entendê-lo melhor.

Como o FiboCode se tornou o que é

Olhando para trás, o FiboCode não foi projetado desde o início para ser o que é hoje.

Começou como um módulo simples de análise. Depois vieram documentos e diagramas de relações, um Agent, um editor e serviços de linguagem. Aos poucos, ganhou edição de código, terminal, MCP e Skills.

Eu queria oferecer a Agent CLI uma experiência de revisão semelhante à do Cursor e transformar os documentos e relações produzidos pela análise em contexto realmente útil para a AI.

Ele evoluiu de um módulo simples para um sistema complexo, e esse crescimento contínuo refletia silenciosamente a expansão da sequência de Fibonacci.

Foi daí que vieram o nome FiboCode e a imagem do caracol.

A concha do caracol contém a beleza matemática da espiral dourada.

Ele não se move muito rápido, mas continua crescendo para a frente.

O FiboCode não tenta fazer as pessoas voltarem a escrever cada linha à mão nem excluir a AI.

Pelo contrário. Ele aceita que a AI escreverá cada vez mais código e, com essa premissa, espera ajudar as pessoas a continuar entendendo, verificando, mantendo e assumindo seus próprios sistemas.

Em uma época em que todos buscam geração mais rápida, ainda espero que possamos desacelerar de vez em quando.

Para entender por que o código funciona como funciona e por que um sistema se tornou o que é hoje.

E para redescobrir a alegria que primeiro nos atraiu à programação.