Subagentes (Subagents): Terceirizando o Trabalho, Não Faça Tudo Sozinho

📚 Navegação da Série: O artigo anterior 22 MCP ensinou você a conectar o Claude a ferramentas externas, permitindo que ele consulte bancos de dados e conecte-se ao GitHub. Este artigo propõe uma abordagem diferente—não se trata de "adicionar ferramentas", mas de ensinar você a terceirizar o trabalho: Subagente (Subagent), um assistente especializado com contexto, permissões e persona independentes, que retorna apenas o resultado final quando terminar.

Dizem que os subagents são poderosos, o "uso avançado" do Claude Code. Muitas pessoas ficam entusiasmadas quando descobrem essa função, querendo dividir uma tarefa em cinco ou seis subagentes rodando ao mesmo tempo, achando que isso é "mais profissional e eficiente".

Mas, para ser honesto: a maioria das pessoas erra ao começar dividindo tudo.

É preciso usar por um tempo para entender isso. Explicaremos o motivo detalhadamente mais adiante—mas aqui está a conclusão inicial: o uso de subagentes não se justifica simplesmente por ter muitas tarefas. Ele é uma ferramenta com cenários de aplicação muito claros; usado corretamente, traz tranquilidade, mas usado incorretamente, torna-se lento e caro. Avaliar "se deve ou não dividir" é muito mais importante do que aprender "como dividir".

Neste artigo, não apenas ensinarei você a criar e acionar subagentes, mas, mais importante, ajudarei a estabelecer a linha de decisão: quando terceirizar e quando é mais rápido fazer você mesmo.

Ao terminar este artigo, você obterá:

• O que realmente é um subagente—contexto independente, ferramentas independentes, persona independente: a diferença crucial em relação à conversa principal
• Os três problemas reais que ele resolve (isolamento de contexto, especialização de tarefas, paralelismo) e aquele obstáculo contraintuitivo: quando não dividir
• Como criar interativamente usando /agents, ou escrever manualmente o arquivo de configuração .claude/agents/name.md, entendendo o propósito de cada campo
• Dois modos de acionamento: delegação automática baseada em description ou menção direta feita por você
• Um guia prático passo a passo com saídas esperadas: criando um subagente mínimo do zero e colocando-o para trabalhar

---

01 Primeiro entenda: O que realmente é um subagente

Conclusão direta: Um subagente é como um assistente especializado contratado temporariamente pelo Claude—ele trabalha em sua própria sala e retorna apenas o resultado final para você, garantindo que a pilha de materiais consultados durante o processo não ocupe a sua mesa de trabalho.

Analogia: Terceirizar uma tarefa para um assistente dedicado. Você tem muitas coisas para fazer, e tarefas como "analisar mil linhas de log para identificar as linhas de erro" são cansativas e ocupam muito espaço. Você não quer espalhar isso em sua mesa de trabalho principal, pois isso a deixaria totalmente desorganizada. Então, você terceiriza para um assistente dedicado a essa função: ele analisa as mil linhas de log em sua própria sala, em sua própria mesa; quando termina, ele não traz de volta as mil linhas de log originais, apenas entrega um bilhete: "Há apenas três erros, nas linhas 207, 589 e 903". Sua mesa de trabalho permanece impecavelmente limpa.

Esse assistente possui três características exclusivas que o separam completamente de você (a conversa principal). A documentação oficial descreve isso de forma bem categórica:

Cada subagent roda em sua própria janela de contexto (context window), com um prompt de sistema personalizado, acesso a ferramentas específicas e permissões independentes.

Em detalhe, são três aspectos "independentes":

Dimensão	Conversa Principal (Você)	Subagente (Assistente terceirizado)
Contexto	Todo o histórico acumulado na conversa com o Claude	Em branco; recebe apenas a instrução da tarefa e não vê o que foi discutido anteriormente
Prompt do Sistema (Persona)	Configuração padrão do Claude Code	Persona personalizada criada por você, como "Você é um revisor de código focado em encontrar problemas"
Ferramentas / Permissões	Todas as ferramentas que você autorizou	Podem ser limitadas individualmente, como "apenas leitura, sem escrita"

O aspecto mais crítico e frequentemente ignorado é o primeiro: o subagente começa a partir de uma página em branco. O documento oficial é explícito—ele "não vê seu histórico de chat, as habilidades carregadas ou os arquivos lidos anteriormente pelo Claude". O Claude redige uma "instrução de tarefa" e a envia para o subagente, que começa a trabalhar a partir desse ponto.

