Como Skills, Agentes e Servidores MCP Funcionam Juntos no Claude Code
Você provavelmente já bateu nessa parede antes: você cola toda a sua base de código em um chat de IA, adiciona um prompt detalhado e recebe de volta... nada útil. Ou pior, o modelo começa a alucinar nomes de funções que não existem porque perdeu o controle do que leu 50.000 tokens atrás.
Este é o problema da janela de contexto. E é por isso que jogar mais código em um LLM não o torna mais inteligente.
O Claude Code resolve isso de forma diferente. Não por ter uma janela de contexto maior (embora isso ajude), mas por ser inteligente sobre como usa o espaço que tem. Ele faz isso através de três coisas trabalhando juntas: skills, sub-agentes e servidores MCP.
Deixe-me mostrar como essas peças se encaixam. Uma vez que você entenda isso, vai parar de lutar contra a IA e começar a trabalhar com ela.
O Problema da Janela de Contexto
Aqui está algo que levei um tempo para internalizar: LLMs não "lembram" realmente o início de uma conversa longa da maneira que você esperaria. A janela de contexto é mais como um holofote do que um arquivo. À medida que você adiciona mais tokens, o conteúdo anterior recebe menos atenção. Cole 100.000 tokens de código e o modelo está essencialmente folheando quando chega à sua pergunta.
Isso explica muito do comportamento frustrante da IA. O modelo parece inteligente no início, depois fica confuso. Ele esquece coisas que você disse antes. Ele alucina detalhes de arquivos que "leu", mas claramente não reteve.
A solução não é uma janela de contexto maior. A solução é não precisar de uma.
Como o Claude Code Realmente Pensa
O Claude Code é um agente. Isso parece sofisticado, mas significa apenas que ele pode planejar, executar, observar resultados e iterar. Quando você pede para ele "corrigir os testes que estão falhando no meu projeto", ele não tenta entender toda a sua base de código de uma vez. Em vez disso, ele trabalha em etapas focadas:
- Ler a estrutura do projeto para entender o que está onde
- Executar os testes para ver o que realmente está falhando
- Olhar o teste específico que está falhando e o código que ele testa
- Fazer uma correção
- Executar os testes novamente
- Se ainda estiver quebrado, tentar outra coisa
Cada etapa trabalha apenas com o contexto que precisa. O agente mantém um resumo funcional do que aprendeu, não um registro bruto de tudo que viu. É assim que o Claude Code pode iterar 20 vezes em um bug complexo sem ficar sem espaço de contexto.
Pense nisso como você realmente depuraria algo. Você não mantém toda a sua base de código na cabeça. Você foca em uma área, forma uma hipótese, testa e ajusta. O Claude Code funciona da mesma maneira.
Sub-Agentes: O Verdadeiro Diferencial
Aqui é onde fica realmente interessante. O Claude Code pode gerar sub-agentes.
Um sub-agente é uma instância separada do Claude com sua própria janela de contexto limpa. Você pode dizer ao Claude Code para criar um, dar a ele uma tarefa focada, deixá-lo trabalhar independentemente e receber de volta um resumo do que ele encontrou. O contexto completo do sub-agente nunca polui sua conversa principal.
Isso é enorme. Em vez de um agente tentando segurar tudo:
Você: "Analise esta base de código em busca de problemas de segurança, problemas de desempenho e cobertura de testes"
Agente principal gera sub-agentes:
├── Sub-agente 1: Análise de segurança (contexto próprio, lê arquivos relevantes de segurança)
├── Sub-agente 2: Revisão de desempenho (contexto próprio, foca em caminhos críticos)
└── Sub-agente 3: Cobertura de testes (contexto próprio, examina arquivos de teste)
Cada sub-agente retorna um resumo ao agente principal Agente principal sintetiza tudo em uma resposta
Os sub-agentes podem ler milhares de linhas de código cada um. Mas o agente principal recebe apenas suas descobertas condensadas. Seu contexto principal permanece limpo enquanto ainda obtém análise profunda em múltiplas áreas.
Pense nisso como delegar para desenvolvedores juniores. Você não precisa ler cada linha que eles revisaram. Você precisa das conclusões deles e quaisquer sinais de alerta que encontraram. Sub-agentes funcionam da mesma maneira.
Como Realmente Usar Sub-Agentes
Você pode explicitamente pedir ao Claude Code para gerar um sub-agente:
- "Gere um sub-agente para analisar o módulo de autenticação em profundidade"
- "Use um sub-agente para revisar todas as consultas ao banco de dados em busca de problemas N+1"
- "Peça a um sub-agente para revisar os arquivos de teste e relatar lacunas de cobertura"
O sub-agente obtém seu próprio contexto novo, faz o trabalho profundo e retorna um resumo. Sua conversa principal não fica inchada com toda a análise bruta.
Isso é especialmente poderoso para bases de código grandes. Em vez do Claude Code perder o controle das coisas no meio do caminho, você obtém análise focada que realmente escala.
Onde as Skills Entram
Então o Claude Code pode dividir tarefas, gerar sub-agentes e trabalhar em etapas focadas. Mas como ele sabe como fazer coisas específicas bem? É aí que as skills entram.
Skills são instruções empacotadas que o Claude lê antes de abordar tipos específicos de tarefas. Quando você pede ao Claude Code para criar uma apresentação PowerPoint, ele primeiro lê o arquivo de skill em /mnt/skills/public/pptx/SKILL.md. Este arquivo contém melhores práticas, armadilhas comuns e padrões de código exatos que realmente funcionam.
Uma skill normalmente inclui:
- Um arquivo
SKILL.mdcom instruções detalhadas - Templates de código e exemplos
- Limitações conhecidas e soluções alternativas
- Especificações de formato de saída
A percepção chave é que as skills são carregadas sob demanda. O Claude não desperdiça espaço da janela de contexto com instruções de PowerPoint quando você está depurando Python. Ele carrega a skill relevante quando precisa, usa essa expertise para a tarefa e segue em frente.
Isso é diferente de ferramentas. Ferramentas são funções que o Claude chama para obter dados de volta, como web_search ou bash_tool. Skills são pacotes de conhecimento que mudam como o Claude aborda problemas. A distinção importa porque ferramentas custam tokens no prompt do sistema (mais ferramentas = menos espaço para seu código), enquanto skills são carregadas apenas quando relevantes.
| Aspecto | Ferramentas | Skills |
|---|---|---|
| Como funciona | Chamar função, obter resultado | Carregar instruções, modificar comportamento |
| Custo de token | Sempre presente no contexto | Carregado sob demanda |
| Melhor para | Ações discretas (chamadas de API, operações de arquivo) | Fluxos de trabalho complexos (criação de documentos) |
Sub-agentes também podem carregar skills. Um sub-agente analisando segurança pode carregar skills específicas de segurança sem que essas instruções atrapalhem sua conversa principal.
O Loop de Iteração
Um padrão que você verá constantemente é o loop de iteração. O Claude Code gera algo, verifica se funciona e corrige problemas até estar certo.
- Gerar código
- Executá-lo (ou fazer lint, ou verificar tipos)
- Ver se funciona
- Se não, analisar o erro e tentar novamente
- Repetir até passar
É por isso que o Claude Code pode corrigir bugs que um prompt de tentativa única perderia. Ele não está apenas gerando código e esperando. Ele está testando seu próprio trabalho e respondendo a feedback real.
Quando o Claude Code cria um componente React e então executa o servidor de desenvolvimento para verificar erros, ele está usando esse loop. Quando ele escreve uma função e executa os testes para verificar se funciona, mesma coisa. As etapas de geração e verificação trabalham juntas.
Isso também explica por que o Claude Code às vezes leva mais tempo do que você esperaria. Ele não é lento. Ele é minucioso. Ele está executando seus testes, verificando erros de tipo e iterando até que as coisas realmente funcionem.
Servidores MCP: Conectando a Sistemas Externos
Até agora falamos sobre como o Claude Code pensa (etapas agênticas, sub-agentes) e o que ele sabe (skills). Mas e quanto a conectar a sistemas externos? É aí que o MCP entra.
O Model Context Protocol é como o Claude Code conversa com bancos de dados, GitHub, sistemas de arquivos, pipelines de CI/CD e praticamente qualquer outra coisa. Pense no MCP como USB-C para IA: uma interface padrão que permite que qualquer sistema de IA compatível se conecte a qualquer serviço compatível.
Servidores MCP expõem três tipos de capacidades:
Ferramentas - Funções que o Claude pode chamar, como consultar um banco de dados ou criar um pull request
Recursos - Fontes de dados que o Claude pode ler, como conteúdo de arquivos ou esquemas de banco de dados
Prompts - Templates reutilizáveis para interações comuns
Para desenvolvimento web, os servidores MCP mais úteis incluem:
- Servidor de sistema de arquivos - Ler e escrever arquivos em seu projeto (isolado por segurança)
- Servidor GitHub - Gerenciar repositórios, PRs, issues e workflows
- Servidores de banco de dados - Consultar PostgreSQL, MySQL, SQLite através de linguagem natural
Aqui está como um servidor MCP simples se parece em TypeScript: typescript import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
const server = new McpServer({ name: 'code-analyzer', version: '1.0.0' });
server.registerTool( 'analyze_complexity', { description: 'Analyze cyclomatic complexity of a file', inputSchema: { filePath: { type: 'string' } } }, async ({ filePath }) => { const result = await analyzeFile(filePath); return { content: [{ type: 'text', text: JSON.stringify(result) }] }; } );
const transport = new StdioServerTransport(); await server.connect(transport);
O poder dos servidores MCP vem de como eles trabalham com sub-agentes. Um sub-agente pode consultar um banco de dados através do MCP, analisar milhares de linhas e retornar apenas as descobertas relevantes. Os dados brutos nunca tocam seu contexto principal.
Juntando Tudo
Vamos percorrer um exemplo real. Você pede ao Claude Code: "Revise este PR e verifique se as migrações do banco de dados são seguras."
Aqui está o que realmente acontece:
- Agente principal carrega skills relevantes para revisão de código
- Ele gera um sub-agente para analisar as mudanças do PR em profundidade
- Esse sub-agente chama o servidor MCP do GitHub para buscar detalhes do PR
- Outro sub-agente lê arquivos de migração e consulta o esquema atual do banco de dados através do MCP
- Sub-agentes retornam resumos focados: "Migração adiciona índice, parece seguro" ou "Aviso: isso remove uma coluna que ainda está referenciada"
- Agente principal sintetiza descobertas dos sub-agentes em uma resposta clara
Perceba como o trabalho pesado acontece em sub-agentes com seus próprios contextos. O agente principal orquestra e resume. Sua conversa permanece limpa enquanto obtém análise profunda.
Por Que Isso Importa Para Seu Fluxo de Trabalho
Entender essa arquitetura muda como você trabalha com o Claude Code:
Você para de lutar contra a janela de contexto. Uma vez que você percebe que sub-agentes lidam com análise profunda separadamente, você para de tentar colar toda a sua base de código na conversa principal. Deixe os sub-agentes fazerem a leitura pesada.
Você usa explicitamente sub-agentes para tarefas grandes. Em vez de esperar que o Claude Code descubra, diga a ele: "Use um sub-agente para analisar o módulo de pagamento" ou "Gere sub-agentes para revisão de segurança, desempenho e testes." Você está trabalhando com a arquitetura em vez de contra ela.
Você entende por que algumas tarefas funcionam melhor que outras. Tarefas que podem ser delegadas a sub-agentes escalam muito bem. Tarefas que requerem ida e volta constante em um contexto atingem limites mais rápido.
Você confia no loop de iteração. Ao corrigir bugs, deixe o Claude iterar. Ele frequentemente encontrará problemas que você não antecipou ao realmente executar o código e observar falhas. Não o interrompa após a primeira tentativa.
Dicas Práticas
Peça explicitamente por sub-agentes em tarefas grandes. "Gere um sub-agente para revisar o sistema de autenticação" funciona melhor do que esperar que o Claude Code descubra que precisa delegar.
Deixe o Claude ler skills primeiro. Se você está criando documentos ou trabalhando com formatos de arquivo específicos, o Claude tem melhor desempenho quando lê o arquivo de skill relevante antes de começar.
Conecte servidores MCP para integrações repetitivas. Em vez de copiar e colar saídas de banco de dados ou detalhes de PR do GitHub em seus prompts, conecte os servidores MCP relevantes. O Claude puxa exatamente o que precisa.
Verifique o ecossistema antes de construir ferramentas personalizadas. O ecossistema MCP cresceu para mais de 5.000 servidores comunitários cobrindo Stripe, Cloudflare, sistemas de CI e a maioria dos serviços que você gostaria de integrar. Alguém provavelmente já construiu o que você precisa.
Dê feedback quando estiver errado. Quando o Claude Code produz resultados errados, diga a ele o que deu errado. O loop de iteração funciona para seu feedback também.
O Panorama Geral
O MCP foi recentemente doado à Linux Foundation, com OpenAI, Google e Microsoft se juntando como membros de apoio. Isso sinaliza que o protocolo está se tornando infraestrutura padrão da indústria, não apenas uma coisa da Anthropic.
A combinação de sub-agentes (trabalho paralelo em contextos separados), skills (expertise de domínio carregada sob demanda) e servidores MCP (conexões limpas a sistemas externos) representa como assistentes de codificação de IA modernos realmente funcionam. Não é mágica. É boa arquitetura resolvendo restrições reais.
O padrão de sub-agente especialmente vale a pena entender profundamente. É a diferença entre uma IA que engasga em bases de código grandes e uma que escala. Quando você pede ao Claude Code para analisar algo grande, ele não está empurrando tudo em um contexto e rezando. Ele está delegando a sub-agentes focados, cada um com contexto limpo, e sintetizando suas descobertas.
Entender essas peças ajuda você a trabalhar com o sistema em vez de contra ele. Você obterá melhores resultados, encontrará menos obstáculos e saberá quando confiar na IA versus quando assumir manualmente.
