Claude Code ou Antigravity: como cada um roda duas tarefas ao mesmo tempo?

Fala aí, beleza? Chega uma hora em que você olha pro backlog e pensa "isso aqui dava pra rodar junto"

Duas frentes independentes, nenhuma dependendo da outra, e você parado esperando a primeira terminar

Aí você descobre que Claude Code e Antigravity resolvem esse mesmo problema por caminhos bem diferentes

E o ponto difícil nem é disparar duas tarefas ao mesmo tempo, isso qualquer um faz

O difícil é depois: saber o que cada agente está fazendo agora, quem travou esperando resposta, quem terminou, e principalmente COMO revisar o que cada tarefa mexeu sem que uma pise no arquivo da outra

É nisso que as duas ferramentas divergem de verdade, e é isso que a gente vai destrinchar aqui 🙂

Como o Claude Code roda mais de uma tarefa ao mesmo tempo

A documentação do Claude Code declara quatro caminhos pra paralelizar trabalho, e cada um serve a um tipo de necessidade

Subagentes concorrentes: vários subagentes rodam ao mesmo tempo, cada um com contexto isolado

O efeito prático é bonito: subtarefas independentes terminam no tempo da mais lenta, não na soma de todas

Agent view: a tela aberta por claude agents, de onde você DESPACHA e acompanha várias sessões em segundo plano ao mesmo tempo

Cada sessão despachada por ali é uma conversa completa que segue rodando sem terminal anexado, e ganha o próprio worktree automaticamente quando precisa editar arquivos

Ou seja, não é só um painel de observação: é dali que as frentes saem rodando lado a lado, já isoladas

Agent teams: uma sessão faz o papel de líder e as outras trabalham de forma independente, cada uma com sua própria janela de contexto

Elas compartilham uma lista de tarefas, reivindicam trabalho e conversam entre si, o que é bem diferente dos subagentes, que só reportam ao agente principal

Se liga que isso é experimental e vem DESLIGADO por padrão, você precisa habilitar com CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 no settings.json ou no ambiente

Dynamic workflows: um script JavaScript que orquestra subagentes em escala, escrito pelo próprio Claude a partir da tarefa que você descreveu

Ele roda num runtime em segundo plano, então a sua sessão continua respondendo enquanto o script trabalha

E o que segura tudo isso sem virar bagunça? O worktree

Se você já usou git worktree, é exatamente isso: um checkout separado, com arquivos e branch próprios, compartilhando o mesmo histórico e o mesmo remoto do repositório principal

É o mecanismo nativo do Claude Code pra isolar sessões paralelas, justamente pra que as edições de uma não colidam com as da outra

Na prática o fluxo é curtinho:

1. Cria o worktree já abrindo a sessão dentro dele, com a flag --worktree (ou -w) e um nome

claude --worktree minha-feature

Se você não passar nome, o Claude gera um pra você (tipo bright-running-fox)

Por padrão o worktree vai pra pasta .claude/worktrees/<nome>/ na raiz do repositório, na branch worktree-<nome>

2. Copia os arquivos que o git ignora

Erro comum deste passo: como o worktree é um checkout NOVO, arquivos ignorados pelo git não vão junto

Ou seja, .env e .env.local simplesmente não estão lá, e a sessão paralela quebra por motivo bobo

Pra copiar automaticamente existe o arquivo .worktreeinclude na raiz do projeto

3. Deixa o agente trabalhar

Enquanto um agente está rodando, o Claude executa git worktree lock no worktree dele, pra que a limpeza automática não remova aquilo debaixo do seu pé

A trava cai quando o agente termina

4. Lista e remove quando acabar

git worktree list
git worktree remove <caminho-do-worktree>

Erro comum deste passo: se houver mudanças não commitadas ou arquivos não rastreados, o remove reclama

Aí é --force, mas com consciência do que você está jogando fora 😛

Um detalhe que evita susto: a varredura periódica remove worktrees que o próprio Claude criou pra subagentes e sessões em segundo plano depois do prazo de cleanupPeriodDays, mas NUNCA remove os que você criou na mão com --worktree

No aplicativo desktop, a remoção é no mouse mesmo: passa por cima da sessão na sidebar e clica no ícone de arquivar

Se a sua dúvida ainda é mais básica, tipo duas sessões no mesmo projeto, vale começar por ali antes de subir pra times de agentes

Como o Antigravity trata vários agentes em paralelo

O Antigravity tem duas superfícies principais, e entender a diferença resolve metade da confusão

A Editor view é a experiência de IDE clássica: tab completion, comandos em linguagem natural e agente no painel lateral

A Manager view é a superfície agent-first, pensada pra agentes e não pra você digitar código

É ali que mora o paralelismo: a Manager view funciona como central pra dar spawn, orquestrar e observar vários agentes locais em paralelo, através de workspaces

