Abri o repositório de um projeto de faturamento multitenant que estávamos desenvolvendo há meses. Clonei em uma máquina nova, instalei o sistema e escrevi Em dois minutos tinha o mapa completo: Laravel 12 com multi-tenancy, Vue 3 no front, MySQL, Sanctum para auth. Detectou os comandos de teste, marcou as pastas de configuração de tenants como zona crítica, registrou o MCP de Laravel sozinho. Tudo antes de tocar uma linha de código.<\/p> Não expliquei nada. Ele leu sozinho.<\/p> Aquele momento foi a confirmação de que o que havia montado nos meses anteriores valia a pena.<\/p> No final do ano percebi algo incômodo: estava perdendo mais tempo corrigindo a IA do que o tempo que economizava usando-a.<\/p> Não era um problema da ferramenta. Era um problema de como eu estava usando.<\/strong><\/p> Cada vez que abria um projeto, Claude começava do zero. Sem contexto. Sem saber qual stack usávamos, quais pastas não tocar, como rodar os testes. Eu explicava. Implementava algo. Eu revisava. Havia algo estranho. Corrigia. Explicava novamente. O ciclo se repetia até que o tempo "economizado" já não existia.<\/p> Em dezembro e janeiro, justo quando o tema dos agentes de IA explodiu, decidi que se ia continuar usando essas ferramentas a sério, precisava montar algo melhor.<\/p> Assim nasceu o onMedia Dev System<\/strong>.<\/p> Quando você trabalha com IA em desenvolvimento, há três fricções que ninguém menciona muito:<\/p> O contexto se perde sempre.<\/strong> Cada sessão começa do zero. Não importa quantas vezes você tenha explicado o projeto — na próxima vez, não sabe de nada.<\/p> Os projetos se confundem.<\/strong> Se você trabalha em vários projetos ao mesmo tempo, como é nosso caso na onMedia, o caos cresce. Qual configuração se aplica a qual? Este colega pode usar o sistema sem quebrar seu fluxo?<\/p> A IA implementa e planeja ao mesmo tempo.<\/strong> Isso soa bem na teoria. Na prática, misturar papéis gera inconsistência. Se você pede para pensar e executar ao mesmo tempo, faz as duas coisas pela metade.<\/p> A ideia central do sistema é simples: Claude não implementa. Orquestra.<\/strong><\/p> Há duas ferramentas trabalhando juntas:<\/p> Claude Code<\/strong> — orquestra, planeja e revisa. É o cérebro.<\/p><\/li> OpenCode<\/strong> — implementa o código. São as mãos.<\/p><\/li><\/ul> Claude decide o que fazer e como. OpenCode executa. Claude depois revisa se está certo. Ninguém faz duas coisas ao mesmo tempo.<\/p> Isso resolveu o problema de qualidade quase de imediato.<\/p> Quando começo uma nova feature, escrevo Check<\/strong> — verifica se o sistema está bem configurado<\/p><\/li> Context<\/strong> — lê o projeto e constrói o mapa (mais sobre isso abaixo)<\/p><\/li> Plan<\/strong> — Claude planeja o que fazer, arquivo por arquivo<\/p><\/li> Implement<\/strong> — OpenCode executa o plano<\/p><\/li> Review<\/strong> — Claude revisa o resultado, roda os testes, aprova ou rejeita<\/p><\/li><\/ol> No final do passo 5, o sistema me faz um handoff: "teste isso e me diga o que encontrou". Eu testo. Se há algo para ajustar, escrevo Três comandos. Sem liturgia.<\/p> Este é o detalhe que mais mudou meu dia a dia.<\/p> A primeira vez que você roda O Explorer abre os arquivos de dependências ( Esse arquivo é a fonte de verdade. Stack com versões, rotas, entry points, convenções, quais pastas são de somente leitura. Da próxima vez que alguém abrir esse projeto — eu, um colega, a sessão de amanhã — o sistema já sabe tudo.<\/p> Não é preciso explicar nada nunca mais.<\/p> E se o projeto é Laravel, instala e registra o MCP de Laravel automaticamente, para que Claude possa consultar modelos, rotas e esquema em tempo real sem que eu faça nada.<\/p> Trabalhamos com mais de 100 clientes. Ter um sistema de IA que se confunde entre projetos não é uma opção.<\/p> A solução foi simples: cada projeto tem seu próprio contexto em uma pasta Além disso — e isso foi importante para compartilhar com colegas — o sistema não faz nada até que você o ative<\/strong>. Não há configuração invasiva que tome controle do Claude Code desde o início. Dorme no projeto até que você escreva Há um detalhe mais que acho valioso mencionar.<\/p> O sistema tem memória persistente global. Um banco de dados SQLite que vive na sua máquina e é compartilhado entre todos os projetos. Cada vez que Da próxima vez que você iniciar um projeto similar, o sistema já tem essa base. Não começa do zero nunca mais.<\/p> <\/p> <\/p> Não foi a velocidade de escrita de código. Isso melhorou, sim, mas não é a principal mudança.<\/p> O que mudou é que deixei de ser o intérprete entre o projeto e a IA. Antes eu era quem sabia o contexto e tinha que transmiti-lo em cada sessão. Agora o sistema sabe. Eu apenas dirijo.<\/p> O problema que tinha em dezembro — mais tempo corrigindo do que economizando — desapareceu. Não porque a IA seja melhor, mas porque o sistema que a rodeia é mais inteligente.<\/p> Se você trabalha com Claude Code ou está pensando em começar a usá-lo a sério para desenvolvimento, o sistema está disponível para instalar. Nos próximos dias vou compartilhar como instalá-lo passo a passo.<\/p> Você usa IA no seu fluxo de desenvolvimento? Qual é a fricção que mais lhe custa resolver?<\/p>\/run-task<\/code> sem dizer mais nada.<\/p>O problema real<\/h2>
A solução: separar papéis<\/h2>
O fluxo na prática<\/h2>
\/run-task<\/code> no Claude Code. Isso dispara um pipeline de cinco passos que roda sozinho:<\/p>\/iterate "o que encontrei"<\/code> e o ciclo se repete sem ter que remontar nada. Quando está tudo bem, \/close<\/code> arquiva o plano e guarda o aprendido na memória.<\/p>O discovery automático<\/h2>
\/run-task<\/code> em um projeto, o sistema lança o Explorer — um subagente cujo único trabalho é entender o projeto do zero, sem assumir nada.<\/p>composer.json<\/code>, package.json<\/code>, requirements.txt<\/code>, o docker-compose), percorre a estrutura de pastas, detecta os comandos de teste, e com tudo isso gera um arquivo .ai\/context.md<\/code> que fica commiteado no repo.<\/p>Multi-projeto sem conflito<\/h2>
.ai\/<\/code> dentro do repositório. O sistema vive lá, isolado. Não sabe nada dos outros projetos e não interfere com eles.<\/p>\/run-task<\/code>. Isso significa que um colega pode ter o sistema instalado sem que mude nada do seu fluxo habitual, e ativá-lo quando quiser testá-lo.<\/p>A memória<\/h2>
\/close<\/code> arquiva um plano, guarda o aprendido: erros que apareceram, decisões que foram tomadas, padrões que funcionaram.<\/p>
O que mudou<\/h2>
Germán Middi
Software Engineer