Essa característica define o que os subagentes fazem bem ou mal, servindo como base para a tomada de decisão no próximo capítulo.

💡 Resumo em uma frase: Um subagente é um assistente terceirizado com contexto, persona e ferramentas independentes, que trabalha em sua própria sala e retorna apenas resultados; lembre-se de que ele inicia do zero, sem acesso ao histórico de conversa anterior.

---

02 O que ele resolve—e aquele obstáculo contraintuitivo

Compreendido o conceito, precisamos entender sua finalidade. Subagentes resolvem efetivamente três problemas, apresentados a seguir, com o terceiro detalhando aquele obstáculo contraintuitivo citado no início.

Problema 1: Isolamento de contexto, sem poluir a linha principal

Este é o caso de uso mais central e valioso dos subagentes.

A janela de contexto—a "mesa de trabalho" do Claude—é limitada. Quanto mais você conversa e lê arquivos, mais cheia ela fica. Ao atingir o limite, o modelo começa a esquecer informações e perde precisão. Algumas tarefas consomem muito espaço, gerando dados intermediários que você nunca mais lerá.

Por exemplo, a instrução "execute toda a suíte de testes e me diga quais falharam". Rodar testes pode gerar centenas ou milhares de linhas de log, mas você só precisa de uma resposta direta: "Estes três testes falharam devido a X". Se executado na conversa principal, todas essas linhas vão poluir a sua mesa de trabalho.

Nessa situação, terceirize para um subagente: ele lidará com essas centenas de linhas em sua própria sala e retornará apenas o resumo das falhas. Sua mesa de trabalho principal permanecerá intocada. A documentação oficial destaca esse uso como "um dos casos mais eficazes":

Executar testes, obter documentações ou processar arquivos de log pode consumir muito contexto. Ao delegar essas tarefas a um subagent, a saída detalhada permanece no contexto do subagent, e apenas o resumo relevante retorna para a sua conversa principal.

Cenário real: Ao integrar um SDK de terceiros, você executa repetidamente comandos curl para inspecionar as respostas da API, gerando telas cheias de JSON. Após cerca de dez rodadas de conversa, a conversa principal fica tão poluída com dados JSON que o Claude começa a esquecer os requisitos iniciais. Abordagem alternativa: delegar a tarefa para um subagente com a instrução "teste essa chamada de API e informe a estrutura dos campos". A conversa principal permanece limpa e sua linha de raciocínio é preservada.

Problema 2: Especialização em tipos específicos de tarefas

Segundo caso de uso: definir um "especialista dedicado" para tarefas repetitivas.

Se você se pega repetindo as mesmas diretrizes—como pedir ao Claude após escrever código para "revisar sob a perspectiva de um revisor experiente, focando em segurança e padrões de nomenclatura"—vale mais a pena consolidar essas instruções em um subagente chamado code-reviewer para acioná-lo de forma simplificada. Citação oficial: "Quando você criar repetidamente o mesmo tipo de agente usando as mesmas instruções, defina um subagent personalizado."

A especialização ocorre em duas frentes: persona dedicada (com prompt de sistema definindo-o rigidamente como um revisor exigente) e ferramentas dedicadas (um revisor precisa apenas ler arquivos, então removemos privilégios de escrita ou edição, impedindo modificações acidentais).

Problema 3: Paralelismo

Terceiro caso de uso: distribuir tarefas independentes para múltiplos subagentes executarem em paralelo.

Por exemplo, "pesquise separadamente sobre os módulos de autenticação, banco de dados e API"—como não há dependências mútuas, você pode iniciar três subagentes em paralelo para pesquisar e depois consolidar os resultados por meio do Claude. Em vez de esperar sequencialmente, tudo é resolvido de uma vez.

O obstáculo contraintuitivo: Nem sempre dividir é a melhor opção

Após apresentar os três casos de uso, retomamos o ponto inicial—por que dividir logo no começo é um erro?

Iniciantes costumam acreditar na premissa: "dividir em mais partes = mais profissional = mais rápido". Ocorre exatamente o oposto. Subagentes trazem três custos implícitos que se tornam evidentes em tarefas simples:

Comparação	Tarefas simples resolvidas diretamente na conversa principal	Tarefas simples divididas de forma forçada para subagentes
Sobrecarga de inicialização	Nenhuma; pronto imediato	Inicia do zero; precisa gastar tempo buscando contexto para entender o estado
Iteração de comunicação	Diálogo dinâmico e ajustes imediatos	Instruções vagas geram retrabalho; ele não vê discussões anteriores
Custo	Custo único de tokens	Múltiplos contextos = consumo maior de tokens; mais agentes consomem mais tokens
Retorno de resultados	Inexistente	Cada agente envia resumos de volta, o que pode poluir novamente a conversa se forem muitos

