ChatGPT, Copilot e Claude: como desenvolvedores estão programando em 2026

No projeto hands-on, usaremos agentes de IA com GitHub Copilot para resolver desafios reais de refatoração, contexto e automação.

O que as pesquisas mostram

A "Developer Survey 2025 do Stack Overflow" mostrou que cerca de 80% dos desenvolvedores já usam IA no fluxo de trabalho.

Em pesquisa com desenvolvedores de Brasil, EUA, Alemanha e Índia, 97% disseram já ter usado ferramentas de IA para código. No Brasil, 61% perceberam aumento de qualidade no código.

Como a IA evoluiu no desenvolvimento

A IA generativa, como a conhecemos, se popularizou com o ChatGPT. Em poucos anos, avanços mudaram a forma de desenvolver software: modelos mais fortes, contexto maior, padrões abertos e agentes capazes de ler repositórios, executar comandos, testar e abrir PRs. Em 2026, o foco é menos "pedir código" e mais "delegar tarefas completas"¹.

Os devs continuam programando, só que agora operam um fluxo de trabalho com agentes.

ℹ️ Nota ¹Atenção: uma tarefa deve ser uma unidade pequena que gera valor dentro do sistema. Ela deve conter detalhes e critérios de aceite, não apenas uma frase genérica como "crie um sistema de finanças". Seja específico!

Muito além do chat: programação agêntica

Esse termo, criado recentemente, descreve a forma mais produtiva de usar IA em 2026.

Você lidera um parceiro de desenvolvimento, baseado em IA, que tem acesso a todo o projeto e realiza alterações diretamente na IDE. Vamos ver como isso está funcionando.

Como era no chat

Antes, era comum usar o ChatGPT ou chats de IA assim:

A IA funcionava como consultor rápido: sugeria código e explicava conceitos, mas o dev fazia tudo manualmente.

Esse fluxo tinha muito atrito:

• copiar e colar código
• reformular prompts
• ajustar contexto manualmente
• repetir o ciclo várias vezes

A IA ajudava, mas não participava do ambiente de desenvolvimento.

O uso de agentes atualmente

Em 2025 e 2026, o paradigma mudou: programação agêntica. A IA atua como agente dentro do projeto, capaz de:

• ler o repositório
• entender o contexto
• implementar funcionalidades
• rodar testes
• refatorar código
• abrir pull requests

Tudo de forma semiautônoma.

Com contexto e um terminal via Tools², você não pede mais "escreva essa função". Você diz:

"Implemente essa história de usuário no projeto."

E o agente executa o fluxo completo.

Percebe a diferença entre os dois diagramas?

A IA executa o trabalho repetitivo, enquanto o humano foca em:

• decisões arquiteturais
• regras de negócio
• validação das soluções

Pedir para a IA fazer commit e abrir PR já é realidade em muitas empresas.

ℹ️ Nota ²Tools são as ferramentas embutidas na plataforma de IA. As mais comuns, embutidas na maior parte delas, são terminal, browser e leitor de arquivos.

Trabalhando com IA no modo agente

Programar no modo agêntico não é largar tudo na mão do modelo. Também não é ficar preso em um chat lateral pedindo trechos soltos de código.

Você ganha maturidade e técnica à medida que entende o funcionamento. Ao instalar uma plataforma de IA na sua IDE, já é possível visualizar o modo agente, a exemplo do GitHub Copilot:

Ao submeter uma tarefa para o agente, você verá que ele lê todo o projeto, procura referências do seu pedido e realiza alterações imediatamente para sua revisão. Você está lidando com um "desenvolvedor virtual".

Nesse momento, surgem reflexões como:

• Eu já uso a IA dessa maneira, o que há de diferente em 2026?
• Na minha empresa, temos uma biblioteca específica de autenticação. Como ele sabe que deve usá-la?
• Ao fazer novas funcionalidades, preciso colocar logs de DEBUG e INFO padronizados. Tenho que avisar em todos os prompts?
• Ao realizar testes unitários, preciso incrementar a cobertura até chegar a 70%. Se eu não pedir todas as vezes, ele não faz. O que fazer?
• Passo muito tempo corrigindo o que a IA fez. Ela nunca entende corretamente meu projeto.

