IA no desenvolvimento de software: como uso no dia a dia

Já faz alguns anos que ferramentas de IA começaram a aparecer no horizonte do desenvolvimento de software, mas foi a partir de 2023 que a coisa ficou séria de verdade. Não estou falando de autocomplete inteligente — estou falando de um par de programação que nunca dorme, não tem ego e processa contexto muito mais rápido do que qualquer colega humano.

Nesse post quero compartilhar como eu, como desenvolvedor backend com mais de 10 anos de experiência, incorporei essas ferramentas no meu fluxo de trabalho sem virar refém delas.

O antes e o depois

Antes de entrar em ferramentas específicas, deixa eu contextualizar o que mudou na prática.

Antes: abrindo 10 abas de documentação ao mesmo tempo, lendo Stack Overflow para lembrar da sintaxe de uma query específica, escrevendo testes repetitivos que seguem sempre o mesmo padrão, revisando manualmente código para encontrar inconsistências.

Depois: a maior parte dessas tarefas mecânicas virou conversa. Pergunto, recebo uma resposta contextualizada, reviso, ajusto, sigo em frente.

O ganho não é em velocidade bruta de digitação — é em tempo de raciocínio. Consigo chegar mais rápido na parte que realmente importa: a decisão de arquitetura.

GitHub Copilot no VS Code

O Copilot foi o primeiro que comecei a usar de forma consistente. Ele vive dentro do editor e aprende o contexto do que você está escrevendo.

O que funciona muito bem:

• Completar código boilerplate: migrations, factories, seeders no Laravel — quase escrevo sozinho.
• Sugerir testes: dada uma função, ele sugere casos de teste baseado na assinatura e no nome.
• Refatoração inline: seleciono um bloco, descrevo o que quero e ele reescreve.

O que precisa de atenção:

• Ele alucina APIs. Às vezes sugere métodos que não existem na versão que estou usando.
• Em código legado sem contexto suficiente, as sugestões ficam genéricas demais.

A regra que adotei: nunca aceito sugestão sem ler. Parece óbvio, mas é tentador apertar Tab no automático.

Claude como par de programação

O Claude (da Anthropic) virou meu principal companheiro para discussões mais profundas. Enquanto o Copilot é bom para completar código no editor, o Claude brilha quando preciso pensar em voz alta.

Casos de uso que mais uso:

Revisão de arquitetura

Coloco o problema, explico as restrições (performance, equipe, prazo) e peço uma análise crítica da minha proposta. Ele não só aponta problemas — explica o raciocínio por trás de cada ponto, o que facilita tomar a decisão final.

Explicar erros complexos

Quando um stack trace é críptico ou quando tenho um comportamento inesperado numa query SQL complexa, colar o contexto e descrever o sintoma economiza muito tempo.

Gerar documentação técnica

Dado um bloco de código, ele produz documentação no padrão que eu quero (PHPDoc, JSDoc, README) com bem menos atrito do que escrever do zero.

Fine-tuning e modelos locais

Recentemente comecei a explorar fine-tuning de modelos menores, como o Qwen 3 de 0.6B parâmetros, treinado com documentação do Laravel 13. A ideia é ter um modelo local que conheça o contexto do framework sem precisar enviar código para APIs externas.

Ainda é experimental, mas o potencial é enorme: um modelo que conhece os padrões do seu projeto, as convenções do time e a versão exata das dependências que você usa.

O que IA não substitui

Importante deixar claro o que esses modelos não fazem:

• Decisões de negócio: entender o domínio da aplicação, conversar com stakeholders, priorizar o que realmente importa.
• Revisão crítica de segurança: o modelo pode apontar alguns problemas óbvios, mas uma auditoria de segurança séria exige raciocínio contextual humano.
• Arquitetura evolutiva: saber quando parar de adicionar features e refatorar, ou quando uma abstração está servindo mais ao ego do que ao sistema.

Conclusão

IA no desenvolvimento não é sobre substituir o programador. É sobre eliminar o atrito das tarefas repetitivas para que sobre mais tempo e energia para o que exige criatividade e julgamento.

Meu conselho: comece pelo Copilot dentro do seu editor. Observe o que ele acerta e o que ele erra no seu contexto específico. Depois experimente um modelo de chat para discussões mais longas. Com o tempo você vai encontrar o equilíbrio certo entre assistência e autonomia.