70% Completion Trap: Desafio final do 30% para codificação assistida por IA

Depois de estar profundamente envolvido no desenvolvimento assistido por IA nos últimos anos, notei um fenômeno interessante. Embora os engenheiros relatem ganhos significativos de produtividade com o uso da IA, o software real que usamos diariamente não parece ser significativamente melhor. O que está acontecendo aqui?

Acho que sei o motivo, e a resposta revela alguns fatos básicos sobre desenvolvimento de software que precisamos enfrentar. Vou compartilhar minhas descobertas.

Como os desenvolvedores realmente usam a IA

Observei dois padrões diferentes na forma como as equipes se desenvolvem com IA. Nós os chamamos de "guias" e "iteradores". Ambos ajudam os engenheiros (e até mesmo os usuários não técnicos) a preencher a lacuna entre a ideia e a execução (ou MVP).

Facilitador: Do zero ao MVP

Ferramentas como Bolt, v0 e IA de captura de tela para código estão revolucionando a maneira como iniciamos novos projetos. Essas equipes geralmente:

• Comece com um projeto ou um conceito preliminar
• Use a IA para gerar uma base de código inicial completa
• Obtenha um protótipo funcional em horas ou dias, não em semanas!
• Foco na validação e iteração rápidas

Os resultados podem ser impressionantes. Recentemente, vi um desenvolvedor independente usando Parafuso Transformei o design do Figma em um aplicativo da Web funcional em um período muito curto de tempo. Ele ainda não está pronto para produção, mas é bom o suficiente para receber o feedback inicial do usuário.

Iteradores: desenvolvimento diário

O segundo campo usa os aplicativos Cursor, Cline, Copilot e WindSurf ferramentas como essa para os fluxos de trabalho de desenvolvimento diários. É menos dramático, mas potencialmente mais transformador. Esses desenvolvedores são:

• Uso de IA para conclusão de código e sugestões
• Aproveitamento da IA para tarefas complexas de reconfiguração
• Gerar testes e documentação
• Usar a IA como um "programador de pares" para resolver problemas

Mas o problema é o seguinte: embora ambas as abordagens possam acelerar significativamente o desenvolvimento, elas têm custos ocultos que não são imediatamente visíveis.

O custo oculto da "velocidade da IA"

Quando você vê um engenheiro sênior usando Cursor talvez Copiloto Parece mágica quando se trata de ferramentas de IA como essa. Elas podem criar um recurso inteiro em minutos, incluindo testes e documentação. Mas observe com atenção e você perceberá algo crítico: elas não seguem apenas os conselhos da IA. Elas estão constantemente:

• Refatoração do código gerado em módulos menores e mais focados
• Adicionar o tratamento da condição de borda ausente da IA
• Aprimoramento das definições de tipos e interfaces
• Questionamento das decisões de arquitetura
• Adicionar tratamento abrangente de erros

Em outras palavras, eles estão aplicando anos de sabedoria de engenharia conquistada a duras penas para moldar e restringir o resultado da IA. A IA está acelerando suas implementações, mas é a experiência deles que manterá o código sustentável.

Os engenheiros juniores geralmente perdem essas etapas críticas. É mais provável que eles aceitem o resultado da IA, o que leva ao que eu chamo de "código de castelo de cartas" - parece completo, mas quebra sob estresse no mundo real.

paradoxo intelectual

Essa é a coisa mais contra-intuitiva que encontrei: o fato de as ferramentas de IA ajudarem mais os desenvolvedores experientes do que os iniciantes. Isso parece retrógrado - a IA não deveria democratizar a codificação?

A realidade é que a IA é como ter um desenvolvedor júnior muito ansioso em sua equipe. Eles podem escrever códigos rapidamente, mas precisam de supervisão e correção constantes. Quanto mais você souber, melhor poderá orientá-los.

Isso cria o que chamo de "paradoxo do conhecimento":

• Os idosos usam a IA para acelerar o que já sabem fazer
• Equipe júnior tentando usar IA para aprender o que fazer
• Os resultados foram muito diferentes

Vejo engenheiros seniores usando a IA para:

• Prototipagem rápida de ideias que eles já entendem
• Gerar implementações básicas que podem ser aprimoradas posteriormente
• Explorar alternativas para problemas conhecidos
• Automatizar tarefas rotineiras de codificação