Garanto que é possível resolver todos esses pontos. Para isso, trabalhamos com quatro pilares importantes:

• PROMPT: instruções claras e específicas que você envia ao agente para guiar sua execução
• AGENTS.md: arquivo que documenta regras, padrões e contexto do projeto para agentes de IA
• SKILL.md: habilidades customizadas que ensinam o agente a executar tarefas complexas do seu fluxo
• MCP: Model Context Protocol, padrão aberto para conectar agentes a ferramentas e dados externos

Em nosso artigo, vamos entrar em detalhes sobre os AGENTS.md, que talvez sejam a maior tendência do momento nessa nova forma de custom agents. Eles são agentes especializados em tarefas específicas do seu projeto, como testes, refatoração ou documentação, cada um com suas próprias regras e comportamentos definidos em arquivos separados.

Aplicando IA em um projeto

Vamos exercitar um cenário muito comum na maior parte das empresas. Utilizaremos um projeto que já existe, mas que precisa de refatoração e da adição de novas funcionalidades.

Você pode encontrar esse projeto aqui, no repositório do nosso blog.

Durante a nossa jornada a seguir, vamos utilizar o GitHub Copilot. É importante que você realize seu cadastro e configuração em uma IDE suportada. O plano gratuito NÃO será suficiente, mas é possível testar gratuitamente por 30 dias ou obter uma licença de estudante. Acesse aqui a página oficial.

O projeto

Estamos falando de uma aplicação WEB, escrita em Java com Spring Boot, que realiza o cadastro de desenvolvedores interessados em Inteligência Artificial no país.

Nossa aplicação se chama dev-xp-ai.

Quando foi construída, devido à sua simplicidade, foi pensada com apenas uma única classe de controller que faz tudo: recebe a requisição, valida os dados e grava no banco de dados. Uma clara falha de construção, mesmo para uma aplicação simples.

Para continuar, você vai precisar fazer o clone ou download do nosso projeto disponível no GitHub do blog. Acesse aqui o commit inicial do projeto e vamos partir dele.

Stack do projeto:

• Java 25
• Maven
• Spring Boot 4.0.2
• Spring Web
• Spring JDBC
• H2 Database

Em seguida, importe seu projeto na IDE de sua preferência, como Spring Tools, IntelliJ ou VSCode, e vamos começar. É importante que ela suporte GitHub Copilot, que é a plataforma com suporte a agentes que vamos usar. Faça o download, cadastro e configuração clicando aqui.

Roadmap das alterações

Para explorar o poder da IA, vamos seguir este passo a passo:

1. Criando os testes unitários
2. AGENTS.md ao resgate: testes unitários de qualidade
3. Refatorar o controller para camadas (Controller, Service e Repository) usando um agente

Antes de continuar, você precisa saber que a IA generativa é uma tecnologia que produz resultados não determinísticos, ou seja, as respostas que você vai obter serão um pouco diferentes das minhas.

1. Criando os testes unitários

Já com a IDE aberta, você encontra nossa “GodClass”, a faz-tudo em DevController.java.

Clique aqui para visualizar o projeto nesta etapa inicial.

Ela possui mais de 300 linhas, mas ainda não vamos refatorá-la. Afinal, toda alteração no código passará por um agente de IA. Isso é importante para garantir o funcionamento da aplicação e não quebrar o comportamento do sistema.

Você vai abrir a extensão do GitHub Copilot para digitar o primeiro prompt do passo a passo. Estou usando o IntelliJ, mas todas as IDEs são similares. Selecione a opção Agent e use o modelo Claude Haiku 4.5.

Agora, envie este prompt para o agente:

Copiar
Crie os testes unitários da minha classe.

