Claude skills vs MCP vs subagents: quando usar cada um

Confundir essas quatro primitivas não quebra nada de forma visível. Só deixa a arquitetura um pouco pior, em silêncio, toda vez que você mexe nela.

Skills, MCP servers, subagents e CLAUDE.md parecem todos “jeitos de dar mais ao Claude”. Não são intercambiáveis. Cada um tapa um buraco específico, e a sobreposição é rasa.

Se você é novo em skills do Claude Code, o guia para criar skills no Claude Code cobre SKILL.md, referências e progressive disclosure por completo. Comece por lá e depois volte.

Este artigo é o mapa de decisão: qual primitiva para qual problema, quando combinar e um checklist para cada uma.

Quatro primitivas, quatro trabalhos

O Claude Code tem quatro primitivas: a skill (método versionado, sem runtime), o MCP server (protocolo que expõe ferramentas e dados ao vivo), o subagent (contexto isolado para paralelismo ou estado limpo) e a memória no CLAUDE.md (contexto de fundo sempre ligado). Cada uma resolve um problema distinto. Usar a errada é silencioso: nada quebra, a arquitetura só piora.

Quatro primitivas, um trabalho cada

Cada primitiva tem um trabalho. O erro comum é tratá-las como intercambiáveis.

Dimensão	Skill	Ferramenta MCP	Subagent	Memória
O que é	Método versionado em SKILL.md + referências	Servidor que expõe ferramentas/dados em runtime	Contexto isolado (frontmatter fork/agent)	Contexto sempre ligado (CLAUDE.md)
Tem runtime?	Não	Sim	Sim	Não
Como é acionado?	O modelo lê o SKILL.md ao ser invocado	O agente chama a ferramenta via protocolo	Criado pelo orquestrador via frontmatter	Sempre no contexto, sem gatilho
Persiste entre sessões?	Sim (arquivo versionado)	Sim (o servidor continua de pé)	Não (worker efêmero)	Sim (arquivo CLAUDE.md)
Melhor para	Método repetível, consistência	Acesso a ferramentas/dados, sistemas ao vivo	Isolamento, paralelismo, tarefas longas	Contexto de projeto/usuário sempre ligado

As quatro primitivas não competem. Elas operam em camadas diferentes. Uma skill não é um MCP mais leve. Um subagent não é uma skill com mais isolamento. O CLAUDE.md não é uma skill que você esqueceu de acionar. Combinar as quatro do jeito certo é o que faz um workflow de produção de verdade.

MCP é a cozinha; a skill é a receita

O MCP expõe capacidade. É o conjunto de facas, panelas e ingredientes crus que o seu agente tem à mão. A skill é o que o agente faz com isso: um método repetível com um padrão de saída. Dá para ter cozinha sem receita (resultados inconsistentes) ou receita sem cozinha (belas intenções, nada no prato).

A analogia quebra se você forçar. Alguns workflows precisam de MCP sem skill: uma consulta pontual num banco ao vivo não precisa de método por trás. Outros precisam de skill sem MCP: uma tarefa pura de raciocínio ou julgamento que só usa as ferramentas nativas. Combine as duas quando a tarefa for estruturada e dependente de ferramenta ao mesmo tempo.

Quando a skill é a ferramenta certa

A skill entra na stack quando você tem um método que vale repetir. Não uma consulta pontual que você digita ali mesmo. Um padrão de julgamento que se repete, um framework que você resolveu uma vez e não quer reconstruir a cada sessão. Skills servem para consistência. Se você está copiando e colando o mesmo prompt longo, já está construindo uma skill; só não formalizou ainda.

O sinal é a recorrência. Eu uso uma skill de avaliação de ofertas apoiada em 13 referências do Hormozi. Toda avaliação roda o mesmo framework, checa os mesmos critérios e entrega o mesmo padrão. Não reescrevo isso a cada sessão. A skill está versionada no git, carrega de forma consistente e melhorou a cada iteração.

Também uso um sistema completo de skills lifeos-*: lifeos-capture, lifeos-ingest, lifeos-study, lifeos-plan, lifeos-review. Cada uma é um módulo próprio, com suas referências e regras de decisão. Nenhuma delas é prompt que eu repito. São métodos que eu mantenho.

A skill não é a escolha certa quando:

• A tarefa é pontual de verdade, sem recorrência
• O que você precisa é de uma chamada de ferramenta, não de um método (trabalho do MCP)
• A tarefa precisa de contexto isolado ou paralelismo (trabalho do subagent)
• Você quer dar ao agente fatos de fundo, do ambiente (trabalho do CLAUDE.md)

Quando o MCP é a ferramenta certa

O MCP entra na stack quando o agente precisa fazer algo que não consegue com as ferramentas nativas: escrever no sistema de arquivos, consultar um banco ao vivo, automatizar um navegador, chamar uma API externa. Não serve para julgamento ou método. Serve para acesso. A maioria dos workflows reais empilha os dois: a skill diz ao agente o que fazer; o MCP torna a ação possível.

Construa uma skill quando...

1. 01O mesmo julgamento ou método se repete e precisa de consistência
2. 02Você tem um framework para destilar, não só uma ferramenta para chamar
3. 03Você quer o mesmo padrão de saída aplicado em toda sessão
4. 04Copiar e colar o mesmo prompt longo já é o seu workflow atual
5. 05Você está codificando um processo de decisão, não adicionando uma capacidade

Construa um MCP server quando...

1. 01O agente precisa de acesso a um sistema ao vivo, uma API ou um banco de dados
2. 02A tarefa exige escrever, ler ou executar algo externo
3. 03Você precisa controlar o navegador, operar arquivos ou ter dados em tempo real
4. 04As ferramentas nativas não bastam e o buraco é de capacidade, não de método
5. 05Você quer compartilhar uma ferramenta entre várias skills ou agentes

O modo de falha do MCP é recorrer a ele quando o que você precisa é de uma skill. Se os resultados do agente são inconsistentes entre sessões, mas ele tem acesso às ferramentas certas, o problema é um método que falta, não um servidor que falta.

O modo de falha de uma skill sem MCP é escrever um método que manda o agente chamar ferramentas que ele não tem. Uma skill pode instruir o agente a usar as ferramentas nativas que ele já tem, mas não consegue inventar capacidades novas. Se o método precisa de dados ao vivo ou de uma ação externa, o MCP é a camada que falta.

Quando o subagent é a ferramenta certa

Um subagent é um contexto isolado do Claude. Use quando a tarefa for longa demais para a sessão principal, quando você precisar de estado limpo sem vazamento de contexto ou quando der para rodar várias tarefas em paralelo. É uma fronteira de execução, não um upgrade de raciocínio. A skill continua dizendo como raciocinar; o subagent só roda isso numa janela separada.

Tarefas longas. Uma tarefa que ameaça consumir a context window principal (pesquisa profunda, análise em várias etapas, refactors grandes) vai para um subagent. O orquestrador cria o subagent, ele roda até o fim e o resultado volta limpo.

Estado limpo. Se uma tarefa não deve ser influenciada pelo que aconteceu antes na sessão, crie um subagent. O contexto anterior não vaza para dentro.

Paralelismo. Vai rodar o mesmo método em cinco inputs? Cinco subagents, um por input, todos ao mesmo tempo. Cada um carrega a mesma skill, cada um roda no seu próprio contexto. Uso isso no workflow do lifeos-study: vários documentos, ingestão em paralelo, sem contaminação cruzada.

Um subagent não é outro motor de raciocínio. É o mesmo modelo num contexto separado. A skill define a qualidade do raciocínio; o subagent define a fronteira de execução.

Escolha a sua primitiva

Siga de cima para baixo. O primeiro que bater vence.

Qual primitiva?

• ✓Obrigatório:
  É um julgamento ou método repetível que você quer consistente entre sessões?Sim → skill. Construa SKILL.md + referências + um loading map.
• ✓Obrigatório:
  A tarefa exige acesso a um sistema ao vivo, uma API, um banco de dados ou uma capacidade externa?Sim → MCP server. Adicione uma skill por cima se também precisar de um método repetível.
• ✓Obrigatório:
  A tarefa precisa de estado limpo, ou o vazamento de contexto da sessão principal causaria problemas?Sim → subagent. Carregue uma skill dentro dele se o método tiver que ser consistente.
• ✓Obrigatório:
  É algo sempre verdadeiro sobre o projeto ou o usuário: fatos de fundo, não um método acionado?Sim → memória no CLAUDE.md. Isso é contexto de ambiente, não uma primitiva de tarefa.
