Comment les compétences, les agents et les serveurs MCP fonctionnent ensemble dans Claude Code

Vous avez probablement déjà rencontré ce problème : vous collez l'intégralité de votre code dans un chat IA, ajoutez un prompt détaillé, et obtenez... rien d'utile. Ou pire, le modèle commence à halluciner des noms de fonctions qui n'existent pas parce qu'il a perdu le fil de ce qu'il a lu il y a 50 000 tokens.

C'est le problème de la fenêtre de contexte. Et c'est pourquoi balancer plus de code à un LLM ne le rend pas plus intelligent.

Claude Code résout ce problème différemment. Pas en ayant une fenêtre de contexte plus grande (même si ça aide), mais en étant intelligent sur la façon dont il utilise l'espace dont il dispose. Il le fait grâce à trois éléments qui fonctionnent ensemble : les compétences, les sous-agents et les serveurs MCP.

Laissez-moi vous montrer comment ces pièces s'assemblent. Une fois que vous aurez compris cela, vous arrêterez de lutter contre l'IA et commencerez à travailler avec elle.

Le problème de la fenêtre de contexte

Voici quelque chose qui m'a pris du temps à intégrer : les LLM ne « se souviennent » pas vraiment du début d'une longue conversation comme vous pourriez l'imaginer. La fenêtre de contexte ressemble plus à un projecteur qu'à un classeur. Au fur et à mesure que vous ajoutez des tokens, le contenu antérieur reçoit moins d'attention. Collez 100 000 tokens de code, et le modèle survole essentiellement au moment où il atteint votre question.

Cela explique beaucoup de comportements frustrants de l'IA. Le modèle semble intelligent au début, puis devient confus. Il oublie des choses que vous lui avez dites plus tôt. Il hallucine des détails de fichiers qu'il a « lus » mais qu'il n'a clairement pas retenus.

La solution n'est pas une fenêtre de contexte plus grande. La solution est de ne pas en avoir besoin.

Comment Claude Code pense réellement

Claude Code est un agent. Ça sonne sophistiqué, mais cela signifie simplement qu'il peut planifier, exécuter, observer les résultats et itérer. Quand vous lui demandez de « corriger les tests qui échouent dans mon projet », il n'essaie pas de comprendre l'intégralité de votre code d'un coup. Au lieu de cela, il travaille par étapes ciblées :

1. Lire la structure du projet pour comprendre ce qui se trouve où
2. Exécuter les tests pour voir ce qui échoue réellement
3. Examiner le test qui échoue spécifiquement et le code qu'il teste
4. Apporter une correction
5. Relancer les tests
6. Si toujours cassé, essayer autre chose

Chaque étape ne fonctionne qu'avec le contexte dont elle a besoin. L'agent maintient un résumé de travail de ce qu'il a appris, pas un journal brut de tout ce qu'il a vu. C'est ainsi que Claude Code peut itérer 20 fois sur un bug complexe sans manquer d'espace de contexte.

Pensez-y comme à la façon dont vous débogueriez réellement quelque chose. Vous ne gardez pas l'intégralité de votre code en tête. Vous vous concentrez sur une zone, formulez une hypothèse, la testez et ajustez. Claude Code fonctionne de la même manière.

Les sous-agents, le vrai changement de jeu

C'est là que ça devient vraiment intéressant. Claude Code peut générer des sous-agents.

Un sous-agent est une instance Claude séparée avec sa propre fenêtre de contexte vierge. Vous pouvez dire à Claude Code d'en créer un, lui donner une tâche ciblée, le laisser travailler de manière indépendante et récupérer un résumé de ce qu'il a trouvé. Le contexte complet du sous-agent ne pollue jamais votre conversation principale.

C'est énorme. Au lieu qu'un seul agent essaie de tout retenir :

Vous : « Analyse ce code pour les problèmes de sécurité, de performance et la couverture de tests »

L'agent principal génère des sous-agents : ├── Sous-agent 1 : Analyse de sécurité (contexte propre, lit les fichiers pertinents pour la sécurité) ├── Sous-agent 2 : Revue de performance (contexte propre, se concentre sur les chemins critiques) └── Sous-agent 3 : Couverture de tests (contexte propre, examine les fichiers de test)

Chaque sous-agent renvoie un résumé à l'agent principal L'agent principal synthétise tout en une seule réponse

Les sous-agents peuvent lire des milliers de lignes de code chacun. Mais l'agent principal ne reçoit que leurs conclusions condensées. Votre contexte principal reste propre tout en obtenant une analyse approfondie sur plusieurs domaines.

Pensez-y comme à déléguer à des développeurs juniors. Vous n'avez pas besoin de lire chaque ligne qu'ils ont examinée. Vous avez besoin de leurs conclusions et des signaux d'alerte qu'ils ont trouvés. Les sous-agents fonctionnent de la même manière.

Comment utiliser réellement les sous-agents

Vous pouvez explicitement demander à Claude Code de générer un sous-agent :