Você verá movimentações no terminal. Ele fará a criação das classes, a execução dos testes e tentará resolver problemas automaticamente. Porém, para mim, ele demorou cerca de 5 minutos para terminar. Aconteceram vários erros, e eu gastei minha janela de contexto trafegando informações inúteis para o propósito dos testes que eu queria. Vamos entender os problemas:

• Ele tentava executar um comando do shell Linux no PowerShell do Windows

• Incluiu dependêcias que eu não queria no meu <code>pom.xml</code>

• Criou todos os testes em inglês

• Usou o Jackson para transformar um objeto em String para o teste, mas eu queria a String diretamente

• Foram criadas quase 1000 linhas de teste, mas qual é a cobertura de testes? Ninguém disse ao agente que seria necessário atingir um percentual de cobertura, por isso isso não foi feito. Ele é reativo, fará o que for pedido e, muitas vezes, alucinar? se não for solicitado corretamente.

Foi um caos. Será que ajudou ou atrapalhou?

Erramos em muitas coisas, dentre elas o básico: o prompt. O prompt poderia estar mais detalhado, impor limites e exemplos, mas e se outro desenvolvedor, menos cuidadoso, não se preocupar com isso? Como padronizar um agente de IA em empresas com centenas de funcionários?

Também erramos no modelo de IA. Usamos o “Claude Haiku 4.5”, um modelo barato, mas que produz resultados ruins em blocos de código grandes ou em repositórios modernos, como o nosso com Spring Boot 4.x.

1. AGENTS.md ao resgate, equipe de especialistas

O arquivo AGENTS.md é uma convenção que se consolidou para documentar como seu projeto deve ser entendido por agentes de IA.

Diferentemente do README.md, voltado para desenvolvedores humanos e que explica como instalar, configurar e usar o projeto, o AGENTS.md é voltado para agentes de IA e descreve como o código está organizado e quais regras seguir ao gerar ou modificar código.

Nele, você descreve:

• arquitetura do sistema
• padrões de código adotados
• convenções de nomenclatura
• regras de negócio importantes

Quando esse arquivo existe na raiz do projeto, agentes como o GitHub Copilot conseguem entender melhor o contexto antes de gerar código.

Em 2026, um novo padrão emergiu: em vez de um único arquivo grande, por que não ter agentes especialistas em áreas diferentes, como testes, documentação, refatoração e muito mais?

No nosso projeto, vamos trabalhar com 2 custom agents. São eles:

• test.agent.md
• refactor.agent.md

Vamos começar com o agente de testes. Para isso, crie uma pasta no diretório do seu projeto chamada .github e, dentro dela, crie o arquivo test.agent.md. Nesse arquivo, cole o conteúdo abaixo:

test.agent.md Após colar o conteúdo, deixe a classe DevController.java aberta, abra a barra lateral do GitHub Copilot, selecione o nosso novo agente test e altere o modelo para Claude Sonnet 4.6. Entenda: o agente é um especialista em um assunto, mas sua fundação, seu “conhecimento de mundo”, é o modelo. A combinação certa traz os melhores resultados.

Agora, novamente, coloque o texto abaixo:

Copiar
Crie os testes unitários da minha classe.

Após alguns minutos processando, “Voilà”, um resultado excelente!

Copiar
@Test
@DisplayName("Deve normalizar email para lowercase e fullName para title case")
void deveNormalizarCamposQuandoCriarDeveloper() throws Exception {
    String payloadComCaseMixto = """
            {
                "fullName": "JOAO CARLOS SILVA",
                "email": "JOAO@EXAMPLE.COM",
                "nickname": "joao.dev",
                "uf": "mg",
                "yearsOfExperience": 2,
                "primaryLanguage": "JAVA",
                "interestedInAi": false,
                "skills": ["spring boot"]
            }
            """;
    mockMvc.perform(post("/developers")
                    .header("correlationId", CORRELATION_ID)
                    .contentType(MediaType.APPLICATION_JSON)
                    .content(payloadComCaseMixto))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.email").value("joao@example.com"))
            .andExpect(jsonPath("$.fullName").value("Joao Carlos Silva"))
            .andExpect(jsonPath("$.uf").value("MG"))
            .andExpect(jsonPath("$.primaryLanguage").value("Java"));
}

