Como uma pipeline de IA ajudou no desenvolvimento de um app para uma rede de Supermercados
Como uma pipeline de IA ajudou no desenvolvimento de um app para uma rede de supermercados A inteligência artificial mudou significativamente a forma como desenvolvemos software. Hoje, é possível delegar tarefas inteir
Como uma pipeline de IA ajudou no desenvolvimento de um app para uma rede de supermercados
A inteligência artificial mudou significativamente a forma como desenvolvemos software. Hoje, é possível delegar tarefas inteiras a agentes de programação, gerar implementações complexas e acelerar entregas que anteriormente exigiriam muito mais tempo.
Mas existe uma questão que começou a me chamar a atenção: como garantir que a velocidade proporcionada pela IA não comprometa a qualidade do software?
Foi tentando responder a essa pergunta que comecei a estruturar uma pipeline de desenvolvimento multiagente, utilizando Claude Code, no contexto de um projeto real.
Não foi um experimento isolado ou uma tentativa de criar uma arquitetura interessante apenas por curiosidade. A necessidade surgiu do próprio dia a dia de desenvolvimento, da quantidade de demandas, da complexidade do produto e da responsabilidade de entregar software com qualidade.
Mais do que acelerar a escrita de código, essa experiência acabou mudando minha maneira de participar do desenvolvimento de um produto.
O contexto: um projeto, centenas de demandas e uma equipe pequena
Atualmente trabalho na Automy AI, onde estamos desenvolvendo uma nova experiência de e-commerce para o Supernosso.
O projeto envolve uma transformação importante: estamos trazendo para dentro da Automy funcionalidades e responsabilidades relacionadas ao ecossistema de e-commerce que anteriormente eram operadas pela VTEX.
Isso envolve não apenas o desenvolvimento de um novo aplicativo, mas também a construção de um sistema administrativo para gerenciar essa operação.
No aplicativo, estamos propondo diversas melhorias na experiência dos clientes. Já no sistema administrativo, precisamos oferecer ferramentas para que as equipes do Supernosso consigam operar e gerenciar o negócio.
É um projeto que envolve diferentes frentes de desenvolvimento, regras de negócio, integrações e tecnologias.
Um detalhe importante é o tamanho da nossa equipe: somos apenas quatro pessoas diretamente envolvidas no desenvolvimento, sendo nosso CTO, um desenvolvedor pleno, eu, como desenvolvedor júnior, e um estagiário.
É um time pequeno para a dimensão do projeto.
Nos últimos três meses, acumulamos mais de 800 tarefas mapeadas no Evolve, nossa ferramenta de acompanhamento de demandas. São funcionalidades, correções, melhorias e ajustes necessários para construir e preparar o produto para o lançamento.
Estamos trabalhando com Go, Java e React, em diferentes partes do ecossistema.
E existe um detalhe que aumenta ainda mais a responsabilidade: estamos chegando à semana final de lançamento.
Nesse cenário, velocidade é importante, mas previsibilidade e qualidade são ainda mais importantes.
Precisávamos encontrar uma maneira de aumentar nossa capacidade de entrega sem comprometer a qualidade do software.
Foi nesse contexto que comecei a estruturar minha pipeline.
Minha primeira experiência utilizando Claude Code como ferramenta central
Essa também é uma experiência particularmente importante para mim: é a primeira vez que trabalho em um projeto utilizando Claude Code como ferramenta central do processo de desenvolvimento.
Não estamos falando apenas de utilizar IA para completar funções, gerar pequenos trechos de código ou tirar dúvidas durante a implementação.
Estou trabalhando com agentes que participam ativamente de diferentes etapas do desenvolvimento: planejamento, implementação, revisão e testes.
Confesso que, inicialmente, fiquei bastante inseguro.
Entregar praticamente todo o ciclo de desenvolvimento para uma ferramenta de IA exige uma mudança de mentalidade. Eu precisava confiar que o Claude Code conseguiria compreender as demandas, trabalhar dentro da arquitetura existente, implementar as funcionalidades e validar o próprio trabalho.
No começo, encontrar uma maneira produtiva de trabalhar assim não foi simples.
Muitas vezes, o tempo economizado na escrita de código acabava sendo consumido acompanhando a execução, corrigindo interpretações equivocadas, revisando implementações e tentando organizar o trabalho dos agentes.
Percebi que simplesmente delegar tarefas não seria suficiente.
Precisava estruturar um processo que permitisse trabalhar com IA de maneira consistente, especialmente considerando o volume de demandas que tínhamos pela frente.
Foi assim que comecei a construir minha pipeline.
Uma referência que me inspira
Antes de entrar na arquitetura, quero reconhecer uma pessoa que teve uma influência importante na construção dessa ideia: Pedro Lara.
Pedro é Google Developer Expert (GDE) e, além de ser uma referência técnica para mim, é um amigo muito importante na minha carreira e vida.
Tenho uma admiração enorme pela maneira como ele compartilha conhecimento, explora novas tecnologias e contribui para a comunidade de desenvolvimento. É alguém com quem aprendo e em quem me inspiro profissionalmente.
Uma das referências que influenciaram diretamente esta implementação foi o codelab Building a Production AI Code Review Assistant with Google ADK, que apresenta a construção de um assistente de revisão de código utilizando uma arquitetura multiagente.
O material demonstra como dividir responsabilidades entre agentes especializados, combinar análises com ferramentas determinísticas, executar testes e sintetizar resultados. Também explora um fluxo iterativo de correção, com novas tentativas e validações.
Foi uma referência importante para começar a pensar em como aplicar conceitos semelhantes ao meu contexto de desenvolvimento.
Quero deixar registrado esse crédito porque acredito que compartilhar conhecimento também significa reconhecer quem nos ajudou a chegar até determinada solução.
Referência: Building a Production AI Code Review Assistant with Google ADK — Google Codelabs
O problema: um agente não precisa fazer tudo
Quando começamos a utilizar ferramentas como Claude Code, é natural entregar uma tarefa diretamente ao agente e esperar que ele resolva tudo: entenda o problema, planeje a implementação, escreva o código, execute os testes e avalie o próprio resultado.
Isso funciona em muitas situações, especialmente em tarefas menores.
Entretanto, conforme o projeto cresce, algumas limitações começam a aparecer.
Um agente que implementa uma funcionalidade também é responsável por avaliar as próprias decisões. Ele pode deixar passar um problema arquitetural, interpretar incorretamente uma regra de negócio ou considerar satisfatória uma implementação que não atende completamente aos requisitos.
Existe também uma questão de contexto: quanto mais responsabilidades concentramos em um único agente, mais difícil pode ser controlar a qualidade de cada etapa.
Minha proposta foi separar essas responsabilidades.
Em vez de pedir que um único agente faça tudo, construí um fluxo em que cada agente recebe uma missão específica e entrega seu resultado para a próxima etapa.
A arquitetura: cada agente tem um papel
A pipeline possui um coordenador central e agentes especializados.
O coordenador é responsável por organizar o processo, distribuir tarefas, acompanhar os resultados e controlar as operações de Git e integração.
Os demais agentes executam atividades específicas.
1. Arquiteto
Antes de qualquer implementação, uma tarefa passa por um agente responsável pelo planejamento técnico.
Seu trabalho é compreender o escopo, analisar a estrutura existente, identificar os arquivos envolvidos, mapear dependências e propor uma estratégia de implementação.
Ele também classifica as tarefas de acordo com sua complexidade e risco.
A ideia é evitar que o desenvolvedor comece a programar sem compreender o que precisa ser feito.
2. Desenvolvedor
A implementação é dividida entre dois perfis:
- Desenvolvedor leve: responsável por tarefas de front-end, testes, ajustes mecânicos e implementações bem especificadas.
- Desenvolvedor pesado: responsável por mudanças mais sensíveis, como pagamentos, autenticação, segurança, integrações com ERP e migrations.
Essa separação também influencia a escolha do modelo utilizado.
3. Revisor
Depois da implementação, outro agente recebe o código para realizar uma revisão independente.
Um detalhe importante: o revisor não recebe a opinião do desenvolvedor sobre o que foi implementado. Ele analisa o diff em um contexto limpo, considerando o contrato da tarefa.
Seu objetivo não é sugerir melhorias cosméticas ou mudanças de estilo, mas encontrar defeitos concretos, explicar cenários de falha e apontar possíveis correções.
4. QA
A etapa de QA também possui dois perfis:
- QA simples: verifica critérios objetivos e listas fechadas, como códigos HTTP esperados, presença de campos e condições específicas.
- QA complexo: exercita fluxos completos na aplicação, procurando problemas em cenários reais de utilização.
A diferença é importante: conferir se um endpoint responde corretamente não é a mesma coisa que verificar se uma jornada inteira funciona.
Escolhendo o modelo certo para cada responsabilidade
Outro aprendizado importante foi perceber que nem toda tarefa precisa do modelo mais poderoso disponível.
A escolha precisa considerar o risco, a complexidade e o tipo de julgamento exigido.
Na minha configuração, a distribuição ficou assim:
| Responsabilidade | Modelo | Esforço |
|---|---|---|
| Arquiteto | Opus | High |
| Dev leve | Sonnet | Medium |
| Dev pesado | Opus | Medium |
| Revisor | Opus | High |
| QA simples | Haiku | Medium |
| QA complexo | Sonnet | High |
O princípio é utilizar mais capacidade onde um erro pode ter consequências maiores e modelos mais econômicos em atividades objetivas ou bem especificadas.
Também existe uma distinção importante: algumas atividades não precisam de inteligência artificial.
Verificar conflitos, validar migrations, identificar possíveis segredos no código e conferir determinadas regras de Git são tarefas que podem ser executadas por scripts.
Se uma regra pode ser validada deterministicamente, não precisamos gastar tokens pedindo a um LLM que faça isso.
Essa foi uma das decisões mais importantes da arquitetura.
Revisão não pode depender apenas da boa vontade do agente
Um dos mecanismos que considero mais interessantes é o controle de abertura de Pull Requests.
Não basta instruir um agente a revisar o código antes de abrir um PR. Instruções em prompts não são garantias de execução.
Por isso, implementei um mecanismo de controle que exige um marcador de revisão aprovada antes da abertura do Pull Request.
O fluxo funciona assim:
- O código passa pelas verificações automatizadas.
- Os testes relevantes são executados.
- O agente revisor analisa o código.
- O coordenador confere os apontamentos e descarta os que não se sustentam.
- Se aprovado, é gerado um marcador associado ao commit.
- Um hook verifica esse marcador antes de permitir a abertura do PR.
Existe uma regra importante: se o código mudar depois da revisão, o marcador anterior deixa de ser suficiente. Um novo commit precisa passar novamente pelo processo.
Isso transforma uma recomendação em uma condição efetivamente verificável.
O ciclo de correção
Encontrar um problema não significa que o processo precisa terminar.
Quando a revisão identifica problemas, a pipeline pode entrar em um ciclo de correção.
O desenvolvedor recebe os apontamentos, realiza os ajustes e o código volta a passar pelas verificações e pelos testes.
Esse processo possui um limite de duas rodadas.
A decisão de estabelecer um limite é importante porque agentes podem entrar em ciclos improdutivos, repetindo tentativas sem convergir para uma solução.
Quando o problema persiste, o fluxo para e escala a situação para análise humana.
A ideia não é criar autonomia ilimitada, mas permitir que a IA trabalhe dentro de limites conhecidos.
Paralelismo: várias tarefas, sem perder o controle
Além do fluxo individual, também implementei uma abordagem para trabalhar com tarefas independentes em paralelo.
O conceito é organizar uma frente de trabalho em ondas.
Cada tarefa recebe seu próprio worktree, branch e contexto de implementação. Assim, diferentes agentes podem trabalhar simultaneamente sem disputar o mesmo ambiente de código.
Depois, cada implementação passa por revisão e retorna ao coordenador para integração.
O coordenador é responsável por organizar os resultados, resolver conflitos, executar as verificações finais e conduzir a integração.
O paralelismo não significa simplesmente abrir vários agentes e esperar que tudo funcione. É necessário identificar dependências, antecipar conflitos e definir como as alterações serão integradas.
O maior ganho: mais tempo para entender o produto
Talvez essa seja a parte mais interessante de toda a experiência.
Quando comecei a utilizar Claude Code, minha preocupação estava muito concentrada em conseguir fazer os agentes implementarem as tarefas corretamente. Eu precisava acompanhar praticamente tudo, entender cada execução e garantir que o resultado estivesse adequado.
Com a evolução da pipeline, consegui organizar melhor esse processo.
Hoje, boa parte do trabalho operacional de planejamento técnico, codificação, revisão e testes pode ser conduzida pelos agentes dentro de um fluxo estruturado.
Isso não significa que deixei de participar das decisões técnicas. Pelo contrário: comecei a conseguir dedicar mais tempo a outras responsabilidades que também fazem parte do desenvolvimento de um produto.
Passei a participar diretamente de reuniões com o cliente, ajudando no discovery, entendendo necessidades e traduzindo problemas de negócio em soluções técnicas.
Também comecei a ter mais contato com as equipes do Supernosso e a compreender melhor como a operação funciona.
Hoje consigo entender muito mais sobre como diferentes setores utilizam o ecossistema de e-commerce, como são estruturadas as promoções, como funcionam os clusters de clientes e quais são as necessidades de cada área.
Esse contato muda a maneira como enxergamos uma tarefa.
Uma demanda que inicialmente parece ser apenas uma alteração em uma tela pode envolver uma regra operacional, uma estratégia comercial ou uma particularidade do comportamento dos clientes.
Quanto melhor compreendemos o contexto, melhores tendem a ser as soluções que construímos.
É nesse ponto que vejo o maior benefício da pipeline na minha rotina: ela me ajuda a transformar o tempo que antes era consumido pela execução operacional em tempo para entender melhor o produto e o problema que estamos tentando resolver.
Consigo participar mais das conversas, compreender as necessidades do cliente e levar esse contexto para a implementação.
A pipeline assume boa parte do trabalho de transformar essas necessidades em código, sempre com acompanhamento e validação.
Não vejo isso como uma substituição do desenvolvedor, mas como uma mudança na distribuição do nosso tempo e da nossa atenção.
Transformando a experiência em um projeto open source
Depois de desenvolver e utilizar essa abordagem no dia a dia, decidi organizar parte da implementação em um projeto público.
Assim nasceu o claude-dev-pipeline.
O repositório disponibiliza um plugin para Claude Code, com duas skills principais e seis agentes especializados.
As duas principais entradas são:
-
/review-pr: executa verificações determinísticas, revisão independente em contexto limpo, gera um relatório consolidado e permite até duas rodadas de correção. -
/parallel-dev: organiza tarefas independentes em ondas, utilizando worktrees, branches e agentes separados para implementação e revisão.
O projeto também inclui scripts de validação, configurações e testes automatizados.
Uma das decisões importantes foi disponibilizá-lo sob a licença MIT, permitindo que outras pessoas conheçam, adaptem e utilizem a implementação.
Não considero o repositório uma solução definitiva para todos os cenários. Ele representa uma organização reutilizável de práticas que surgiram de problemas reais do desenvolvimento.
Repositório: github.com/obelucca/claude-dev-pipeline
Como experimentar
Você pode adicionar o marketplace e instalar o plugin diretamente no Claude Code:
/plugin marketplace add obelucca/claude-dev-pipeline
/plugin install dev-pipeline@obelucca
Também é possível consultar o README em português para conhecer os requisitos, configurações e comandos disponíveis.
O que aprendi construindo essa arquitetura
Construir essa pipeline reforçou algumas percepções que considero importantes sobre o desenvolvimento de software com inteligência artificial.
A primeira é que mais agentes não significam necessariamente mais qualidade.
O valor está em definir responsabilidades, limitar o escopo de cada agente e estabelecer critérios claros para avaliar suas entregas.
A segunda é que nem tudo deve ser delegado a um modelo. Scripts, testes automatizados e mecanismos de controle continuam sendo fundamentais. Na verdade, quanto mais autonomia damos aos agentes, mais importantes se tornam essas garantias.
A terceira é que o coordenador continua tendo um papel essencial. Ele não é apenas alguém que encaminha mensagens entre agentes: é responsável por manter a coerência do processo e tomar decisões quando os resultados não são satisfatórios.
Por fim, acredito que estamos entrando em uma fase em que saber utilizar ferramentas de IA será apenas parte da competência de um desenvolvedor.
Precisaremos entender como projetar sistemas que utilizam essas ferramentas de maneira confiável.
No meu caso, essa arquitetura nasceu de uma necessidade bastante concreta: conseguir trabalhar com um volume elevado de demandas, em uma equipe pequena, em um produto real, com diferentes tecnologias e um lançamento importante pela frente.
Ela ainda está em evolução. Existem pontos que precisam ser aprimorados, decisões que precisam ser validadas e possibilidades de otimização.
Não considero essa arquitetura uma solução definitiva, muito menos uma receita que funciona para qualquer projeto.
Ela é o resultado de experimentação, estudo, problemas encontrados no desenvolvimento e referências de pessoas que compartilham conhecimento com a comunidade.
E é justamente por isso que faço questão de reconhecer a influência do Pedro Lara nessa construção.
Aprender com outras pessoas, adaptar ideias ao nosso contexto e compartilhar o resultado faz parte do que considero mais interessante na nossa profissão.
O futuro do desenvolvimento com IA não está apenas em escrever código mais rápido, mas em construir processos melhores para produzir software com qualidade e permitir que desenvolvedores participem cada vez mais da construção dos produtos.
Agradecimentos e referências
- Pedro Lara: LinkedIn
- Codelab que inspirou parte da arquitetura: Building a Production AI Code Review Assistant with Google ADK
- Projeto open source: Claude Dev Pipeline — GitHub
- Autor: Cleber Lucas — LinkedIn
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.