• « Génère un sous-agent pour analyser le module d'authentification en profondeur »
• « Utilise un sous-agent pour examiner toutes les requêtes de base de données à la recherche de problèmes N+1 »
• « Demande à un sous-agent de parcourir les fichiers de test et de signaler les lacunes de couverture »

Le sous-agent obtient son propre contexte frais, effectue le travail approfondi et renvoie un résumé. Votre conversation principale ne se retrouve pas encombrée de toute l'analyse brute.

C'est particulièrement puissant pour les grandes bases de code. Au lieu que Claude Code perde le fil à mi-chemin, vous obtenez une analyse ciblée qui évolue réellement.

Où interviennent les compétences

Donc Claude Code peut décomposer les tâches, générer des sous-agents et travailler par étapes ciblées. Mais comment sait-il comment faire des choses spécifiques correctement ? C'est là qu'interviennent les compétences.

Les compétences sont des instructions packagées que Claude lit avant de s'attaquer à des types de tâches spécifiques. Quand vous demandez à Claude Code de créer une présentation PowerPoint, il lit d'abord le fichier de compétence à /mnt/skills/public/pptx/SKILL.md. Ce fichier contient les meilleures pratiques, les pièges courants et les modèles de code exacts qui fonctionnent réellement.

Une compétence comprend généralement :

• Un fichier SKILL.md avec des instructions détaillées
• Des modèles de code et des exemples
• Des limitations connues et des solutions de contournement
• Des spécifications de format de sortie

L'idée clé est que les compétences sont chargées à la demande. Claude ne gaspille pas d'espace de fenêtre de contexte sur les instructions PowerPoint quand vous déboguez du Python. Il charge la compétence pertinente quand il en a besoin, utilise cette expertise pour la tâche et passe à autre chose.

C'est différent des outils. Les outils sont des fonctions que Claude appelle pour récupérer des données, comme web_search ou bash_tool. Les compétences sont des packages de connaissances qui changent la façon dont Claude aborde les problèmes. La distinction compte parce que les outils coûtent des tokens dans le prompt système (plus d'outils = moins de place pour votre code), tandis que les compétences ne sont chargées que lorsqu'elles sont pertinentes.

Les sous-agents peuvent également charger des compétences. Un sous-agent analysant la sécurité peut charger des compétences spécifiques à la sécurité sans que ces instructions n'encombrent votre conversation principale.

La boucle d'itération

Un modèle que vous verrez constamment est la boucle d'itération. Claude Code génère quelque chose, vérifie si ça fonctionne et corrige les problèmes jusqu'à ce que ce soit correct.

1. Générer du code
2. L'exécuter (ou le linter, ou vérifier les types)
3. Voir si ça fonctionne
4. Sinon, analyser l'erreur et réessayer
5. Répéter jusqu'à ce que ça passe

C'est pourquoi Claude Code peut corriger des bugs qu'un prompt unique manquerait. Il ne génère pas simplement du code en espérant. Il teste son propre travail et répond aux retours réels.

Quand Claude Code crée un composant React puis lance le serveur de développement pour vérifier les erreurs, il utilise cette boucle. Quand il écrit une fonction et exécute les tests pour vérifier qu'elle fonctionne, même chose. Les étapes de génération et de vérification fonctionnent ensemble.

Cela explique aussi pourquoi Claude Code prend parfois plus de temps que prévu. Il n'est pas lent. Il est minutieux. Il exécute vos tests, vérifie les erreurs de type et itère jusqu'à ce que les choses fonctionnent réellement.

Les serveurs MCP : se connecter aux systèmes externes

Jusqu'à présent, nous avons parlé de la façon dont Claude Code pense (étapes agentiques, sous-agents) et de ce qu'il sait (compétences). Mais qu'en est-il de la connexion aux systèmes externes ? C'est là qu'intervient MCP.

Le Model Context Protocol est la façon dont Claude Code communique avec les bases de données, GitHub, les systèmes de fichiers, les pipelines CI/CD et à peu près tout le reste. Pensez à MCP comme à l'USB-C pour l'IA : une interface standard qui permet à n'importe quel système IA compatible de se connecter à n'importe quel service compatible.

Les serveurs MCP exposent trois types de capacités :

Outils : Fonctions que Claude peut appeler, comme interroger une base de données ou créer une pull request

Ressources : Sources de données que Claude peut lire, comme le contenu de fichiers ou les schémas de base de données

Prompts : Modèles réutilisables pour les interactions courantes

Pour le développement web, les serveurs MCP les plus utiles incluent :

• Serveur de système de fichiers : Lire et écrire des fichiers dans votre projet (en sandbox pour la sécurité)
• Serveur GitHub : Gérer les dépôts, les PR, les issues et les workflows
• Serveurs de base de données : Interroger PostgreSQL, MySQL, SQLite en langage naturel

Voici à quoi ressemble un serveur MCP simple en 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);

