Como Usar Claude Code com Agentes Paralelos (Guia Prático)

# Como Usar Claude Code com Agentes Paralelos (Guia Prático)

Se você já usou o Claude Code para escrever um arquivo ou corrigir um bug, sabe o quanto isso acelera o desenvolvimento. Mas existe um nível acima disso — e na Stream 8 do projeto EmailHacker.ai, Laschuk mostrou ao vivo como usar agentes paralelos para renderizar 4 vídeos ao mesmo tempo, configurar integrações e escrever código, tudo rodando simultaneamente enquanto ele tomava café.

Este guia documenta exatamente como fazer isso: escolher o modelo certo para cada tarefa, criar skills customizadas e orquestrar múltiplos agentes em paralelo.

Por Que Agentes Paralelos?

O modelo padrão de usar IA é sequencial: você pergunta, a IA responde, você lê, você pergunta de novo. Isso é lento. Com agentes paralelos, você inverte a lógica:

• ‣Você define as tarefas com clareza
• ‣O Claude as executa simultaneamente em terminais separados
• ‣Você revisa os resultados enquanto tudo acontece em paralelo

O ganho real não é apenas velocidade — é foco. Enquanto um agente renderiza um vídeo, outro está escrevendo o email de lançamento, e um terceiro está ajustando o CSS da landing page. Você não precisa gerenciar nenhum desses passos manualmente.

Na Stream 8, isso ficou evidente: 4 vídeos Remotion foram disparados em paralelo via Claude Code. O tempo total foi o mesmo que renderizar 1 vídeo sequencialmente.

O Que Você Precisa

Antes de começar, certifique-se de ter:

• ‣Claude Code instalado (CLI da Anthropic — npm install -g @anthropic-ai/claude-code)
• ‣Conta na Anthropic com acesso aos modelos Opus, Sonnet e Haiku
• ‣Node.js 18+ (para projetos JavaScript/TypeScript)
• ‣Um projeto real com tarefas paralelizáveis (desenvolvimento de software, geração de conteúdo, processamento de dados)
• ‣Familiaridade básica com terminal

Se você quer entender melhor como o Claude Code foi usado em streams anteriores, veja o histórico de streams — cada uma documenta um avanço diferente do projeto.

Passo 1: Entender os Modelos (Opus, Sonnet, Haiku)

O primeiro erro de quem começa com Claude Code é usar o modelo mais poderoso para tudo. Isso é caro e desnecessário. Cada modelo tem um papel específico:

Tabela de Decisão Rápida

Passo 2: Configurar Claude Code

O Claude Code usa um arquivo CLAUDE.md na raiz do projeto para dar contexto ao agente. Este arquivo é lido automaticamente a cada sessão — é como uma briefing permanente.

Estrutura mínima de um CLAUDE.md eficiente:

markdown# Contexto do Projeto

## Stack
- Next.js 16, TypeScript, Tailwind CSS v4
- Supabase (banco de dados)
- Dev: porta 1337

## Regras
- Nunca fazer commit direto — sempre usar /deploy
- Ícones: Lucide React, 20px, stroke-width 1.5
- Sem acentos em variáveis, nomes de arquivo, commits

## Comandos
- Dev: cd apps/web && npm run dev
- Build: cd apps/web && npm run build

Quanto mais contexto relevante o CLAUDE.md tiver, menos você precisa repetir instruções. O Claude Code carrega esse arquivo em todos os agentes que você lançar — incluindo os paralelos.

Janela de Contexto de 1M de Tokens: O Claude suporta até 1 milhão de tokens de contexto. Isso significa que você pode passar arquivos inteiros, logs completos, esquemas de banco de dados e histórico de decisões — sem compressão ou resumo. Use isso a seu favor: contexto completo gera respostas mais precisas.

Passo 3: Criar Skills Customizadas

Skills são habilidades customizadas que você ensina ao Claude Code para executar tarefas específicas do seu projeto. Elas ficam em ~/.claude/skills/ e podem ser invocadas com /nome-da-skill.

Como uma Skill é estruturada

Uma skill é basicamente um arquivo de instruções que o Claude lê antes de executar uma tarefa. Exemplo de estrutura:

~/.claude/skills/
  deploy/
    index.md        ← instruções principais
    knowledge/
      checklist.md  ← conhecimento específico
  geo/
    index.md
    references/
      seo-rules.md

Quando criar uma Skill

Crie uma skill quando você:

1. 1.Repete a mesma tarefa mais de 3 vezes com as mesmas instruções
2. 2.Tem um processo com múltiplos passos que precisa ser executado na ordem certa
3. 3.Tem regras específicas que se aplicam a um domínio (ex: como escrever emails para a sua audiência)
4. 4.Quer garantir consistência entre diferentes sessões e agentes

No EmailHacker.ai existem skills para: /deploy, /send (disparar email), /geo (criar guias SEO), /stream (preparar live), entre outras. Cada skill encapsula o conhecimento necessário para executar aquela tarefa sem precisar reexplicar tudo a cada vez.

Criando sua primeira Skill

Passo 1: Crie a pasta da skill: %%CODEBLOCK_2%%

Passo 2: Crie o arquivo index.md com as instruções: %%CODEBLOCK_3%%

Passo 3: Invoque com /minha-skill no Claude Code.

Passo 4: Orquestrar Agentes em Paralelo

Aqui está o diferencial real. O Claude Code permite lançar múltiplos agentes em terminais separados, cada um com sua própria tarefa, rodando simultaneamente.

Método 1: Múltiplos Terminais Manuais

A forma mais simples: abra 3-5 janelas de terminal e execute Claude Code em cada uma com tarefas diferentes.