Você agrupa conversas em Projects, opera em múltiplos workspaces e ainda automatiza rotina com mensagens agendadas

Quem precisa tocar frentes que nem moram no mesmo lugar, tipo dois projetos ao mesmo tempo, sente o valor de ter isso separado por workspace

E os subagentes? Como eles não se atropelam?

Os subagentes do Antigravity rodam de forma assíncrona em segundo plano e escolhem como tratar o espaço de trabalho, em três modos:

• inherit: mesmo workspace do agente pai
• branch: worktree git isolado
• share: armazenamento de diretório compartilhado

Sacou a jogada? O modo branch é exatamente o mesmo raciocínio do worktree lá do Claude Code, só que como opção declarada do subagente

Outra coisa massa: o subagente herda do pai os prefixos de comando de terminal permitidos, os escopos de leitura e escrita de arquivos e as configurações de sandbox

Você não precisa reconfigurar permissão pra cada agente que nasce, o que evita aquele clássico "por que esse aqui não consegue rodar nada?"

Na versão 2.0, que virou aplicativo desktop autônomo pra macOS, Linux e Windows, entrou o suporte nativo a git worktree: ao escolher a opção "New Worktree" no início de uma conversa, o Antigravity provisiona o worktree em segundo plano e já começa a conversa naquele caminho

A mesma 2.0 trouxe as Scheduled Tasks, com agentes acionados em horários definidos por cron, além dos Projects e da nova sidebar de gerenciamento

É o tipo de recurso que muda o jogo pra rotina chata: varredura de lint, checagem diária, aquele relatório que você sempre esquece de rodar

O que muda no acompanhamento e na revisão de cada tarefa

Aqui mora a diferença real, e não é firula de interface

No Claude Code, o acompanhamento é a mesma tela de onde as sessões saem

O agent view mostra o que está rodando, o que precisa de resposta e o que já terminou, tudo em uma tela

Cada sessão em segundo plano é uma conversa completa, que continua rodando sem terminal anexado

Você abre, responde e sai quando quiser

Pra entrar numa sessão, seleciona a linha e aperta Enter ou seta pra direita

E ao anexar, o Claude posta um recap curto do que aconteceu enquanto você esteve fora, o que evita aquele scroll infinito tentando entender o que rolou

O agent view ainda move automaticamente cada sessão despachada pro próprio worktree quando ela precisa editar arquivos, e subagentes criados dentro de uma sessão também podem receber um worktree cada

Já a revisão do que cada tarefa MEXEU cai no git

git worktree list pra ver quem existe, diff e commit no fluxo normal, git worktree remove pra encerrar

No app desktop, o ícone de arquivar na sidebar faz o serviço

É um modelo direto: se você já vive no terminal, não tem nada novo pra aprender além das flags

No Antigravity, o acompanhamento é por Artifacts

O Antigravity é construído em torno de Artifacts, que são o que o agente produz tanto pra trabalhar quanto pra comunicar o que fez

Entram aí task lists, implementation plans, walkthroughs, diffs de código, diagramas de arquitetura, screenshots e gravações de navegador

O implementation plan é o artefato em que o agente desenha as mudanças ANTES de executar, com os detalhes técnicos do que vai ser alterado, feito pra ser revisado por você

O walkthrough é o oposto: nasce quando o agente conclui a implementação e traz um resumo conciso das mudanças na conversa

Ou seja, você tem um antes e um depois legível, sem depender só do diff

A revisão aceita comentário em texto inline nos artefatos, o que deixa você corrigir o rumo antes de o agente encostar nos arquivos

Tem botão Proceed pra seguir com o plano, e uma política de artifact review que pode ser configurada com a opção Always Proceed pra quando você não quer ser interrompido

Perceba a filosofia diferente: o Claude Code te devolve o estado das sessões e joga a revisão pro git, o Antigravity te devolve artefatos e coloca a revisão dentro do próprio fluxo

Claude Code x Antigravity em paralelismo: comparativo lado a lado

As células com "não verificado" são honestidade, não preguiça: só entra aqui o que eu consegui confirmar na documentação de cada ferramenta

O que apareceu quando rodei os mesmos prompts nas ferramentas

Aqui preciso ser bem claro sobre o escopo, senão viro exatamente o tipo de comparação que eu critico

O teste que eu gravei foi Codex contra Antigravity, no mesmo app, com 5 prompts idênticos aplicados em cada ferramenta

Não foi Claude Code contra Antigravity, então nada do que eu vi ali serve de veredito pro Claude Code, beleza?

O que dá pra trazer desse material sobre trabalho em paralelo é mais desconfortável do que empolgante

O paralelismo apareceu como uma linha da tabela comparativa, não como teste prático

No Codex, a ideia é conseguir acionar vários agentes pra executar tarefas disparadas, mas é difícil perceber se isso está de fato acontecendo enquanto você usa

