Há algum tempo venho falando sobre uma coisa que, para mim, ficou cada vez mais evidente depois que comecei a trabalhar intensamente com inteligência artificial:
a discussão sobre usar ou não IA no desenvolvimento de software já ficou para trás.
Hoje, para mim, ela faz parte do processo.
Não como um brinquedo para gerar meia dúzia de linhas de código. Não como uma máquina onde você escreve qualquer coisa e espera que um sistema inteiro apareça magicamente pronto. E muito menos como substituta para conhecimento técnico.
Ela virou uma ferramenta de trabalho.
E uma ferramenta absurdamente poderosa.
Recentemente vi o Fabio Akita falando sobre algo muito parecido. Ele comentou sobre como ainda é comum encontrar desenvolvedores publicando exemplos isolados de erros cometidos por modelos de IA.
“Olha a besteira que ela fez.”
“Olha esse código errado.”
“Olha esse bug.”
E isso acaba criando uma percepção curiosa: se a IA produz código com erro, então ela não é confiável.
O problema é que essa lógica ignora uma coisa bastante óbvia.
Código escrito por humanos sempre teve bugs.
Sempre.
Antes do ChatGPT, antes do Claude, antes do Codex e antes de qualquer agente de programação, nós já tínhamos sistemas quebrando em produção, vulnerabilidades de segurança, regressões, memory leaks, queries ruins, deploys problemáticos e decisões arquiteturais das quais alguém se arrependeria alguns anos depois.
Existe uma quantidade enorme de ferramentas criadas justamente porque seres humanos cometem erros desenvolvendo software.
Testes automatizados.
Code review.
Linters.
Análise estática.
CI/CD.
Ambientes de homologação.
Monitoramento.
Rollback.
Versionamento.
Nada disso surgiu por causa da inteligência artificial.
Tudo isso existe porque desenvolvimento de software sempre foi uma atividade sujeita a erro.
Por isso acho estranho quando alguém encontra um bug produzido por uma IA e apresenta aquilo como evidência definitiva de que não deveríamos confiar nela.
Se esse fosse o critério, provavelmente teríamos que parar de contratar desenvolvedores também.
A qualidade da IA depende muito de quem está usando
Essa talvez seja uma das coisas mais difíceis de aceitar nessa nova fase.
Quanto mais trabalho com IA, mais percebo que o resultado está profundamente relacionado com a capacidade de quem está conduzindo o processo.
Um desenvolvedor experiente não olha apenas para o código produzido.
Ele entende o contexto.
Sabe identificar uma decisão estranha.
Sabe quando aquela solução vai criar dívida técnica.
Consegue explicar a arquitetura.
Consegue quebrar um problema grande em etapas menores.
Sabe testar.
Sabe validar.
Sabe investigar quando alguma coisa não parece correta.
E principalmente: sabe dizer para a IA o que precisa ser feito, quais são as restrições e o que caracteriza um resultado aceitável.
Quando você coloca uma ferramenta extremamente poderosa nas mãos de alguém que já sabe fazer tudo isso, o resultado não é simplesmente “código feito por IA”.
É um profissional experiente trabalhando com uma capacidade de execução que simplesmente não existia alguns anos atrás.
É aí que as coisas começam a ficar interessantes.
Hoje consigo explorar soluções, analisar bases de código, criar testes, revisar implementações, investigar problemas, escrever documentação, refatorar sistemas e experimentar arquiteturas em uma velocidade que seria difícil imaginar pouco tempo atrás.
Não significa aceitar tudo que aparece na tela.
Significa justamente o contrário.
Significa aumentar a capacidade de experimentar e validar.
O apego ao conhecimento técnico
Mas existe outra parte dessa discussão que considero ainda mais interessante.
Durante muito tempo, principalmente na área de tecnologia, nosso conhecimento técnico também fez parte da nossa identidade.
Passamos anos aprendendo linguagens, frameworks, comandos, APIs, arquiteturas e dezenas de pequenos detalhes que separavam alguém experiente de alguém começando.
Era natural sentir orgulho disso.
Eu também sinto.
O problema aparece quando confundimos aquilo que sabemos fazer com aquilo que somos.
Porque, de repente, surge uma ferramenta capaz de fazer em segundos algo que você levou anos para aprender.
E isso mexe com as pessoas.
É desconfortável.
É muito mais confortável acreditar que a ferramenta é ruim.
Que o código é sempre uma porcaria.
Que ninguém que usa IA sabe programar.
Que desenvolvimento “de verdade” é escrever tudo manualmente.
Porque, se a ferramenta não presta, nada mudou.
Seu conhecimento continua ocupando exatamente o mesmo lugar que ocupava antes.
Só que as coisas mudaram.
E vão continuar mudando.
Acredito que parte da resistência que vemos hoje não seja exatamente uma discussão sobre qualidade de código.
É uma discussão sobre identidade profissional.
Existe um medo legítimo de que aquilo que durante anos diferenciou alguém profissionalmente esteja deixando de ser tão raro.
Mas talvez a conclusão esteja errada.
O conhecimento técnico não perdeu valor.
Ele mudou de função.
Antes, grande parte do valor estava na capacidade de executar.
Agora, cada vez mais, está na capacidade de entender, decidir, orientar e validar.
Saber escrever código continua importante.
Mas saber qual código deve existir provavelmente se tornou ainda mais importante.
Eu não quero competir com a ferramenta
Essa é talvez a maior mudança na minha maneira de enxergar desenvolvimento.
Eu não tenho interesse em provar que consigo escrever alguma coisa mais rápido que uma inteligência artificial.
Provavelmente não consigo.
Também não vejo sentido em transformar desenvolvimento em uma competição entre humano e máquina.
Quero usar tudo que estiver disponível para construir melhor.
Se uma IA consegue analisar milhares de linhas de código em poucos segundos, ótimo.
Se consegue escrever testes para uma funcionalidade que acabei de implementar, melhor ainda.
Se consegue apontar um cenário que eu não percebi durante uma revisão, excelente.
Isso não diminui meu trabalho.
Amplia.
Meu papel continua sendo entender o problema, conhecer o produto, tomar decisões, definir arquitetura, avaliar riscos e garantir que aquilo realmente faça sentido.
Só que agora tenho ferramentas muito mais poderosas para me ajudar durante esse processo.
IA não elimina responsabilidade
Também existe um erro no extremo oposto.
Usar IA não significa abandonar boas práticas.
Na verdade, acredito que quanto mais usamos IA, mais importantes algumas delas se tornam.
Testes automatizados continuam sendo importantes.
Versionamento continua sendo importante.
Code review continua sendo importante.
Observabilidade continua sendo importante.
Segurança continua sendo importante.
Arquitetura continua sendo importante.
A diferença é que agora temos uma ferramenta capaz de participar de praticamente todas essas etapas.
Inclusive revisando o próprio código que produziu.
Ou revisando código produzido por nós.
A questão nunca deveria ser:
“Foi um humano que escreveu ou foi uma IA?”
A pergunta deveria ser:
“Isso foi bem projetado, testado e validado?”
Porque software não fica melhor simplesmente porque alguém digitou cada linha manualmente.
Estamos entrando em outra forma de desenvolver software
Eu trabalho com desenvolvimento há bastante tempo e já vi muitas tecnologias chegarem acompanhadas de resistência.
Frameworks.
CMS.
Cloud.
Low-code.
Bibliotecas JavaScript.
Stack Overflow.
Open source.
Sempre existiu alguém dizendo que aquela nova camada faria os desenvolvedores saberem menos.
De certa forma, isso até aconteceu.
Hoje poucas pessoas precisam conhecer todos os detalhes de baixo nível necessários para construir uma aplicação web como alguém precisava conhecer décadas atrás.
E ainda assim construímos sistemas muito mais complexos.
Porque abstrações permitem que avancemos.
A inteligência artificial talvez seja simplesmente a maior abstração que já colocamos sobre o desenvolvimento de software.
Ela não elimina a necessidade de saber o que estamos fazendo.
Mas elimina uma quantidade enorme de trabalho mecânico entre ter uma ideia e conseguir executá-la.
E é por isso que considero IA praticamente indispensável hoje no meu processo de desenvolvimento.
Não porque ela seja perfeita.
Ela não é.
Eu também não sou.
Nenhum desenvolvedor é.
Mas porque, quando usada por alguém que entende o que está fazendo, ela amplia de maneira absurda nossa capacidade de produzir, revisar, aprender e experimentar.
Talvez daqui a alguns anos seja estranho lembrar que existiu uma época em que discutíamos se desenvolvedores deveriam ou não usar inteligência artificial.
Assim como hoje seria estranho discutir se um programador deveria usar autocomplete, documentação online ou controle de versão.
A tecnologia mudou.
O trabalho mudou.
E acredito que a pior decisão que podemos tomar agora é gastar energia tentando proteger a forma antiga de trabalhar apenas porque foi nela que aprendemos a ser bons.
Nosso conhecimento continua valendo.
Só precisamos aprender a usá-lo de uma maneira diferente.