A documentação oficial fornece uma lista de critérios sobre "quando usar a conversa principal versus subagentes", que resumo assim: tarefas com interações frequentes, compartilhamento de contexto amplo, pequenas edições rápidas ou que exigem baixa latência devem permanecer na conversa principal; tarefas autossuficientes, que exigem restrições de ferramentas ou produzem muitos dados intermediários indesejados devem ser terceirizadas.

A documentação também ressalta um detalhe contraintuitivo—subagentes são desvantajosos em tarefas onde a latência é crítica:

A latência é importante. Os subagents começam do zero e podem precisar de tempo para coletar contexto.

Cenário real: Insistir em usar um subagente para algo simples como "renomear uma variável" apenas para parecer profissional trará problemas. O agente precisará ler o arquivo do zero (já que não compartilha do contexto atual) e fará a alteração lentamente antes de retornar o resultado, demorando muito mais do que se você simplesmente pedisse no chat principal "altere o nome da variável X", além de consumir mais tokens. Guarde esta regra prática: tarefas simples, fáceis de explicar e de escopo imediato nunca devem ser terceirizadas.

💡 Resumo em uma frase: Subagentes resolvem isolamento de contexto, especialização e execução paralela; mas tarefas simples são mais rápidas e baratas quando resolvidas diretamente—dividir demais não traz profissionalismo, apenas lentidão, custo extra e poluição de contexto.

---

03 Como criar: Processo interativo com /agents

Agora que compreendemos o cenário de uso, vamos criar um. O caminho mais simples é usar o comando /agents, que oferece uma interface interativa sem exigir escrita manual de configurações.

Na sessão do Claude Code, digite:

/agents

Isso exibirá a interface de gerenciamento. O fluxo de criação sugerido na documentação oficial é o seguinte (siga estes passos simples):

1. Definir local: Vá para a aba Library → Create new agent → selecione Personal. Escolher Personal salvará o agente em ~/.claude/agents/, permitindo que ele seja usado em any projeto; selecionar Project limitará o uso ao projeto atual, permitindo versionamento via git com a equipe (as diferenças serão detalhadas a seguir).
2. Geração assistida pelo Claude: Escolha Generate with Claude e descreva em linguagem natural o tipo de assistente que deseja. Por exemplo: "Um assistente de revisão de código que analisa arquivos e oferece sugestões sob três aspectos: legibilidade, desempenho e boas práticas, destacando os problemas com trechos de código e sugerindo melhorias". O Claude gerará automaticamente o nome, descrição e o prompt de sistema personalizado.
3. Escolha de ferramentas: Como o revisor só deve ler dados, marque apenas Read-only tools e desmarque o restante. Lembrete da documentação oficial: "Se você mantiver todas as ferramentas selecionadas, o subagent herdará o acesso a todas as ferramentas da conversa principal" — portanto, defina os limites necessários.
4. Seleção de modelo: Defina o modelo a ser usado. Para tarefas de revisão, a documentação sugere usar o Sonnet (melhor balanço entre velocidade e qualidade de análise).
5. Salvar: Avalie as configurações geradas e salve pressionando s ou Enter para começar a usar. (A interface perguntará sobre cores de fundo e escopo de memória (memory scope); a cor é opcional e a memória pode ser deixada como None por padrão).

Analogia: Preencher um formulário de contratação. Você não precisa redigir contratos; o assistente interativo (/agents) faz perguntas passo a passo: nome da função, tarefas atribuídas, ferramentas permitidas e nível de habilidade requerido—após responder, o subagente está criado. O Generate with Claude funciona como um recrutador ajudando a preencher a vaga da melhor forma.

Cenário real: É assim que se cria um subagente de utilidade diária—por exemplo, um test-runner focado em "executar testes e apenas reportar falhas e mensagens de erro". Configurá-lo com permissões exclusivas de Read e Bash (sem Write) impede que ele altere acidentalmente seu código durante a execução. Uma vez configurado, estará sempre pronto.

💡 Resumo em uma frase: A interface /agents é o caminho sugerido para criar subagentes de forma interativa, facilitando a execução do prompt de sistema; restringir as ferramentas é importante, caso contrário, ele herdará todos os privilégios do chat principal.