Ao mesmo tempo, a equipe júnior frequentemente:

• Aceitação de soluções incorretas ou desatualizadas
• Falta de considerações importantes sobre segurança e desempenho
• Dificuldade para depurar o código gerado pela IA
• Criação de sistemas vulneráveis que não compreendem totalmente

Problema 70%: O paradoxo da curva de aprendizado da IA

Um tweet recente que chamou minha atenção capta perfeitamente o que tenho observado na área: não engenheiros que codificam com IA se deparam com obstáculos frustrantes. Eles podem concluir o 70% em uma velocidade alarmante, mas, no final, o 30% se torna um exercício de retorno decrescente.

Essa "pergunta 70%" revela algumas informações importantes sobre o estado atual do desenvolvimento assistido por IA. Inicialmente, o progresso parecia incrível: você podia descrever o que queria e uma ferramenta de IA como v0 ou Bolt gerava um protótipo funcional que parecia impressionante. Mas então a realidade se impôs.

Modo de retrocesso em duas etapas

Em seguida, geralmente ocorre um padrão previsível:

• Você tentou corrigir um pequeno erro.
• A IA sugeriu uma mudança que parecia razoável
• Essa correção quebrou outra coisa.
• Você pediu à IA para corrigir um novo problema.
• Isso, por sua vez, levanta duas questões
• repetidamente

Esse ciclo é especialmente doloroso para os não engenheiros, porque eles não têm os modelos mentais para entender o que de fato deu errado. Quando um desenvolvedor experiente encontra um erro, ele pode inferir possíveis causas e soluções com base em anos de reconhecimento de padrões. Sem esse histórico, você está basicamente jogando um jogo de pega-pega com um código que não entende completamente.

A continuação do paradoxo do aprendizado

Há um problema mais profundo aqui: as mesmas coisas que tornam as ferramentas de codificação de IA fáceis de usar para quem não é engenheiro - elas representam sua capacidade de lidar com a complexidade - podem, na verdade, prejudicar o aprendizado. Quando o código "aparece" e você não entende os princípios subjacentes:

• Você não está desenvolvendo habilidades de depuração.
• Você está perdendo a oportunidade de aprender os padrões básicos
• Não é possível extrapolar as decisões arquitetônicas
• Você tem dificuldade para manter e desenvolver códigos

Isso cria uma dependência em que você precisa voltar sempre à IA para resolver problemas, em vez de desenvolver sua própria experiência para lidar com eles.

Lacuna de conhecimento

Os não engenheiros mais bem-sucedidos que já vi usando ferramentas de codificação de IA adotaram uma abordagem híbrida:

1. Prototipagem rápida com IA
2. Dedique tempo para entender como o código gerado funciona
3. Aprender conceitos básicos de programação ao usar IA
4. Criação da base de conhecimento passo a passo
5. Usar a IA como uma ferramenta de aprendizado, não apenas como um gerador de código

Mas isso requer paciência e dedicação - o oposto do que muitos esperam conseguir com o uso de ferramentas de IA.

Implicações para o futuro

O "problema 70%" sugere que as ferramentas atuais de codificação de IA devem ser consideradas como tal:

• Acelerador de protótipos para desenvolvedores experientes
• Auxílios de aprendizagem para aqueles comprometidos com a compreensão do desenvolvimento
• Gerador de MVP para validação rápida de ideias

Mas eles ainda não são a solução para democratizar a codificação que muitos esperam. Por fim, o 30% - a parte que torna o software pronto para produção, sustentável e robusto - ainda requer conhecimento real de engenharia.

A boa notícia? À medida que as ferramentas melhoram, a lacuna pode diminuir. Mas, por enquanto, a abordagem mais pragmática é usar a IA para acelerar o aprendizado, e não substituí-lo completamente.

O que realmente funciona: um modelo prático

Depois de observar dezenas de equipes, eis o que vi funcionar de forma consistente:

1. modelo "AI first draft

• Deixe a IA gerar uma implementação básica
• Revisão manual e refatoração para modularidade
• Adicionar tratamento abrangente de erros
• Escreva testes abrangentes
• Documentação das principais decisões

2. modelo de "diálogo contínuo