bash# Terminal 1
claude "Crie o componente Header seguindo o design system em knowledge/design/design-system.md"

# Terminal 2
claude "Escreva os testes unitários para src/lib/attribution.ts"

# Terminal 3
claude "Otimize as queries SQL em src/lib/supabase-queries.ts para reduzir latência"

Cada agente tem seu próprio contexto e executa independentemente. Você monitora os três ao mesmo tempo.

Método 2: Git Worktrees (Para Código)

Quando múltiplos agentes precisam editar arquivos diferentes do mesmo repositório, use git worktrees. Isso evita conflitos:

bash# Criar worktrees separados
git worktree add .worktrees/feature-header -b feature/header
git worktree add .worktrees/feature-tests -b feature/tests

# Lançar agente em cada worktree
cd .worktrees/feature-header && claude "Crie o componente Header"
cd .worktrees/feature-tests && claude "Escreva os testes para attribution.ts"

Cada agente trabalha em sua própria branch, sem interferir no trabalho do outro.

Método 3: Skills que Disparam Subagentes

O nível mais avançado: uma skill que, ao ser invocada, define e lança múltiplos subagentes automaticamente. O agente orquestrador (rodando em Opus) define as tarefas, e os subagentes (em Sonnet) executam em paralelo.

Essa abordagem é usada na skill /stream do EmailHacker.ai: ao preparar uma live, um agente busca métricas no banco, outro prepara o roteiro, e um terceiro verifica o estado do código — tudo ao mesmo tempo.

Regras de Ouro para Paralelização

Passo 5: Otimizar Custos

Usando agentes paralelos sem critério, os custos podem escalar rapidamente. Aqui estão as estratégias usadas no EmailHacker.ai:

Regra 80/15/5

Cache de Contexto

O Claude tem cache automático de prefixo de prompt. Isso significa que se múltiplos agentes leem o mesmo CLAUDE.md e os mesmos arquivos de referência, o custo dessas leituras é cobrado uma vez, não por agente. Mantenha o contexto compartilhado no início da conversa para maximizar o cache.

Tamanho de Contexto vs. Custo

Monitore o Uso

O Claude Code exibe o custo estimado de cada sessão no terminal. Acompanhe isso por alguns dias para entender quais tarefas são mais caras e onde você pode trocar Sonnet por Haiku.

Caso Real: 4 Vídeos Simultâneos na Stream 8

Na Stream 8, Laschuk precisava renderizar 4 variações de vídeos Remotion para o projeto EmailHacker.ai — diferentes formatos para Reels, YouTube Shorts e stories.

O processo sequencial levaria ~40 minutos (10 min por vídeo). Com agentes paralelos:

Passo 1: O agente orquestrador (Opus) analisou os 4 formatos necessários e definiu os parâmetros de cada renderização.

Passo 2: 4 agentes Sonnet foram lançados em terminais separados, cada um com a tarefa de configurar e disparar a renderização de um formato específico.

Passo 3: Os 4 processos de renderização rodaram simultaneamente. Tempo total: ~10 minutos (o mesmo de 1 vídeo).

Resultado: 4 vídeos entregues em 25% do tempo original. Laschuk usou esses minutos para gravar o áudio de narração e revisar o script — trabalho que só ele pode fazer.

Isso é o ponto central da abordagem: agentes fazem o trabalho repetível e computacional; você faz o trabalho criativo e estratégico.

Para ver outras aplicações de IA em streaming ao vivo, confira também a Stream 6 onde Laschuk explorou o Claude Computer Use para automação de interface.

Próximo Passo

Agora que você entende a lógica dos agentes paralelos, o caminho natural é:

1. 1.Instale o Claude Code e configure seu primeiro CLAUDE.md
2. 2.Identifique 3 tarefas no seu projeto que poderiam rodar em paralelo
3. 3.Crie sua primeira skill para a tarefa que você mais repete
4. 4.Lance 2 agentes simultaneamente e observe o fluxo

Se você quer acompanhar isso acontecendo ao vivo — código sendo escrito, agentes sendo orquestrados, features sendo construídas em tempo real — entra no Discord do EmailHacker.ai. Cada stream é uma aula prática de como usar IA para construir produto.

Erros Comuns

Erro 1: Usar Opus para tudo Symptoma: custos altos sem ganho proporcional de qualidade. Solução: reserve Opus para decisões estratégicas; use Sonnet para execução.

Erro 2: Contexto insuficiente para os agentes Sintoma: o agente toma decisões erradas ou pede mais informações constantemente. Solução: passe o contexto completo na primeira mensagem — arquivos relevantes, regras do projeto, exemplos do padrão esperado.

Erro 3: Paralelizar tarefas dependentes Sintoma: um agente precisa do output de outro para continuar, gerando gargalo. Solução: mapeie as dependências antes de paralelizar. Tarefas em sequência precisam rodar em sequência — só paralelize as verdadeiramente independentes.

Erro 4: Skills genéricas demais Sintoma: a skill não gera resultado consistente entre execuções. Solução: seja específico nas instruções. Inclua exemplos de input/output esperado, regras de negócio do seu projeto e checklist de validação.

Erro 5: Não revisar o output dos agentes Sintoma: código ou conteúdo de baixa qualidade vai para produção. Solução: sempre revise o output antes de commitar ou publicar. Agentes são rápidos, mas você é o último filtro de qualidade.

Erro 6: Ignorar o CLAUDE.md Sintoma: você repete as mesmas instruções em toda sessão. Solução: documente tudo que você repete mais de 2 vezes no CLAUDE.md. Isso é memória persistente do projeto — use-a.