---

04 Como criar: Escrevendo um arquivo de configuração manualmente

Após ser criado via interface interativa, o subagente é salvo no disco como um arquivo Markdown. Compreender este formato permite editar ou escrever configurações manualmente.

O arquivo do subagente possui a seguinte estrutura—um bloco YAML (frontmatter) no topo define os parâmetros e o corpo do texto abaixo determina a persona (prompt de sistema):

---
name: code-reviewer
description: Reviews code for quality and best practices
tools: Read, Glob, Grep
model: sonnet
---

You are a code reviewer. When invoked, analyze the code and provide
specific, actionable feedback on quality, security, and best practices.

Crachá de identificação e manual de instrução. O bloco YAML representa o crachá com informações básicas—nome, descrição, ferramentas liberadas e modelo usado (name/description/tools/model); o corpo do texto abaixo é o manual de tarefas do subagente contendo instruções como "quem você é, por onde começar e quais regras seguir". Ele se limita a esses dados, sem acessar outras informações confidenciais do seu ambiente.

De acordo com as especificações oficiais, apenas name e description são obrigatórios; o restante pode ser omitido. Abaixo estão listados os campos mais comuns:

Campo	Obrigatório	Função	Dica rápida
name	Sim	Identificador exclusivo usando letras minúsculas e hifens (ex: code-reviewer)	Deve ser exclusivo no escopo para evitar conflitos silenciosos
description	Sim	Informa ao Claude qual tipo de tarefa deve ser delegada a ele	Quanto mais claro, mais precisa será a delegação automática; é a chave para o acionamento
tools	Não	Ferramentas permitidas	Se omitido, herda todas as ferramentas da conversa principal; liste as permitidas para restringir
model	Não	Modelo de IA usado	sonnet/opus/haiku/inherit; o padrão é inherit (o mesmo do chat principal)
permissionMode	Não	Modo de permissão	Opções: default/acceptEdits/auto/dontAsk/bypassPermissions/plan

O local do arquivo define seu escopo de uso. Apenas dois locais principais precisam ser memorizados por iniciantes:

Onde salvar	Quem pode usar	Adequado para
~/.claude/agents/	Todos os seus projetos	Assistentes de uso geral pessoal (como um revisor de código frequente)
.claude/agents/	Apenas no projeto atual	Assistentes dedicados ao repositório; pode ser versionado no git para equipe

A recomendação oficial sobre agentes locais de projeto é muito prática:

Subagents de projeto (.claude/agents/) são ideais para agentes específicos de um repositório. Envie-os ao controle de versão para que sua equipe possa colaborar no uso e melhoria deles.

Um erro clássico de iniciantes, destacado nas notas oficiais: arquivos editados manualmente ou diretamente no disco só serão carregados após reiniciar a sessão; alterações feitas pela interface /agents entram em vigor instantaneamente. Na primeira vez em que escrever um subagente, caso note falta de resposta após chamá-lo, o motivo costuma ser a necessidade de reinicialização da sessão.

💡 Resumo em uma frase: Um subagente é apenas um arquivo Markdown contendo configurações YAML (sendo obrigatórios apenas name e description) e um corpo com as instruções; use ~/.claude/agents/ para fins globais e .claude/agents/ para compartilhar no repositório; lembre-se de reiniciar a sessão após edições manuais.

---

05 Como acionar: Delegação automática versus menção direta

Uma vez criado, como acionar o subagente? Existem dois caminhos: o Claude delega automaticamente com base na descrição da tarefa, ou você o chama diretamente pelo nome.

Caminho 1: Delegação automática guiada por description

Ao fazer uma solicitação padrão, o Claude comparará sua instrução com a description de todos os subagentes e delegará a tarefa se houver compatibilidade. Você sequer precisa acioná-lo de forma explícita.

Essa é a razão pela qual enfatizamos a importância de uma description bem estruturada—ela serve de guia para a distribuição de tarefas feita pelo Claude. Uma técnica útil indicada na documentação é incluir termos como "use de forma proativa" (use proactively) na descrição para encorajar o Claude a usar o agente. Por exemplo, definir a descrição de um revisor como "iniciar revisão proativamente após criar ou modificar código" pode fazer com que o Claude o chame automaticamente logo após edições.

Analogia: A clareza da descrição da vaga define a assertividade na distribuição. A description funciona como uma especificação de trabalho. Definições vagas ("realiza tarefas gerais") dificultam a decisão de delegação do assistente principal; enquanto descrições precisas ("revisa padrões de nomenclatura e segurança, agindo proativamente após alterações") garantem que o assistente certo seja escolhido.