La puissance des serveurs MCP vient de la façon dont ils fonctionnent avec les sous-agents. Un sous-agent peut interroger une base de données via MCP, analyser des milliers de lignes et ne renvoyer que les résultats pertinents. Les données brutes ne touchent jamais votre contexte principal.

Tout assembler

Parcourons un exemple réel. Vous demandez à Claude Code : « Examine cette PR et vérifie si les migrations de base de données sont sûres. »

Voici ce qui se passe réellement :

1. L'agent principal charge les compétences pertinentes pour la revue de code
2. Il génère un sous-agent pour analyser les changements de la PR en profondeur
3. Ce sous-agent appelle le serveur MCP GitHub pour récupérer les détails de la PR
4. Un autre sous-agent lit les fichiers de migration et interroge le schéma de base de données actuel via MCP
5. Les sous-agents renvoient des résumés ciblés : « La migration ajoute un index, semble sûre » ou « Attention : cela supprime une colonne qui est encore référencée »
6. L'agent principal synthétise les conclusions des sous-agents en une réponse claire

Remarquez comment le gros du travail se fait dans les sous-agents avec leurs propres contextes. L'agent principal orchestre et résume. Votre conversation reste propre tout en obtenant une analyse approfondie.

Pourquoi c'est important pour votre flux de travail

Comprendre cette architecture change la façon dont vous travaillez avec Claude Code :

Vous arrêtez de lutter contre la fenêtre de contexte. Une fois que vous réalisez que les sous-agents gèrent l'analyse approfondie séparément, vous arrêtez d'essayer de coller l'intégralité de votre code dans la conversation principale. Laissez les sous-agents faire la lecture intensive.

Vous utilisez explicitement les sous-agents pour les grandes tâches. Au lieu d'espérer que Claude Code comprenne, dites-lui : « Utilise un sous-agent pour analyser le module de paiement » ou « Génère des sous-agents pour la sécurité, la performance et la revue des tests ». Vous travaillez avec l'architecture au lieu de lutter contre elle.

Vous comprenez pourquoi certaines tâches fonctionnent mieux que d'autres. Les tâches qui peuvent être déléguées aux sous-agents évoluent très bien. Les tâches nécessitant des allers-retours constants dans un seul contexte atteignent les limites plus rapidement.

Vous faites confiance à la boucle d'itération. Lors de la correction de bugs, laissez Claude itérer. Il trouvera souvent des problèmes que vous n'aviez pas anticipés en exécutant réellement le code et en observant les échecs. Ne l'interrompez pas après la première tentative.

Conseils pratiques

Demandez explicitement des sous-agents pour les grandes tâches. « Génère un sous-agent pour examiner le système d'authentification » fonctionne mieux qu'espérer que Claude Code comprendra qu'il doit déléguer.

Laissez Claude lire les compétences d'abord. Si vous créez des documents ou travaillez avec des formats de fichiers spécifiques, Claude performe mieux quand il lit le fichier de compétence pertinent avant de commencer.

Connectez les serveurs MCP pour les intégrations répétitives. Au lieu de copier-coller les sorties de base de données ou les détails de PR GitHub dans vos prompts, connectez les serveurs MCP pertinents. Claude récupère exactement ce dont il a besoin.

Vérifiez l'écosystème avant de créer des outils personnalisés. L'écosystème MCP a grandi pour inclure plus de 5 000 serveurs communautaires couvrant Stripe, Cloudflare, les systèmes CI et la plupart des services que vous voudriez intégrer. Quelqu'un a probablement déjà construit ce dont vous avez besoin.

Donnez des retours quand c'est faux. Quand Claude Code produit de mauvais résultats, dites-lui ce qui n'a pas fonctionné. La boucle d'itération fonctionne aussi pour vos retours.

La vue d'ensemble

MCP a récemment été donné à la Linux Foundation, avec OpenAI, Google et Microsoft rejoignant en tant que membres de soutien. Cela signale que le protocole devient une infrastructure standard de l'industrie, pas seulement un truc d'Anthropic.

La combinaison de sous-agents (travail parallèle dans des contextes séparés), de compétences (expertise de domaine chargée à la demande) et de serveurs MCP (connexions propres aux systèmes externes) représente la façon dont les assistants de codage IA modernes fonctionnent réellement. Ce n'est pas de la magie. C'est une bonne architecture résolvant de vraies contraintes.

Le modèle de sous-agent en particulier mérite d'être compris en profondeur. C'est la différence entre une IA qui s'étouffe sur de grandes bases de code et une qui évolue. Quand vous demandez à Claude Code d'analyser quelque chose de volumineux, il ne fourre pas tout dans un seul contexte en priant. Il délègue à des sous-agents ciblés, chacun avec un contexte propre, et synthétise leurs conclusions.

Comprendre ces éléments vous aide à travailler avec le système au lieu de lutter contre lui. Vous obtiendrez de meilleurs résultats, rencontrerez moins d'obstacles et saurez quand faire confiance à l'IA par rapport à quand reprendre le contrôle manuellement.