Pular para o conteúdo
Voltar para o blog
  • IA no Desenvolvimento
  • Inteligência Artificial
  • AI code generation
  • workflow de desenvolvimento
  • vibe coding
  • TDD
  • Produtividade
  • qualidade de software
  • Automação
  • Comunidade Dev
  • Futuro do Trabalho
  • Desenvolvimento Pessoal
  • Impacto da IA
  • Projetos Pessoais
  • test driven development

Meu Fluxo de Desenvolvimento com IA

Do PRD ao Deploy em Horas

Pixel art de madrugada: uma esteira passa por estações de ideia, documento, quadro, arquivo e testes até a torre de onde um foguete verde-limão decola

Eu levava semanas, às vezes meses, para construir um sistema completo. Hoje faço a mesma coisa em horas ou em poucos dias. Não é porque passei a digitar mais rápido. É porque mudei a forma de pensar o desenvolvimento. Este post não é sobre pedir ao ChatGPT funções soltas. É sobre o fluxo de desenvolvimento com IA que uso para construir sistemas do zero, com planejamento, agentes especializados, TDD e deploy, contado passo a passo.

Do Caos à Orquestração: o que Mudou no Meu Papel

No começo, eu sentia falta de pôr a mão no código. Mexia com frequência no que a IA gerava. Em parte porque a IA da época não era tão boa quanto a de hoje. Em parte porque eu sentia que tinha perdido o controle.

Com o tempo, entendi que o problema não era a IA. Era a falta de um sistema. Eu pedia coisas de forma aleatória, sem direção e sem validação. O resultado era código que parecia funcionar e desmoronava na primeira integração.

Hoje eu não escrevo código. Eu orquestro. Penso na arquitetura, defino os requisitos, crio agentes especializados, e a IA executa. Isso não quer dizer que eu preciso saber menos. Preciso saber mais.

O código nunca foi a parte mais importante. Quem já abriu um projeto open source para estudar sabe que grandes sistemas são feitos de soluções improvisadas que funcionam. O essencial sempre foi entender o que o código faz, e não escrevê-lo. Agora que a gente não escreve mais, entender código ficou ainda mais crítico.

Para sair do caos, eu precisei de um processo que se repete. É ele que mostro a seguir.

Meu Workflow com IA, Passo a Passo

O fluxo segue sempre a mesma ordem:

Ideia → PRD → Issues no GitHub → TASKS.md → TDD (testes + execução) → Deploy

Cada etapa tem um motivo. Pular uma delas gera problemas que só aparecem depois, e corrigir depois sai muito mais caro do que prevenir antes.

1. Ideia: discutir antes de pedir código

Tudo começa com uma frase como "quero fazer um sistema de autenticação RBAC completo, o que fazer a partir daqui?". Daí em diante é um bate-e-volta com a IA, geralmente num chat web. As perguntas que eu faço são deste tipo:

  • "Essa ideia é possível com tal stack?"
  • "Mesmo com trade-offs significativos, daria para fazer com a stack X?"
  • "Isso é necessário ou é over-engineering?"
  • "Não estamos pensando pequeno demais?"
  • "Não estamos pensando mais do que deveríamos?"

2. PRD: a IA me entrevista

Quando a ideia está sólida no nível macro, eu inverto o jogo: peço para a IA me fazer várias perguntas sobre o sistema. São as perguntas necessárias para montar o PRD completo. Elas já não são sobre a ideia, e sim sobre a execução: o que o sistema vai fazer e o que ele não vai fazer.

3. Issues e TASKS.md: granularidade extrema

Com o PRD pronto, gero as issues no GitHub. A partir delas, crio um arquivo TASKS.md dividido em etapas, com o que será feito em cada uma.

Esse arquivo às vezes passa de 200 tasks. E cada task é pequena, do tipo "agora criar esta função".

4. Execução: uma sessão nova para cada grupo de tasks

Para cada grupo de tasks, abro uma sessão nova na IA, com o contexto zerado. Antes de qualquer coisa, uso o modo de planejamento da ferramenta. Isso reduz alucinação e garante que o resultado seja o que eu quero.

Não aproveito contexto de sessões anteriores porque as funções precisam ser independentes. Planejo como aquela função vai funcionar, executo, e só depois começo a conectar as funções.

5. TDD: se não tem teste, não entra

TDD é obrigatório em todos os meus projetos hoje. Para cada grupo de tasks, o teste define o comportamento esperado antes de o código existir. Se o código gerado pela IA não passa no teste, quem muda é o código, não o teste. Explico esse ciclo em detalhe mais abaixo e no post sobre minha jornada com TDD.

6. Deploy

