Professional Software Developers Don't Vibe, They Control: AI Agent Use for Coding in 2025
Este artigo investiga como desenvolvedores de software experientes em 2025 utilizam agentes de IA, revelando que, em vez de delegar o trabalho totalmente, eles controlam estrategicamente o comportamento do agente e colaboram seletivamente com eles para manter a alta qualidade do software e a integridade do design.
Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo
No mundo da criação de software, um novo tipo de ajudante chegou. Durante anos, os programadores utilizaram ferramentas que agiam como um autocompletar avançado, sugerindo a próxima palavra ou linha de código enquanto digitavam. Mas recentemente, essas ferramentas evoluíram para algo mais autônomo. Elas agora são agentes capazes de ler projetos inteiros, fazer alterações, executar testes e corrigir seus próprios erros sem a necessidade de digitação humana constante. A promessa desses agentes é sedutora: a de que uma pessoa poderia simplesmente descrever uma ideia de software em linguagem comum e observar a máquina construí-lo inteiramente por conta própria. Essa ideia desencadeou uma onda de entusiasmo, com alguns afirmando que o futuro da programação envolve o "vibe coding" — um estado onde o desenvolvedor confia completamente na máquina, deixando-a fluir através do trabalho enquanto o humano recua para aproveitar a jornada. No entanto, à medida que essas ferramentas se tornam mais poderosas, uma questão crítica permanece: essa visão de delegação total realmente funciona para as pessoas que constroem o software que gerencia nosso mundo moderno?
Para encontrar a resposta, uma equipe de pesquisadores voltou sua atenção para desenvolvedores de software experientes. Eles queriam ver como profissionais reais, aqueles com anos de treinamento e responsabilidade por sistemas complexos, realmente interagem com esses novos agentes. A equipe conduziu dois estudos distintos para obter uma imagem clara. Primeiro, observaram treze desenvolvedores experientes enquanto trabalhavam em tarefas reais, observando como usavam as ferramentas em seu ambiente natural. Em seguida, entrevistaram outros noventa e nove desenvolvedores experientes para colher uma visão mais ampla de seus hábitos e sentimentos. Os pesquisadores buscavam a verdade por trás do hype: esses especialistas estão deixando as máquinas assumirem o volante, ou estão eles mesmos pilotando o navio?
Os resultados foram claros e consistentes. Apesar do fascínio de deixar um agente fazer tudo, os desenvolvedores profissionais não praticam o "vibe coding". Eles não entregam o controle e esperam pelo melhor. Em vez disso, tratam essas ferramentas poderosas como colaboradoras que exigem supervisão rigorosa. Os desenvolvedores no estudo valorizaram os agentes por um motivo principal: velocidade. As ferramentas os ajudavam a escrever código mais rápido e a lidar com tarefas tediosas e repetitivas que, de outra forma, os atrasariam. No entanto, esse desejo por eficiência nunca veio às custas da qualidade. Os desenvolvedores permaneciam profundamente preocupados com a confiabilidade, segurança e estrutura do software que estavam construindo. Como sabiam que um pequeno erro poderia causar uma falha de grande escala, recusaram-se a deixar os agentes trabalharem cegamente.
A maneira como esses profissionais controlavam os agentes era metódica e deliberada. Antes de pedir que um agente escrevesse uma única linha de código, eles frequentemente criavam um plano detalhado, dividindo o trabalho em etapas pequenas e gerenciáveis. Eles não pediam à máquina para construir um sistema inteiro de uma só vez. Em vez disso, davam uma instrução específica, esperavam o resultado e, então, verificavam o trabalho cuidadosamente. Se o agente tentasse instalar uma ferramenta que o desenvolvedor não desejava, ou se o código parecesse desorganizado, o desenvolvedor o interrompia e corrigia o curso. Eles tratavam os agentes como um assistente muito inteligente, porém inexperiente, que conhecia as regras da linguagem, mas não entendia o contexto específico do projeto. Os desenvolvedores forneciam esse contexto, oferecendo instruções claras, apontando para arquivos específicos e explicando exatamente o que era necessário.
Essa supervisão cuidadosa estendia-se à forma como os desenvolvedores verificavam o trabalho. Eles não simplesmente aceitavam o código produzido pelos agentes. Eles liam todas as alterações, executavam testes para ver se o software realmente funcionava e usavam ferramentas de depuração para rastrear quaisquer erros. Em muitos casos, os desenvolvedores descobriram que os agentes tentavam fazer coisas demais ou ficavam presos em loops, exigindo que o humano interviesse e corrigisse a direção. Os pesquisadores descobriram que os desenvolvedores eram mais bem-sucedidos quando usavam os agentes para tarefas diretas, como escrever testes básicos, criar estruturas de código padrão ou atualizar documentação. Estas eram áreas onde as regras eram claras e o risco de um erro grave era menor. No entanto, quando se tratava de tarefas complexas, como projetar a arquitetura geral de um sistema, lidar com lógica de negócio sensível ou corrigir bugs profundos em códigos antigos, os desenvolvedores recuavam. Eles sabiam que essas áreas exigiam julgamento humano e uma compreensão profunda da situação específica que a máquina não possuía.
O sentimento dos desenvolvedores foi surpreendentemente positivo, mas com uma condição crucial. Eles gostavam de trabalhar com os agentes e achavam o processo menos estressante do que programar sozinhos, mas apenas porque permaneciam no comando. Eles descreveram a experiência como uma parceria onde o humano fornecia a visão e a direção, enquanto o agente lidava com o trabalho pesado de escrever o código. Sentiam um senso de alívio ao saber que a máquina poderia lidar com as partes entediantes, mas também sentiam um forte senso de responsabilidade para garantir que o produto final estivesse correto. Eles não viam os agentes como substitutos para sua própria expertise, mas sim como ferramentas que amplificavam suas próprias habilidades. Um desenvolvedor comparou a experiência a dirigir um carro de alto desempenho: era rápido e emocionante, mas o motorista ainda precisava manter as mãos no volante e os olhos na estrada.
Em última análise, o estudo revela que o futuro do desenvolvimento de software profissional não é sobre deixar as máquinas assumirem o controle. É sobre um novo tipo de colaboração onde os humanos permanecem como os arquitetos e os agentes servem como os construtores. A ideia de que um desenvolvedor poderia simplesmente descrever um projeto e se afastar enquanto a máquina o constrói não é como os profissionais experientes trabalham hoje. Eles sabem que a qualidade do software depende de supervisão humana, planejamento claro e da capacidade de detectar erros antes que eles se tornem problemas. À medida que essas ferramentas continuam a melhorar, o papel do desenvolvedor está mudando de um escritor de cada linha de código para um gestor de sistemas inteligentes. A máquina pode estar ficando mais inteligente, mas o humano continua sendo aquele que decide o que será construído e como será feito.
Afogado em artigos na sua área?
Receba digests diários dos artigos mais recentes que correspondam às suas palavras-chave de pesquisa — com resumos técnicos, no seu idioma.