• Inicie um novo bate-papo com IA para cada tarefa diferente
• Mantendo o contexto focado e minimizado
• Revisão e envio frequente de alterações
• Manter um circuito de feedback estreito

3. modelo "Trust but verify" (confie, mas verifique)

• Geração inicial de código usando IA
• Revisão manual de todos os caminhos críticos
• Casos extremos de testes automatizados
• Realizar auditorias de segurança regulares

Olhando para o futuro: o verdadeiro futuro da IA?

Apesar desses desafios, estou otimista quanto ao papel da IA no desenvolvimento de software. O segredo é entender em que ela é realmente boa:

1. Aceleração conhecida
   A IA é boa em nos ajudar a perceber padrões que já entendemos. É como ter um programador gêmeo infinitamente paciente que pode digitar muito rápido.
2. Explore as possibilidades
   A IA é excelente para criar rapidamente protótipos de ideias e explorar diferentes abordagens. É como ter uma caixa de areia na qual podemos testar conceitos rapidamente.
3. Rotina de automação
   A IA reduz bastante o tempo gasto com amostras e tarefas regulares de codificação, permitindo que nos concentremos em problemas interessantes.

O que isso significa para você?

Se estiver apenas começando com o desenvolvimento assistido por IA, aqui estão minhas recomendações:

1. Comece pequeno
   • Use a IA para tarefas isoladas e bem definidas
   • Revisar cada linha do código gerado
   • Criação progressiva de maior funcionalidade
2. Manutenção da modularidade
   • Divida tudo em documentos pequenos e focados
   • Manter interfaces claras entre os componentes
   • Documentar os limites de seu módulo
3. Confie em sua experiência.
   • Use a IA para acelerar, não para substituir seu julgamento
   • Questionamento do código gerado que não parece correto
   • Mantenha seus padrões de engenharia

O surgimento da engenharia de software de agentes

Ao entrarmos em 2025, o cenário do desenvolvimento assistido por IA está mudando radicalmente. Embora as ferramentas atuais tenham mudado a maneira como fazemos protótipos e iterações, acredito que estamos no limiar de uma mudança ainda mais importante: o surgimento da engenharia de software baseada em agentes.

O que quero dizer com "agente"? Esses sistemas não respondem apenas a solicitações, eles planejam, executam e iteram soluções com autonomia cada vez maior.

Se tiver interesse em saber mais sobre proxies, incluindo minhas opiniões sobre Cursor/Cline/v0/Bolt, talvez você se interesse por mim.

Já estamos vendo os primeiros sinais dessa evolução:

De respondentes a colaboradores

A ferramenta atual espera principalmente por nossos comandos. Mas dê uma olhada nos recursos atualizados, como o Anthropic na seção Claude (a) o uso de computadores na Cline A capacidade de iniciar navegadores e executar testes automaticamente. Não se trata apenas de autocompletamentos glorificados - eles realmente entendem a tarefa e tomam a iniciativa de resolver o problema.

Pense na depuração: esses agentes não se limitam a sugerir correções:

• Identificação proativa de possíveis problemas
• Colocar o conjunto de testes em funcionamento
• Inspeção de elementos da interface do usuário e captura de capturas de tela
• Propor e implementar correções
• Verificar se a solução funciona (isso pode ser um grande problema)

O futuro multimodal

As ferramentas de última geração podem fazer mais do que apenas lidar com o código - elas podem ser perfeitamente integradas:

• Compreensão visual (capturas de tela da interface do usuário, modelos, diagramas)
• diálogo de linguagem oral
• Interação com o ambiente (navegador, terminal, API)

Essa capacidade multimodal significa que eles podem entender e usar o software como os humanos fazem - de modo geral, não apenas no nível do código.

Autônomo, mas guiado

O principal insight que obtive com o uso dessas ferramentas é que o futuro não é a IA substituir os desenvolvedores, mas sim a IA se tornar um colaborador cada vez mais capaz de tomar a iniciativa e, ao mesmo tempo, respeitar a orientação e o conhecimento humano.

As equipes mais eficazes em 2025 podem ser aquelas que aprendem:

• Definir limites e diretrizes claros para seus agentes de IA
• Crie padrões arquitetônicos avançados nos quais os agentes possam trabalhar
• Criação de ciclos de feedback eficazes entre as pessoas e os recursos de IA
• Manter a supervisão humana e, ao mesmo tempo, aproveitar a autonomia da IA

Ambiente de desenvolvimento que prioriza o inglês

Como aponta Andrej Karpathy:

"O inglês está se tornando a nova linguagem de programação mais quente."

Essa é uma mudança fundamental na forma como interagiremos com as ferramentas de desenvolvimento. A capacidade de pensar com clareza e de se comunicar com precisão em linguagem natural está se tornando tão importante quanto as habilidades tradicionais de codificação.

Essa mudança para o desenvolvimento de agências exigirá que desenvolvamos nossas habilidades:

• Design de sistemas e pensamento arquitetônico mais sólidos
• Melhor especificação e comunicação dos requisitos
• Maior foco na garantia de qualidade e validação
• Aprimoramento da colaboração entre pessoas e recursos de IA

O retorno do software como engenharia?

Embora a IA torne mais fácil do que nunca a criação rápida de software, corremos o risco de perder algo fundamental: a arte de criar experiências realmente refinadas e com qualidade para o consumidor.

Demonstração de armadilhas de qualidade

Isso está se tornando um padrão: as equipes estão usando IA para criar rapidamente demonstrações impressionantes. O caminho feliz está funcionando muito bem. Os investidores e as redes sociais estão entusiasmados com isso. Mas e quando os usuários reais começam a clicar? É aí que as coisas desandam.

Eu vi isso com meus próprios olhos:

• Mensagens de erro que não significam nada para o usuário comum
• Casos extremos que levam a falhas no aplicativo
• Estados de IU bagunçados que nunca foram limpos
• Ignorando completamente a acessibilidade
• Problemas de desempenho em dispositivos mais lentos

Esses não são apenas bugs do P2 - eles são a diferença entre um software que as pessoas toleram e um software que as pessoas adoram.

A arte perdida do embelezamento

A criação de um verdadeiro software de autoatendimento - do tipo em que os usuários não precisam entrar em contato com o suporte - exige uma mentalidade diferente:

• Obcecado por desinformação
• Testes em uma conexão lenta
• Lida elegantemente com todos os casos extremos
• tornar a funcionalidade detectável
• Testes com usuários reais, geralmente não técnicos

Essa atenção aos detalhes (talvez) não pode ser gerada pela IA. Ela vem da empatia, da experiência e de uma profunda preocupação com o ofício.

Renascimento do software pessoal

Acredito que veremos um renascimento no desenvolvimento de software pessoal. Como o mercado está inundado de MVPs gerados por IA, os produtos que se destacarão serão aqueles criados por desenvolvedores que são

• Orgulho de seu trabalho artesanal
• Atenção aos pequenos detalhes
• Foco na experiência completa do usuário
• Criado para casos extremos
• Criação de uma verdadeira experiência de autoatendimento

Ironicamente, as ferramentas de IA podem, na verdade, estar contribuindo para esse renascimento. Ao lidar com tarefas rotineiras de codificação, elas permitem que os desenvolvedores se concentrem no que é mais importante: criar um software que realmente sirva e encante os usuários.

sublinhar

A IA não está melhorando nosso software, porque a qualidade do software (talvez) nunca tenha sido limitada principalmente pela velocidade de codificação. As partes mais difíceis do desenvolvimento de software - compreender os requisitos, projetar sistemas passíveis de manutenção, lidar com casos extremos, garantir a segurança e o desempenho - ainda exigem julgamento humano.

O que a IA faz é nos permitir iterar e experimentar mais rapidamente e, ao explorar mais rapidamente, pode levar a soluções melhores. Mas somente se mantivermos nossa disciplina de engenharia e usarmos a IA como uma ferramenta, não como um substituto para as boas práticas de software. Lembre-se: o objetivo não é escrever mais código mais rapidamente. Em vez disso, o objetivo é criar um software melhor. Usada com sabedoria, a IA pode nos ajudar a fazer isso. Mas ainda cabe a nós entender o que significa "melhor" e como alcançá-lo.

Qual é a sua experiência com o desenvolvimento assistido por IA? Gostaria muito de ouvir suas histórias e percepções nos comentários.