Só depois disso o código vai para produção. Se quiser ver como o código sai da minha máquina até lá, contei em Git Flow para GitHub Flow.

Esse é o esqueleto. Duas decisões, porém, fazem ele funcionar: a ordem em que eu construo e a forma como eu monto os agentes.

Backend Primeiro, Frontend Depois

Essa mudança demorou para eu aceitar. Eu fazia o frontend primeiro e só depois pensava no backend, e deixava muita coisa passar. Quando você começa pelo visual, é fácil se empolgar com a interface e esquecer de validar se a estrutura de dados faz sentido, se as regras de negócio estão bem definidas e se as integrações vão funcionar.

Hoje começo sempre pelo backend: entidades, APIs, regras de negócio e testes. Só com essa base pronta vou para o frontend. Para isso, tenho agentes específicos de backend, agentes de frontend e agentes que trabalham nos dois.

Agentes Especializados: o Segredo Está nos Limites

Agente é prompt. E um bom prompt de agente, para mim, segue duas regras:

  • Markdown obrigatório.
  • Seções bem definidas, entre elas o que o agente pode e o que ele não pode fazer.

A segunda regra é a mais importante. Para um agente ser especialista, ele precisa saber muito bem o que não fazer. É isso que faz ele focar no que deve.

Um agente genérico só tem duas saídas: ou fica superficial em tudo, ou fica tão grande que não cabe bem numa sessão de IA, e aí o risco de alucinação e de resultado genérico aumenta.

Por isso eu crio agentes separados para code review, segurança e acessibilidade. Cada um tem contexto delimitado, regras claras e sabe até onde vai a própria responsabilidade.

Limite no agente e teste no código são as duas formas de validação do fluxo. E validação é exatamente o que falta no vibe coding.

Por que Vibe Coding Não Funciona em Sistema Crítico

O problema do vibe coding não é a IA. É a ausência de validação. Quando você pede código sem um teste que diga o que é correto, está confiando que o modelo entendeu a sua intenção. Isso raramente acontece de forma consistente. Contei os detalhes de como a IA se comporta sem essa âncora no post sobre TDD.

Por curiosidade, já olhei aplicações feitas com vibe coding e consegui acesso total a mais de uma. Não é exceção. É consequência de não validar.

Para site estático ou projeto pessoal, isso pode não ser um problema. Quando essa mentalidade chega a sistemas críticos, com usuários e dados sensíveis, vira um problema de segurança.

"A diferença fundamental entre quem usa IA bem e quem usa mal é conhecimento. Precisamos ter uma visão pragmática, não romantizada, dos limites e das forças da IA."

Com essa visão, além de construir sistemas melhores, você consegue aplicar o mesmo fluxo com qualquer ferramenta ou LLM. Quem faz vibe coding fica dependente da IA e da ferramenta, e não sabe pensar sem elas.

Conceito Acima da Ferramenta

Eu me especializo no conceito, não numa ferramenta ou num LLM específico. Consigo rodar esse fluxo em qualquer lugar. Hoje uso mais o Claude Code ou o OpenCode com o plano da Alibaba. Amanhã pode ser outra ferramenta. O workflow continua o mesmo.

O que mudou foi a proporção do meu tempo. Antes eu planejava muito pouco. Hoje gasto bem mais tempo preparando um ambiente bem documentado antes de executar. Foi essa troca que permitiu o salto de semanas para horas.

E o ciclo de TDD ainda não é natural para mim. Ainda estou aprendendo, e muitas vezes sinto que estou mais lento do que antes. Os resultados dizem outra coisa: menos bugs, menos refatoração depois e mais segurança para mudar o código.

Conclusão

Esse fluxo não nasceu pronto. Veio de erro, de código que desmoronava em produção e de integrações que falhavam porque eu não tinha planejado o suficiente. Foi tentativa e erro que me levou do caos à orquestração.

A principal lição é que IA não substitui pensamento, ela amplifica. Se você pensa de forma desorganizada, a IA gera código desorganizado mais rápido. Se você pensa de forma estruturada, ela executa de forma estruturada, e mais rápido ainda.

Se quiser começar amanhã, faça nesta ordem:

  • Planeje antes de pedir qualquer linha de código. Defina o que o sistema faz e o que ele não faz.
  • Quebre o trabalho em tasks pequenas. Uma task, uma função.
  • Use TDD para validar. O teste vem antes, e é o código que se adapta a ele.
  • Nunca confie no output da IA sem validação.

A diferença entre vibe coding e desenvolvimento profissional com IA não é a ferramenta. É o processo.

Referências

Matheus Mierzwa

AI Enablement Lead & Frontend Tech Lead

Escrevo sobre o que construo e lidero na prática.