• ✓Obrigatório:
  Você está rodando o mesmo método em vários inputs e quer paralelizar?Sim → skill dentro de um subagent, um subagent por input.
• •Opcional:
  É algo pontual de verdade, sem recorrência, sem ferramenta externa, sem isolamento?Sim → prompt simples, ali mesmo. Nenhuma infraestrutura necessária.

FAQ

Qual a diferença entre uma Claude skill e uma ferramenta MCP?+

Uma skill é um método versionado (SKILL.md mais arquivos de referência) que o modelo lê quando é invocada. Não tem runtime e não chama nenhum sistema externo por conta própria. Uma ferramenta MCP é um servidor que expõe capacidades reais: leituras em banco de dados, chamadas de API, ações no navegador, escrita no sistema de arquivos.

Versão curta: a skill diz ao agente como pensar; a ferramenta MCP dá a ele algo para fazer.

Uma skill e um MCP server funcionam juntos?+

Sim, e essa combinação é comum. A skill define o método: o que checar, em que ordem, com que padrão. O MCP server fornece a capacidade de que a skill precisa para agir.

A minha skill lifeos-capture codifica o método de captura no SKILL.md; o MCP server é quem de fato escreve a saída estruturada no sistema de arquivos. A skill sem MCP te dá instruções; o MCP sem a skill te dá execução inconsistente.

Quando usar um subagent em vez de rodar na sessão principal?+

Use um subagent quando a tarefa for longa o bastante para poluir o contexto principal, quando você precisar de estado limpo sem vazamento dos turnos anteriores ou quando estiver rodando a mesma tarefa em vários inputs e quiser paralelizar.

Um subagent é uma fronteira de execução, não um upgrade de raciocínio. A skill continua definindo o método lá dentro.

A memória do CLAUDE.md é a mesma coisa que uma skill?+

Não. A memória (CLAUDE.md) é contexto de fundo sempre ligado: o que é permanentemente verdade sobre o projeto ou o usuário. Nunca é acionada por uma tarefa específica.

Uma skill é ativada quando é relevante: instruções específicas, referências para carregar, um padrão de saída para seguir. Uma está sempre ligada; a outra dispara sob demanda.

Preciso de uma skill dentro do subagent, ou ele roda sem?+

Um subagent pode rodar com um prompt simples ou só com a memória. A skill faz diferença quando a tarefa do subagent segue um método repetível que você quer consistente em toda execução.

Se você se pega reescrevendo as instruções do subagent toda vez, esse é o sinal para extrair uma skill.

Qual o motivo mínimo para construir uma skill em vez de um prompt longo?+

Recorrência. Se você vai rodar o mesmo tipo de tarefa mais de uma vez, a skill se paga. Um prompt se degrada: é parafraseado, cortado e esquecido entre sessões. Uma skill fica versionada no git, carrega as mesmas referências toda vez e melhora a cada iteração.

O custo de setup é real, mas limitado: de uma a três horas para construir um SKILL.md decente e um punhado de referências. Tudo depois disso roda na infraestrutura que você construiu uma vez.

O que é progressive disclosure no contexto de skills?+

É o termo da Anthropic para o padrão de carregamento em três camadas embutido nas skills: o nome e a description da skill ficam sempre no contexto (metadados), o corpo do SKILL.md carrega quando a skill é invocada, e os arquivos de referência em references/ só carregam quando o modelo é explicitamente roteado até eles.

Isso mantém a context window enxuta. O loading map no SKILL.md é o que diz ao modelo quais referências buscar. Sem ele, o agente chuta, e o chute favorece os pesos em vez dos seus arquivos.

Elas se combinam

As quatro primitivas não competem, mas se combinam. Uma skill dentro de um subagent, apoiada em ferramentas expostas por MCP, é um padrão comum de produção, e é mais limpo do que parece quando cada camada sabe o seu trabalho.

O guia para criar skills no Claude Code cobre a camada de skill do zero. Se você ainda está decidindo entre uma skill e uma opção mais simples (um prompt, uma nota no CLAUDE.md), Claude skill vs prompt vs memória cobre essa fronteira. Para exemplos concretos de uma biblioteca de skills real, exemplos de Claude skills em produção é a continuação.

Escolha a primitiva que bate com o problema real. O resto é fiação.