- A GenAI (LLM) está aumentando a produtividade dos desenvolvedores com recursos de geração e assistência automática de código
- Já existiram no passado ferramentas de “codificação sem necessidade de programar”, mas, no fim, o processo real de engenharia de software ainda tem uma complexidade própria
- Desde o lançamento do ChatGPT, a velocidade de evolução das ferramentas de IA tem sido notável, mas, em vez de transformar radicalmente todo o processo, elas têm atuado mais como um meio de encurtar bastante algumas etapas dentro de um problema dado
As formas reais de uso pelos desenvolvedores se dividem em dois grupos
- Bootstrappers
- Usam ferramentas como Bolt, v0 e Screenshot-to-code para implementar rapidamente um novo projeto ou MVP
- A IA gera uma base de código inicial completa a partir de um design (como no Figma) ou mesmo de um conceito mais bruto
- Criam protótipos funcionais em poucos dias ou até em poucas horas
- Mesmo sem estar pronta para produção, a abordagem é forte para validar ideias
- Priorizam validação rápida e iteração
- Iterators
- Usam Cursor, Cline, Copilot, WindSurf e outros no fluxo diário de desenvolvimento
- Utilizam IA para autocompletar código, fazer refatorações complexas e gerar testes e documentação
- Deixam testes complexos, documentação e refatorações nas mãos da IA, mas verificam continuamente o resultado
- Usam a ferramenta como uma espécie de “programador em par” para ajudar na resolução de problemas
- Repetem o processo de selecionar, editar e complementar as sugestões da IA até chegar ao melhor código possível
O problema dos 70%: a dificuldade dos “últimos 30%” — o paradoxo da curva de aprendizado da IA
- A IA consegue produzir código rapidamente até cerca de 70%, mas os 30% finais acabam sendo um grande gargalo
- Surge um ciclo ruim em que, ao corrigir um bug pequeno, outra parte quebra
- Especialmente para não especialistas ou pessoas júnior, é fácil aceitar todo o código sugerido pela IA e acabar provocando problemas em cascata
- Elas têm dificuldade para entender por que as mudanças sugeridas pela IA causam problemas
- Desenvolvedores seniores experientes conseguem inferir rapidamente a causa dos bugs, reestruturar o código e ainda considerar segurança e desempenho para cobrir o que a IA deixou passar
- Mesmo usando a IA de forma ativa, revisam e refatoram sem parar para transformar o resultado em “código sustentável”
- Se pessoas júnior ou não desenvolvedoras aceitarem sem pensar o código gerado pela IA, existe o risco de surgir um “código castelo de cartas”, que desmorona facilmente em ambiente real de operação
- Paradoxo do conhecimento
- Pessoas seniores conseguem implementar rapidamente com a IA problemas que já conhecem
- Pessoas júnior precisam aprender com a IA, mas, sem base suficiente, enfrentam grande dificuldade na depuração e na validação
Padrões de uso eficazes
- Rascunho da IA seguido de refinamento
- Quando a IA faz a implementação inicial, a pessoa revisa, refatora e testa manualmente
- Adiciona manualmente tratamento de erros e casos de exceção, além de reforçar testes automatizados e processos de revisão para aumentar a confiabilidade
- Reforça modularidade, tratamento de erros, definição de tipos e projeto de arquitetura para manter o código sustentável
- Manter conversas por unidade de trabalho
- Em vez de passar um contexto enorme de uma vez, usa prompts independentes para problemas menores e obtém respostas mais focadas
- Revisa e faz commit das mudanças com frequência, incorporando feedback em ciclos curtos
- Abordagem de “confiar, mas verificar”
- A IA faz o rascunho, mas lógica crítica, tratamento de erros e questões de segurança ficam sob responsabilidade humana
- Sempre escreve casos de teste e verifica cuidadosamente desempenho, segurança e solidez estrutural
Implicações para desenvolvedores
- Comece pequeno
- Experimente usar IA primeiro em tarefas pequenas e bem definidas, com escopo claro, e revise cuidadosamente o código gerado
- Antes de avançar para funcionalidades maiores, cuide bem dos testes e da documentação. Depois, expanda o escopo gradualmente
- Mantenha a modularização
- Separe adequadamente a base de código para evitar que o código produzido pela IA se misture estruturalmente de forma caótica
- Divida arquivos e funcionalidades em unidades menores e defina com clareza interfaces e fluxo de dependências
- Confie na experiência
- Use a IA como assistente, mas mantenha o julgamento final baseado na sua própria experiência
- É melhor desconfiar de código ou arquitetura suspeitos e seguir os padrões de engenharia
A ascensão da engenharia de software agentic
- Se antes as ferramentas de IA apenas respondiam a comandos gerando código, daqui para frente elas devem evoluir para o conceito de Agentic
- A IA agentic planeja, executa e valida objetivos por conta própria, operando com mais autonomia
- Claude (Anthropic), Cline e outros já vão além do simples autocompletar, abrindo o navegador automaticamente e executando testes
- O processo de depuração também muda
- O agente pode encontrar sozinho problemas potenciais, executar conjuntos de testes e até verificar o estado da UI para propor correções
- As ferramentas do futuro não vão lidar só com código
- Elas poderão entender e integrar vários canais de entrada, como capturas de tela de UI, diagramas e conversas por voz
- Nesse movimento, o papel do desenvolvedor será
- Deixar a IA trabalhar de forma criativa, mas mantendo-a guiada por humanos e operando dentro de uma arquitetura saudável
- Construir um forte ciclo de feedback entre humanos e IA
- Espera-se um modelo de colaboração em que humanos definem a direção geral e os objetivos, enquanto agentes cuidam das tarefas detalhadas
- Assim como se diz que “a linguagem de programação mais importante é o inglês”, ganha importância a capacidade de expressar requisitos em linguagem natural de forma clara e precisa
O artesanato do software vai voltar?
- Graças à IA, protótipos e demos podem ser criados rapidamente
- Mas, quando usuários reais começam a usar o software em ambientes variados e com edge cases, os problemas aparecem
- Mensagens de erro incompreensíveis para o usuário
- Ambientes especiais que provocam falhas (edge cases)
- Projetos que ignoram completamente acessibilidade (Accessibility)
- Problemas de desempenho em dispositivos lentos
- Detalhes de UI/UX que acabam definindo a qualidade
- Do ponto de vista do consumidor, para que um produto seja bem acabado, é preciso atenção aos detalhes e cuidado humano
- Se a IA reduzir o trabalho repetitivo, desenvolvedores poderão se concentrar mais nesse grau de acabamento
- Será possível dedicar mais tempo a áreas humanas e especializadas, como experiência do usuário, edge cases e tratamento de erros significativo
Reflexões adicionais
- O processo de engenharia de software abrange várias áreas, como planejamento, projeto, implementação, validação, monitoramento e manutenção, e hoje a IA melhora principalmente a área de “escrita de código”
- No passado, já houve tentativas com COBOL, Visual Basic e plataformas no-code de permitir que “não desenvolvedores também criem software facilmente”, mas, quando a complexidade aumentava, desenvolvedores experientes continuavam sendo necessários
- Quanto mais as ferramentas de LLM multiplicarem a quantidade de código, maior tende a ser a necessidade de engenheiros seniores em projetos complexos
- Desenvolvedores experientes que sabem usar IA podem aumentar ainda mais seu valor
- Em resumo, as ferramentas de IA parecem evoluir não para substituir completamente desenvolvedores, mas para tornar ainda mais fortes aqueles que têm insight e experiência
Reflexões adicionais (incluindo comentários do Gergely)
- Na engenharia de software, o peso da codificação em si nunca foi tão grande assim
- No passado, Fred Brooks classificava aproximadamente o tempo de trabalho em software como
- ⅓ planejamento
- ⅙ codificação
- ¼ testes de componentes e sistema
- ¼ testes de sistema (todos os componentes manualmente)
- Pela visão atual, o tempo de codificação (incluindo testes) aumentou, mas planejamento, revisão de código, monitoramento e rollout ainda ocupam uma parte importante
- 20% planejamento
- 40% codificação (código + testes)
- 20% revisão de código (código de outras pessoas)
- 20% preparação para produção + rollout + pequenas correções nesse período + monitoramento + alertas
- O processo de construir bom software
- 1. What: decidir o que construir
- Inclui brainstorming, design, testes com usuários e colaboração com gerentes de produto e stakeholders de negócio
- Em startups, essa etapa pode ser bem curta (“vamos fazer e ver a reação”)
- Em empresas já estabelecidas, pode levar mais tempo decidir o que construir para não confundir clientes existentes
- 2. How: planejar como construir
- Define concretamente como implementar o produto/funcionalidade/serviço
- Considera impacto na arquitetura, dependências, estratégia de testes e assim por diante
- Startups podem pular essa etapa e partir direto para a execução, mas, em organizações grandes, ignorar o desenho prévio pode gerar problemas depois
- A maioria das equipes usa Design doc, RFC, ADR etc. para passar por algum nível de planejamento
- 3. Build: implementar de fato
- Escrever em código a funcionalidade ou produto desejado e verificar se funciona corretamente
- 4. Verify: validar
- Antes de colocar em produção, verificar cuidadosamente se tudo funciona como esperado
- Especialmente em casos como serviços financeiros, onde uma falha pode causar consequências graves, o processo de QA precisa ser rigoroso
- 5. Ship it: publicar
- Fazer merge das mudanças e liberar para os clientes
- Existem várias formas de fazer deploy em produção
- 6. Monitoring and oncall: monitoramento e on-call
- Detectar e resolver imediatamente problemas no produto
- Também inclui ações posteriores para evitar que a mesma falha se repita
- 7. Maintain: manutenção
- Coletar reclamações e feedback dos usuários e decidir quais bugs corrigir e quais melhorias priorizar
- Também inclui filtrar feedback que pode ser ignorado
- 8. Migrate: migração
- Quando o próprio produto muda muito ou o stack tecnológico muda, pode ser necessária uma migração de grande porte
- Hoje, as ferramentas de IA ajudam muito na etapa “Build”, mas vale refletir o quanto serão úteis também nas outras 7 partes citadas acima
- Desde a década de 1960, existe o sonho de que “não desenvolvedores possam criar software sem desenvolvedores”
- COBOL, Visual Basic e no-code são alguns exemplos
- Dá para criar sites simples sem programar nada, mas, em produtos complexos, o trabalho de engenharia continua sendo necessário
- Quanto maior a expressividade, mais aumenta a complexidade, porque é preciso instruir a IA em detalhes sobre “como isso deve funcionar”
- Quanto mais código a IA produzir, maior pode se tornar a necessidade de engenheiros especialistas para manter esse código e lidar com a arquitetura
- Hoje, desenvolvedores seniores que aprendem a trabalhar com LLM tendem a ser mais produtivos e podem gerar mais valor para as empresas
Agentes de IA: uma promessa importante, mas também uma 'terra desconhecida' em 2025
- Dois anos após o lançamento dos LLMs, muitos desenvolvedores aprenderam a usar LLMs em codificação e engenharia de software
- LLMs têm contribuído muito em tarefas como prototipagem, migração para linguagens desconhecidas, verificação da precisão dos resultados e identificação de respostas incorretas (alucinações)
- Mas os agentes de IA ainda estão em estágio inicial
- Hoje, o agente disponível de forma mais geral é basicamente o Devin, que custa US$ 500 por mês e recebe avaliações mistas
- Com a entrada de capital de risco, espera-se o surgimento de mais ferramentas de agentes de codificação com IA
- Os preços também devem cair gradualmente
- O GitHub Copilot provavelmente disponibilizará ao público o Copilot Workspace, baseado em agentes, em 2025
- Também estão previstos lançamentos como o /dev/agents, fundado pelo ex-CTO da Stripe
- Agentes de IA buscam maior precisão aceitando respostas mais lentas (processo de “pensamento”) e custos mais altos
- Ainda não está claro o quanto isso realmente melhora a precisão e em quais casos de engenharia isso trará grandes ganhos de produtividade
Possível aumento da demanda por engenheiros de software experientes
- Pode haver necessidade de mais engenheiros de software experientes (sênior ou acima) do que hoje
- Eles conseguem lidar melhor com ferramentas de IA, sabem como é um “resultado excelente” e conseguem “comandar” com precisão
- Quando identificam geração incorreta de código, conseguem decidir quando parar o processo de geração e corrigir o código-fonte diretamente
- Com a ajuda das ferramentas de IA, muito mais código será escrito, e mais pessoas e empresas provavelmente criarão suas próprias soluções
- Mas, à medida que a complexidade crescer, serão necessários engenheiros experientes para controlá-la
- Empresas de tecnologia já estabelecidas também podem precisar de gente para lidar com o aumento de complexidade trazido pela IA
- Se engenheiros de software desenvolverem a capacidade de trabalhar com IA, poderão se tornar mais produtivos e mais valiosos
- Leva tempo para aprender a realmente “dominar” essas ferramentas, por isso é importante experimentar e aprender ativamente em um ambiente de ferramentas que muda rápido
11 comentários
É um texto realmente muito bom.
Concordo bastante com o último parágrafo, "possível aumento da demanda por engenheiros de software experientes". No fim das contas, a gente usa bem aquilo que conhece bem, não é? ^^
Como no caso do Expo 52, em áreas onde houve mudanças grandes recentemente, até um Claude inteligente não ajudou muito.
Ele ficava sugerindo código antigo e já descontinuado, e acabou mais atrapalhando do que ajudando.
No fim das contas, parece que para usar IA direito ainda é preciso ter o "olhar" treinado.
Só um detalhe: pelo que sei,
/dev/agentsnão é um agente de programação. Ainda não foi lançado, mas se descreve como um "SO para agentes de IA".Pessoalmente, acho e aposto que, no futuro (ou, dependendo do ponto de vista, no médio prazo), o papel de programador vai diminuir em todas as funções de engenharia, enquanto o papel de TPM vai se ampliar.
Como o Cursor escreve código melhor, ele será delegado a isso, e as pessoas provavelmente farão a maior parte do trabalho em uma camada mais abstrata acima disso.
Obrigado por compartilhar. Eu também escrevi recentemente um texto relacionado, e ele tem alguns pontos parecidos. https://www.stdy.blog/can-junior-beat-coding-agent/
Resumo: o futuro dos desenvolvedores na era da IA (versão otimista)
?? : Agora não precisa mais de desenvolvedor (versão de empresa fundo de quintal)
Meu Deus kkkkkkk
1+ kkk
kkk, nota 100