Caminho 2: Menção direta por você

Se preferir não depender da delegação automática ou desejar chamar um agente específico, use a menção direta. Existem diferentes maneiras sugeridas oficialmente, sendo as duas primeiras suficientes para iniciantes:

Menção em linguagem natural—chame-o pelo nome no chat de forma direta, sem sintaxe rígida:

Use o subagente code-reviewer para verificar minhas últimas alterações

Menção usando @—digite @ para escolher na lista flutuante (que adiciona a formatação @"code-reviewer (agent)"), ou escreva manualmente @agent- seguido do nome. Esse método força o uso do agente, retirando a escolha do Claude:

@agent-code-reviewer revise as modificações do módulo de autenticação

A diferença é explicada claramente na documentação oficial: a menção natural indica que "o Claude provavelmente delegará", enquanto o uso de @ "garante a execução do subagente". Uma boa prática: use @ ao testar agentes novos para evitar que o Claude decida não chamá-los por conta própria.

Como os resultados retornam

Independentemente da forma de acionamento, o subagente processa tudo em seu próprio espaço e retorna apenas o "resultado" para a conversa principal. É a aplicação prática da nossa analogia: o assistente lê todas as logs e traz apenas o bilhete com as linhas de erro. A documentação indica que ele "trabalha de forma independente e retorna resultados", e "a saída detalhada permanece no contexto do subagent, enquanto apenas o resumo retorna para o chat principal".

⚠️ Atenção ao volume de dados retornados: iniciar muitos subagentes que retornam relatórios gigantescos acabará poluindo sua mesa de trabalho do mesmo jeito. Use o paralelismo com moderação—como indicado na Seção 02: terceirize apenas tarefas autocidas que dependem de respostas breves.

💡 Resumo em uma frase: O acionamento pode ocorrer via description (delegação automática de tarefas claras) ou por menção direta natural/@ (sendo o @ a garantia de execução); embora retorne apenas resumos, o excesso de agentes pode congestionar o chat principal.

---

06 Prática: Criando um subagente mínimo e colocando-o para rodar em 5 minutos

Nada melhor do que testar na prática. Vamos escrever manualmente um subagente básico e executá-lo para ver a dinâmica de "delegação → resumo de resposta" funcionando. Sem dependências de software complexas.

Criaremos o agente mais básico possível: um "revisor crítico de código" somente leitura que lê arquivos e sugere melhorias, sem permissão para alterar qualquer caractere (liberando ferramentas Read e bloqueando Write/Edit).

Passo 1: Criar a estrutura de diretórios e o projeto de teste (PowerShell)

New-Item -ItemType Directory -Path "sub-demo\.claude\agents" -Force
cd sub-demo

Passo 2: Escrever o arquivo de configuração do subagente

Com seu editor preferido, crie o arquivo sub-demo/.claude/agents/code-reviewer.md e insira o seguinte conteúdo:

---
name: code-reviewer
description: Revisor de código somente leitura que analisa arquivos e sugere melhorias em legibilidade, nomenclatura e bugs potenciais. Usar de forma proativa ao revisar códigos.
tools: Read, Grep, Glob
---

Você é um revisor de código experiente. Seu papel é apenas encontrar problemas, sem alterar o código.
Quando chamado:
1. Leia o arquivo especificado pelo usuário.
2. Agrupe as observações em três categorias: legibilidade, nomenclatura e potenciais bugs.
3. Forneça sugestões práticas de melhoria para cada problema encontrado, mas nunca altere os arquivos diretamente.

Classifique por nível de severidade: Obrigatório, Recomendado, Opcional.

Note que omitimos o campo model—seguindo o comportamento padrão, ele usará inherit (o mesmo modelo do chat principal). Definimos apenas as três ferramentas de leitura em tools, impedindo ações de escrita.

Passo 3: Criar um código de teste com pontos a melhorar

Use um editor para criar calc.py e insira o seguinte código:

def f(a, b):
    return a / b

Esse nome de função f e parâmetros a/b são ruins, e o código não trata divisão por zero—um cenário perfeito para nosso revisor.

Resultado esperado: O arquivo calc.py foi criado no diretório sub-demo com o conteúdo acima.

Passo 4: Iniciar o Claude e chamar o subagente

claude

Ao entrar, use o @ para chamá-lo diretamente (garantindo que ele seja executado sem depender do assistente principal). Digite @agent-code-reviewer ou selecione-o no menu flutuante:

@agent-code-reviewer revise o arquivo calc.py

Resultado esperado: Você verá o Claude delegando a tarefa ao subagente code-reviewer (com a interface indicando a execução dele, possivelmente marcada por cores). Ele lerá calc.py em seu próprio contexto e retornará apenas o relatório de revisão no chat principal—apontando que o nome de função f e parâmetros a/b não são claros, a falta de validação para divisão por zero, e sugerindo nomes melhores e tratamento de exceção. Observe que ele sugere as mudanças mas não altera o arquivo (devido às restrições de privilégios de escrita).

Passo 5: Confirmar que o arquivo não foi modificado

Saia do Claude (digitando exit ou usando Ctrl+D) e verifique o arquivo no terminal:

Get-Content calc.py

Resultado esperado: O arquivo calc.py permanece inalterado, contendo apenas as duas linhas originais—essa é a segurança de limitar ferramentas: com privilégios apenas de leitura, ele não consegue alterar arquivos mesmo que tente.

Ao testar estes cinco passos, você terá validado todo o fluxo de ponta a ponta: "definir configuração → carregamento → chamada direta → execução em contexto isolado → retorno de resumo sem privilégios extras". Qualquer subagente avançado operará sob essa mesma infraestrutura básica, variando apenas o prompt e as ferramentas permitidas.

⚠️ Se o @agent-code-reviewer não aparecer na listagem ao digitar @, provavelmente as novas configurações manuais não foram recarregadas—sessões manuais precisam ser reiniciadas (como visto na Seção 04). Saia e entre novamente, ou use a criação via /agents para ativação imediata.

💡 Resumo em uma frase: Escrever manualmente um agente com permissão apenas de leitura, chamá-lo com @ e confirmar que o arquivo original não foi alterado na prática—testar esse isolamento ensina muito mais do que decorar propriedades de configuração.

---

07 Resumo

Neste artigo, passamos pelas etapas de "quando usar", "como construir", "como acionar" e "como validar" subagentes—o objetivo principal não é criar múltiplos agentes desnecessários, mas sim estabelecer o discernimento para decidir quando terceirizar ou agir diretamente.

Revisão rápida dos pontos essenciais:

Dúvida comum	Resposta	Ponto-chave
O que é um subagente	Assistente com contexto, persona e ferramentas independentes	Inicia do zero, sem ler discussões prévias
O que ele resolve	Isolamento de contexto, especialização e paralelismo	O principal valor é reter detalhes intermediários no contexto do agente e retornar apenas resumos
Quando não usar	Tarefas simples, de interação contínua ou sensíveis a atrasos	Dividir demais gera lentidão e desperdício de tokens
Como criar	Pelo menu /agents ou criando arquivos em .claude/agents/	Campos obrigatórios são apenas name e description; edições no disco exigem reiniciar a sessão
Como acionar	Delegação automática por description, menção natural ou @	O @ garante a chamada; descrições claras ajudam na delegação automática

Agora você deve ser capaz de: Avaliar se uma tarefa deve ou não ser delegada (evitando divisões desnecessárias), criar agentes via /agents ou manualmente com permissão e persona dedicadas, e chamá-los por menção natural ou @ para obter apenas respostas diretas de volta no chat. Esse equilíbrio de saber quando terceirizar e quando agir no chat principal é a principal virtabilidade no uso de subagentes—as funções em si são aprendidas rapidamente, mas o discernimento vem com o uso diário.

Guarde o ensinamento contraintuitivo do início: subagentes são excelentes, mas o valor real reside em usá-los no momento correto, não na quantidade de agentes criados.

💡 Resumo em uma frase: O desafio não é criar agentes, mas sim saber quando usá-los—terceirize tarefas poluentes de contexto, autocidas ou sob restrição de escrita; execute no chat principal edições imediatas ou conversações dinâmicas.

---

No próximo artigo, 24 "Plugins (Plugins)"—a lista de recursos adicionais que você domina está crescendo: CLAUDE.md, comandos slash, Skills e agora Subagents. Configurá-los um a um pode parecer um tanto fragmentado. O próximo artigo ensinará você a empacotar esses recursos em um Plugin, facilitando a instalação, compartilhamento ou uso de soluções prontas da "loja de plugins". Já pensou em importar comandos e subagentes prontos de terceiros com um único comando?

---

Leitura Recomendada

• Manual do CLI: Comandos e flags globais
• Criação de vídeos com Remotion (Leitura opcional)
• Instalação e uso básico