Essa parte multiagente não é explícita na interface, e talvez nem apareça em ação durante o vídeo

No Antigravity também dá pra trabalhar com mais de um agente, porém sem comunicação entre eles: quem abre cada um manualmente é você

Sobre cota, o que eu observei: a janela de 4 horas do Codex não chegou nem a 50% durante os testes e a gravação do curso, pelo que eu lembro

Já o consumo de cota do Antigravity é, na minha experiência, o principal ponto fraco dele, gasta bem mais rápido

E tem um viés que eu preciso declarar: eu tenho MUITO mais vivência com Antigravity do que com Codex, então leia minha opinião com esse filtro

Outra preferência minha que vale registrar: no Antigravity eu trabalho sempre em modo de planejamento, porque o fast mode atropela as coisas e não entrega bom resultado pra mim

E eu gosto de como o Codex separa planejar e executar em etapas visíveis, dá pra enxergar isso acontecendo de forma destacada

Pra não dar vantagem a nenhum lado, eu padronizo os testes colocando o mesmo arquivo de instruções do projeto nas duas ferramentas, copiando de uma pra outra

Criar esse arquivo é mais prático direto no Antigravity, por ser uma IDE, e mais trabalhoso no Codex, onde eu precisei abrir a pasta ou pedir pra própria ferramenta fazer

E eu fecho cada prompt com instruções explícitas de limite, proibindo funcionalidade além do que foi pedido, porque em comparações anteriores eu senti as ferramentas passando do escopo

No vídeo acima você vê os 5 prompts rodando lado a lado no mesmo projeto, a tabela comparativa que eu monto antes do teste e onde cada ferramenta escorrega

Quando rodar duas tarefas em paralelo ajuda de verdade (e quando atrapalha)

Paralelismo não é medalha, é ferramenta

Rodar quatro agentes numa tarefa que é sequencial só te dá quatro jeitos de quebrar a mesma coisa 😀

Vale paralelizar quando:

• as subtarefas são independentes de verdade, porque aí o tempo total vira o da mais lenta, não a soma de todas
• cada frente consegue viver em branch ou worktree próprio, sem disputar arquivo
• você aguenta revisar em lote depois, com diff e resumo de fechamento na mão
• é rotina repetitiva que dá pra agendar e revisar com calma, tipo as tarefas por cron do Antigravity

Não vale paralelizar quando:

• o trabalho é sequencial, um passo dependendo do resultado do anterior
• duas tarefas precisam editar o mesmo arquivo
• existem muitas dependências cruzadas entre as frentes

E olha que legal: isso não é achismo meu, a própria documentação do Claude Code diz quando NÃO usar agent teams

Pra tarefas sequenciais, edições no mesmo arquivo ou trabalho com muitas dependências, uma sessão única ou subagentes são mais eficazes

Tome cuidado com a euforia de abrir cinco frentes: o custo de revisar cinco diffs desconexos costuma comer o ganho de tempo que você achou que teve

Veredito: qual escolher para o seu jeito de trabalhar

Não tem vencedor absoluto aqui, tem encaixe com o seu jeito de trabalhar

Se você já vive no terminal e no git, o modelo do Claude Code é natural: worktree isolando cada sessão, claude agents como painel de controle, recap ao anexar e revisão no fluxo git que você já domina

Você não aprende uma interface nova, aprende três flags e segue a vida

Se você quer uma central visual, com plano revisável antes de o agente mexer no código e resumo de fechamento no fim, a Manager view e os Artifacts do Antigravity conversam mais com você

Comentário inline no plano é um recurso que economiza retrabalho de um jeito que diff nenhum economiza

Dois avisos honestos pra fechar

Agent teams do Claude Code é experimental e vem desligado por padrão, então trate como terreno em obra, não como base do seu fluxo de produção

E o Antigravity está em ciclo de versões bem acelerado: o desktop 2.0 saiu em 19/05/2026, e só em agosto de 2026 já apareceram a 2.8.0 (12/08) e a 2.8.1 (13/08)

Ciclo rápido é bom pra recurso novo e ruim pra estabilidade de fluxo, escolha sabendo disso

Conclusão

O ganho de rodar tarefas em paralelo não vem da quantidade de agentes, vem de duas coisas: isolamento e revisão

Sem isolamento, dois agentes viram um conflito de merge com passos extras

Sem revisão decente, você ganha tempo na execução e perde o dobro tentando entender o que cada um fez

Claude Code resolve isso com worktree e uma tela de sessões, Antigravity resolve com workspaces e artefatos revisáveis

Caminhos diferentes, mesma preocupação de fundo

Meu próximo passo sugerido é modesto de propósito: pegue duas frentes realmente independentes, coloque cada uma em seu worktree, acompanhe, revise e só DEPOIS pense em times de agentes ou orquestração em escala

Quem pula direto pra cinco agentes costuma voltar com cinco problemas…

até o próximo post! 🙂