Não é à toa. É orientação, regra, política e contexto aplicados à Inteligência Artificial. Se você voltar ao nosso arquivo test.agent.md, verá que ele:

1. Dá contexto do projeto e das tarefas do agente
2. Possui ciclo de feedback curto e seguro a cada alteração
3. Padroniza idioma e semântica
4. Transforma a IA no guardião dos testes do projeto

Visualize as alterações desse commit aqui.

Os problemas que tivemos inicialmente se foram. O investimento de tempo para criar o nosso custom agent não se paga apenas neste projeto, mas também em outros projetos, dado que esses agentes podem ou não ser agnósticos. Podemos facilmente usar esse agente de testes em todas as nossas aplicações.

1. Refatorar o controller para camadas (Controller, Service e Repository) usando um agente

Bem, chegamos. Talvez aqui você fique um pouco assustado 👀. Heheh, é realmente PODEROSA a refatoração que estamos prestes a fazer.

Novamente, vamos criar um arquivo em .github/refactor.agent.md com o seguinte conteúdo:

refactor.agent.md

Abra a classe DevController.java e, desta vez, selecione o agente de refatoração:

Cole o prompt:

Copiar
Refatore o código da minha classe.

⚠️ Essa etapa pode demorar um pouco mais. Caso o chat trave, clique no botão de “stop”, digite “continue” no prompt e envie para o agente retomar de onde parou.

Após a execução, quando eu olho, ainda não consigo acreditar: em 5 minutos, este é o resultado:

A nossa GodClass se transformou em um projeto profissional e, o melhor de tudo, com as políticas e os contextos definidos em refactor.agent.md, o seu resultado será semelhante, apesar de a IA generativa não ser determinística. Legal, né?

Veja os pacotes gerados.

O que as empresas buscam

O uso de IA cresce de startups a Big Techs. Como isso afeta profissionais em busca de destaque?

Esta vaga de Tech Lead no Grupo Boticário ilustra bem:

"Eficiência e Eficácia: Potencializar os times de Engenharia através de IA Generativa e práticas de FinOps, otimizando o uso de recursos em nuvem e o ciclo de entrega. Pragmatismo sem overengineering."

Duas palavras-chave: "potencializar" (objetivo) e "overengineering" (risco). Desenvolvedores experientes ampliam boas decisões com IA. Quem não domina os fundamentos tende a criar soluções confusas e caras de manter.

🤖 Dica Muitos evitam IA por medo de perder o emprego. Erro. A IA elimina tarefas repetitivas e potencializa quem a usa bem. Mais código gera mais funcionalidades, mais usuários, maior receita e demanda por mais profissionais.

A mensagem de 2026 é clara: empresas buscam quem desenvolve com inteligência, delegando tarefas repetitivas à IA e focando em resolver problemas complexos, tomar decisões arquiteturais e entregar valor de negócio.

Conclusão

Bom, pessoal, se você chegou ao final deste artigo, quero te convidar a continuar explorando novas formas de integrar a inteligência artificial ao seu fluxo de trabalho. Nós sabemos que o mercado está mudando, e quem acompanha esse movimento gera transformação por onde passa.

Este artigo é a pontinha do iceberg para você potencializar suas entregas.

O código completo está no repositório do blog, separado em três commits:

1. Projeto inicial
2. Criação dos testes
3. Refatoração

Fontes

• https://stackoverflow.blog/2025/12/29/developers-remain-willing-but-reluctant-to-use-ai-the-2025-developer-survey-results-are-here/
• https://github.blog/news-insights/research/survey-ai-wave-grows/
• https://agents.md/
• https://github.blog/ai-and-ml/github-copilot/how-to-write-a-great-agents-md-lessons-from-over-2500-repositories/
• https://github.com/features/copilot?locale=pt-BR
• https://www.linkedin.com/jobs/view/4379241896