Comment configurer des agents de codage MCP dans GitHub Copilot et Xcode

Les agents de codage MCP franchissent enfin la ligne entre les démos intéressantes et l’outillage pratique quotidien. Au lieu de s’arrêter aux suggestions inline ou aux réponses chat, les agents de codage peuvent inspecter votre dépôt, planifier le travail, utiliser des outils, faire des modifications, exécuter des builds ou tests et vous remettre quelque chose de concret à vérifier.

C’est important maintenant parce que GitHub et Apple ont rapproché ce modèle du workflow développeur normal. Du côté GitHub, l’agent de codage peut travailler à partir du contexte du dépôt et utiliser des outils MCP. Du côté Xcode, Xcode (avec support du codage agentique) ajoute le codage agentique et peut exposer les capacités Xcode via le Model Context Protocol, ce qui rend les workflows locaux de plateforme Apple beaucoup plus utiles que le simple prompting copier-coller.

Dans ce tutoriel, vous allez configurer un petit package Swift, activer les agents de codage dans GitHub Copilot et Xcode, connecter des outils MCP et exécuter un vrai workflow : demander à l’agent d’expliquer la base de code, corriger un bug, ajouter des tests, puis valider le résultat avant de l’accepter.

Avant de commencer, assurez-vous que vous pouvez accéder à GitHub Copilot, ouvrir un projet dans Xcode (avec support du codage agentique) ou ultérieur, et vous authentifier avec un produit de codage supporté dans Xcode. Vous n’avez pas besoin d’une énorme base de code pour ce guide. Un petit package Swift suffit pour prouver que le workflow fonctionne de bout en bout.

Étape 1 : Comprendre les pièces mobiles

Avant d’activer des fonctionnalités, il est utile de comprendre ce que fait chaque couche. La plupart des problèmes de configuration d’agent sont en réalité des problèmes de modèle mental : le mauvais outil est activé, l’agent a le mauvais périmètre, ou le développeur attend un comportement d’autocomplétion d’un système conçu pour compléter des tâches.

Ce qu’est Agent HQ

Dans GitHub, l’agent de codage n’est pas juste “le chat Copilot, mais plus fort.” Il s’exécute comme un workflow autonome orienté tâche lié à votre dépôt et processus de pull request. Selon votre plan et configuration, vous pouvez travailler depuis l’onglet Agents du dépôt ou la page globale des agents, choisir un dépôt, démarrer une tâche et surveiller la session en direct pendant que l’agent lit le code, édite les fichiers et prépare une pull request.

C’est fondamentalement différent de l’autocomplétion. L’autocomplétion prédit ce qui vient ensuite au curseur. Un agent de codage évalue un objectif, le décompose en étapes, navigue dans votre base de code et travaille vers une implémentation que vous pouvez vérifier.

Ce que fait le codage agentique Xcode

Xcode (avec support du codage agentique) ajoute un changement similaire localement. Au lieu de générer uniquement des snippets, Xcode peut travailler avec un agent de codage externe qui utilise les capacités fournies par Xcode pour inspecter votre projet, chercher dans la documentation Apple, construire, tester et itérer. Cela signifie que votre configuration Xcode peut devenir un vrai environnement d’exécution pour le travail d’agent plutôt que juste un éditeur de texte qui envoie des prompts à un modèle.

Où MCP s’inscrit

MCP est le ciment entre les modèles et les outils. Un modèle seul peut raisonner sur le texte que vous lui envoyez, mais MCP permet à l’agent d’utiliser des outils structurés et du contexte externe de manière standardisée. En pratique, cela signifie des choses comme :

• accès au dépôt et aux tickets
• commandes de build et test
• recherche de documentation
• contexte de bugs et exceptions
• données de tracker de tickets ou de déploiement

Sur GitHub, MCP peut exposer des outils de serveurs configurés à l’agent de codage. Dans Xcode, MCP est la façon dont les outils de codage externes peuvent accéder aux capacités Xcode comme le build, les tests et la recherche de documentation.

Un bon modèle de fonctionnement est celui-ci :

• L’agent de codage GitHub est idéal pour les tâches de dépôt en arrière-plan qui devraient se terminer par une pull request.
• Le codage agentique Xcode est idéal pour le développement local interactif, le débogage et le contexte de plateforme Apple.
• MCP est ce qui donne à tous les deux accès à plus que du texte brut.

Vous devriez maintenant comprendre pourquoi cette configuration est plus puissante que l’autocomplétion seule, et pourquoi GitHub plus Xcode plus MCP est une combinaison utile plutôt que trois fonctionnalités sans rapport.

Étape 2 : Activer les agents de codage dans GitHub

Cette étape fait fonctionner l’agent de codage GitHub Copilot sur un dépôt que vous contrôlez. L’objectif est de s’assurer que l’agent peut voir le dépôt, démarrer une tâche et opérer au bon endroit avant d’ajouter des outils MCP supplémentaires.

Créer un petit dépôt de pratique

Si vous n’avez pas déjà un dépôt sûr pour tester, créez un petit package Swift. Cela vous donne quelque chose que Xcode peut ouvrir et sur lequel GitHub peut opérer.

Créez un nouveau dossier et initialisez le package :

mkdir AgentPlayground
cd AgentPlayground
swift package init --type library
mkdir -p Sources/AgentPlayground
mkdir -p Tests/AgentPlaygroundTests

Remplacez Package.swift par :

// swift-tools-version: 6.0
import PackageDescription

let package = Package(
    name: "AgentPlayground",
    products: [
        .library(
            name: "AgentPlayground",
            targets: ["AgentPlayground"]
        )
    ],
    targets: [
        .target(
            name: "AgentPlayground"
        ),
        .testTarget(
            name: "AgentPlaygroundTests",
            dependencies: ["AgentPlayground"]
        )
    ]
)

Créez Sources/AgentPlayground/TipCalculator.swift :

import Foundation

public enum TipCalculator {
    public static func total(amount: Double, tipPercent: Int) -> Double {
        let tip = amount * Double(tipPercent / 100)
        return amount + tip
    }
}

Ce fichier a un bug intentionnel : tipPercent / 100 effectue une division entière avant la conversion, donc 15 / 100 devient 0.

Committez le dépôt :

git init
git add .
git commit -m "Create AgentPlayground sample"

Poussez-le vers un nouveau dépôt GitHub :

git branch -M main
git remote add origin git@github.com:YOUR-USER/agent-playground.git
git push -u origin main

Activer l’accès à l’agent de codage GitHub Copilot

La disponibilité de l’agent de codage GitHub Copilot dépend de votre plan et des paramètres admin. En tant qu’abonné individuel, il peut déjà être activé. Dans les environnements Business ou Enterprise, un administrateur peut avoir besoin de l’activer d’abord et d’autoriser l’accès au dépôt.

À un haut niveau, vérifiez ces éléments :

1. Ouvrez les paramètres GitHub Copilot.
2. Confirmez que l’agent de codage est activé pour votre compte ou organisation.
3. Confirmez que votre dépôt cible est inclus dans l’accès au dépôt.
4. Ouvrez le dépôt et cherchez l’onglet Agents ou utilisez la page globale des agents.

Démarrer votre première session d’agent

Ouvrez le dépôt dans GitHub, puis démarrez une nouvelle tâche depuis l’onglet Agents ou la page globale des agents. Choisissez votre dépôt et branche de base.

Pour votre première tâche, utilisez un prompt en lecture seule qui prouve que l’agent peut voir le dépôt :

Explain the structure of this repository. Identify the package name,
the main target, and the file most likely responsible for tip
calculations. Do not make any changes yet.

Une bonne réponse devrait mentionner :

• le package AgentPlayground
• la cible AgentPlayground
• Sources/AgentPlayground/TipCalculator.swift

Si votre plan inclut plusieurs agents ou choix de modèle, choisissez d’abord l’agent de codage Copilot par défaut. N’optimisez pas la sélection de modèle avant de confirmer que l’accès basique au dépôt fonctionne.

Vérifier que l’agent peut voir la base de code

La vérification la plus simple n’est pas si la session démarre. C’est si l’agent peut décrire avec précision les fichiers, cibles et emplacements d’édition probables sans halluciner.

Vous devriez maintenant voir une session qui peut nommer votre package, identifier TipCalculator.swift et référencer la structure du dépôt correctement. S’il ne peut pas, arrêtez-vous ici et corrigez l’accès au dépôt avant de continuer.

Étape 3 : Configurer le codage agentique dans Xcode

Maintenant vous allez configurer le côté local du workflow. L’objectif est de connecter un produit de codage supporté dans Xcode, activer les outils MCP de Xcode et confirmer que l’agent peut inspecter le contexte de votre projet.

Ouvrir le même projet dans Xcode

Depuis la racine du dépôt, ouvrez le package Swift dans Xcode :

xed .

Si xed n’est pas disponible, ouvrez Xcode manuellement et sélectionnez le fichier ou dossier Package.swift.

Activer l’intelligence de codage et connecter un agent supporté

Dans Xcode, ouvrez :

Xcode > Settings > Intelligence

De là, activez le produit de codage que vous voulez utiliser. Xcode (avec support du codage agentique) supporte des flux de configuration directs pour les agents de codage supportés, et l’assistant de codage vous permet de choisir quel produit utiliser dans une conversation.

Si le produit nécessite une authentification, connectez-vous et terminez la configuration avant de continuer.

Choisir un agent dans l’assistant de codage

Ouvrez l’assistant de codage dans Xcode. Dans la barre d’outils de l’assistant de codage, démarrez une nouvelle conversation et utilisez le sélecteur de produit pour choisir le produit de codage que vous avez activé.

Utilisez ce premier prompt :

Inspect the open Swift package and explain where the business logic
lives, where tests should go, and which file you would change to fix
the tip calculation bug. Do not edit anything yet.

Une bonne réponse devrait identifier :

• la logique métier dans Sources/AgentPlayground/TipCalculator.swift
• les tests dans Tests/AgentPlaygroundTests
• le bug probablement lié au calcul de pourcentage

Confirmer que l’agent a un vrai contexte de projet

Maintenant testez si Xcode donne à l’agent un contexte utile au lieu de juste du texte de prompt brut. Demandez :

Before making changes, list the package target names and summarize the
current implementation of TipCalculator.total(amount:tipPercent:).

Si la réponse correspond au code réel, Xcode passe avec succès le contexte du projet.

Vous devriez maintenant avoir une conversation Xcode fonctionnelle qui peut voir le projet ouvert, identifier votre structure de package Swift et raisonner sur l’emplacement du bug avant d’éditer le code.

Étape 4 : Ajouter du contexte et des outils MCP

C’est là que le workflow devient vraiment “agentique” plutôt que juste du chat avec contexte de fichiers. Dans cette étape, vous allez câbler l’accès aux outils dans GitHub et activer les Xcode Tools basés sur MCP pour que l’agent puisse faire plus qu’éditer du texte source.

Ajouter une configuration MCP au niveau du dépôt dans GitHub

Sur GitHub, ouvrez votre dépôt et naviguez vers :

Settings > Copilot > Coding agent

Trouvez la zone de configuration MCP et ajoutez une configuration minimale. Pour une première configuration, une configuration MCP GitHub en lecture seule est un bon point de départ parce qu’elle garde le périmètre étroit.

Utilisez ce JSON :

{
  "mcpServers": {
    "github-mcp-server": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/readonly",
      "tools": ["*"],
      "headers": {
        "X-MCP-Toolsets": "repos,issues,pull_requests,actions,web_search"
      }
    }
  }
}

Cette configuration garde le serveur en mode lecture seule et limite l’accès à un sous-ensemble de toolsets GitHub. Ce n’est pas la configuration la plus serrée possible, mais c’est un premier pas pratique pour l’apprentissage et la vérification. Consultez la documentation MCP actuelle de GitHub pour les dernières URLs d’endpoint et options de configuration, car celles-ci peuvent changer.

Ajouter des secrets uniquement si votre serveur MCP en a besoin

Certains serveurs MCP ont besoin de clés API ou tokens. Dans GitHub, créez un environnement de dépôt nommé copilot et ajoutez des secrets ou variables préfixés par COPILOT_MCP_.

Par exemple :

• COPILOT_MCP_SENTRY_AUTH_TOKEN
• COPILOT_MCP_GITHUB_PERSONAL_ACCESS_TOKEN

Si votre serveur a besoin de dépendances supplémentaires au runtime, vous pourriez aussi avoir besoin d’un workflow copilot-setup-steps.yml pour que l’environnement de l’agent puisse les installer avant de démarrer le serveur.

Pour ce tutoriel, vous pouvez sauter cela à moins que votre serveur MCP ne nécessite un setup personnalisé.

Activer les Xcode Tools pour les agents externes

Dans Xcode, retournez à :

Xcode > Settings > Intelligence

Sous Model Context Protocol, activez Xcode Tools.

Ce paramètre est ce qui permet aux agents externes supportés d’utiliser les capacités Xcode via MCP. En pratique, cela peut inclure des actions comme :

• construire le projet
• exécuter les tests
• lire les diagnostics
• chercher dans la documentation Apple pertinente au code

Tester l’accès aux outils MCP

Utilisez un prompt orienté outils dans GitHub d’abord :

Using the available tools, summarize the open issues and pull requests
for this repository, then explain whether there is already a tracked
bug related to tip calculation. Do not make changes.

Puis utilisez un prompt orienté outils dans Xcode :

Use Xcode tools to inspect the project, then tell me whether the
package builds cleanly right now and what would need to change to add
regression tests for TipCalculator.

Un résultat réussi mentionnera généralement l’activité des outils, l’inspection du projet, le contexte de build/test ou la recherche de documentation plutôt que de retourner une réponse purement générique.

Vous devriez maintenant avoir des outils MCP fonctionnels dans GitHub et Xcode : GitHub via la configuration MCP du dépôt, et Xcode via les Xcode Tools exposés au produit de codage.

Étape 5 : Exécuter une vraie tâche

Maintenant que la plomberie est en place, vous pouvez exécuter un vrai workflow d’agent. La première tâche la plus sûre est étroite, testable et facile à vérifier : corriger un simple bug et ajouter des tests de régression.

Demander à l’agent d’expliquer l’architecture avant de changer le code

Commencez avec ce prompt dans GitHub ou Xcode :

Before editing anything, explain the architecture of this package in
5 bullet points. Then propose the smallest safe change needed to fix
the tip calculation bug and the tests you would add.

C’est un pattern sous-estimé. Il force l’agent à démontrer sa compréhension avant de commencer à changer des fichiers. Si l’explication est fausse, vous pouvez la corriger tôt au lieu de vérifier un diff large et de mauvaise qualité plus tard.

Demander à l’agent de codage GitHub de corriger le bug

Créez un ticket dans GitHub avec une description étroitement périmètrée :

Titre : Fix tip percentage calculation and add regression tests

Corps :

The function `TipCalculator.total(amount:tipPercent:)` currently
calculates the tip incorrectly because the percentage math uses
integer division.

Please:
1. Fix the bug so `tipPercent = 15` on `amount = 100` returns `115.0`
2. Add focused regression tests for 0%, 15%, and 20%
3. Keep the change minimal
4. Do not add new dependencies

Assignez le ticket à l’agent de codage Copilot, ou démarrez une tâche d’agent depuis l’onglet Agents avec cette même instruction.

Une bonne exécution d’agent GitHub devrait :

• inspecter TipCalculator.swift
• mettre à jour le calcul
• créer un fichier de test
• ouvrir une pull request avec un résumé concis

Ce à quoi le code corrigé devrait ressembler

Une implémentation correcte dans Sources/AgentPlayground/TipCalculator.swift devrait finir fonctionnellement équivalente à ceci :

import Foundation

public enum TipCalculator {
    public static func total(amount: Double, tipPercent: Int) -> Double {
        let tip = amount * (Double(tipPercent) / 100.0)
        return amount + tip
    }
}

Et un fichier de test ciblé à Tests/AgentPlaygroundTests/TipCalculatorTests.swift devrait ressembler à ceci :

import XCTest
@testable import AgentPlayground

final class TipCalculatorTests: XCTestCase {
    func testZeroPercentTip() {
        XCTAssertEqual(TipCalculator.total(amount: 100.0, tipPercent: 0), 100.0, accuracy: 0.0001)
    }

    func testFifteenPercentTip() {
        XCTAssertEqual(TipCalculator.total(amount: 100.0, tipPercent: 15), 115.0, accuracy: 0.0001)
    }

    func testTwentyPercentTip() {
        XCTAssertEqual(TipCalculator.total(amount: 100.0, tipPercent: 20), 120.0, accuracy: 0.0001)
    }
}

Vous devriez maintenant avoir soit une pull request GitHub soit un ensemble de modifications Xcode locales qui corrige le bug et ajoute des tests de régression.

Étape 6 : Vérifier et valider les résultats

Cette étape est là où la plupart de la valeur est gagnée ou perdue. Un agent de codage qui peut produire du code est utile. Un développeur qui peut rapidement valider et façonner ce code est là où le vrai gain de productivité apparaît.

Vérifier le diff avant de lire le résumé

Les résumés de l’agent sont utiles, mais le diff reste la source de vérité. Vérifiez :

• A-t-il touché uniquement TipCalculator.swift et le fichier de test ?
• A-t-il évité le reformatage non lié ?
• A-t-il changé les paramètres de projet ou les dépendances sans qu’on le lui demande ?
• A-t-il ajouté des tests qui correspondent réellement au bug ?

Si l’ensemble de modifications est plus large que prévu, demandez une révision plus étroite au lieu de tout corriger à la main vous-même.

Exécuter les tests localement

Depuis la racine du dépôt, exécutez :

swift test

Pour ce package exemple, swift test est la confirmation la plus simple.

Vérifier les changements risqués

Si l’agent a changé quoi que ce soit en dehors du périmètre demandé, vérifiez ces fichiers attentivement.

Utilisez cette checklist :

• Aucune nouvelle dépendance n’a été ajoutée sans raison
• Aucune référence de secret, token ou credential n’a été introduite
• Les paramètres de projet n’ont pas changé de manière inattendue
• Les tests couvrent la régression prévue
• L’implémentation est la correction raisonnable minimale

Vous devriez maintenant avoir un résultat validé : diff vérifié, tests qui passent et une compréhension claire de ce que l’agent a changé et pourquoi.

Étape 7 : Mettre des garde-fous autour de l’utilisation

Une fois que le workflow fonctionne, l’objectif suivant n’est pas “utiliser les agents partout.” C’est de les rendre utiles de manière prévisible. De bons garde-fous transforment les agents en levier. De mauvais garde-fous ou leur absence les transforment en travail de nettoyage.

Limiter les permissions et le périmètre

Dans GitHub :

• gardez l’accès au dépôt limité aux dépôts qui ont réellement besoin de l’agent de codage
• gardez les serveurs MCP étroits et en lecture seule sauf si un accès plus large est justifié
• préférez les outils en liste blanche aux configurations * ouvertes en production
• évitez de donner aux serveurs MCP des secrets inutiles

Dans Xcode :

• activez uniquement les produits de codage que vous utilisez réellement
• gardez les tâches étroitement périmètrées
• évitez que le premier prompt combine des changements d’architecture, des changements de dépendances et des corrections de bugs en un seul coup

Décider quelles tâches les agents devraient et ne devraient pas faire

Bonnes tâches pour les agents de codage :

• corrections de bugs ciblées
• ajout ou renforcement de tests
• petits refactorings
• mises à jour de documentation
• changements mécaniques répétitifs
• génération d’un premier brouillon de fonctionnalité avec des contraintes claires

Mauvais premiers candidats :

• reconceptions d’auth
• logique de facturation ou mouvement d’argent
• grandes migrations de schéma
• réécritures sensibles à la sécurité
• changements de réponse aux incidents
• travail produit ambigu sans critères d’acceptation

Garder les humains dans la boucle de revue

Le pattern gagnant n’est pas “l’agent remplace le développeur.” C’est “l’agent fait la première passe, l’humain possède l’acceptation.” Cela signifie :

• l’humain définit le périmètre
• l’agent exécute
• l’humain vérifie, teste et merge

Les meilleures équipes gardent la décision de merge humaine, même quand la tâche elle-même est fortement automatisée.

Vous devriez maintenant avoir à la fois la configuration technique et les garde-fous opérationnels nécessaires pour rendre les agents de codage MCP utiles sans les lâcher sur tout.

Problèmes courants de configuration

L’agent ne peut pas accéder au projet

Symptômes :

• L’agent GitHub ne peut pas démarrer sur le dépôt
• L’agent Xcode donne des réponses génériques et ne peut pas identifier les fichiers
• Le dépôt est absent de l’UI de sélection

Correction :

1. Dans GitHub, confirmez que l’agent de codage est activé et que le dépôt est autorisé
2. Dans Xcode, rouvrez Xcode > Settings > Intelligence et vérifiez la configuration du produit
3. Rouvrez la vraie racine du projet ou package, pas un répertoire parent
4. Relancez un prompt en lecture seule qui demande à l’agent de nommer les fichiers avant de lui demander d’éditer du code

L’outil MCP n’est pas reconnu

Symptômes :

• GitHub accepte la configuration mais l’outil n’apparaît jamais dans les logs
• L’agent se comporte comme si aucun outil n’était disponible

Correction :

1. Revérifiez le JSON attentivement pour les virgules, guillemets et imbrication d’objets
2. Confirmez que les secrets et variables utilisent le préfixe COPILOT_MCP_
3. Vérifiez le log de session pour l’étape Start MCP Servers dans GitHub
4. Dans Xcode, réactivez Xcode Tools et redémarrez la conversation

Les changements générés sont trop larges

Symptômes :

• L’agent reformate des fichiers non liés
• Il change la configuration, le package ou les paramètres de build sans qu’on le lui demande
• La pull request est beaucoup plus grande que le problème

Correction :

Utilisez des prompts plus étroits :

Fix only the bug in TipCalculator.total(amount:tipPercent:). Add
regression tests. Do not change dependencies, formatting outside
edited files, or package configuration.

Conclusion

Vous avez maintenant une configuration cross-outils fonctionnelle pour les agents de codage MCP dans GitHub Copilot et Xcode. Vous avez activé l’agent de codage GitHub, configuré le codage agentique Xcode, activé l’accès aux outils MCP, exécuté une vraie tâche de correction de bug et validé le résultat avec des tests et une revue de diff.

Les prochaines choses utiles à automatiser sont petites et répétitives : tests de régression, mises à jour de documentation, refactorings étroits et corrections de bugs pilotées par les tickets. Une fois ceux-ci fiables, ajoutez des agents personnalisés et des serveurs MCP plus spécifiques pour que le workflow devienne plus précis plutôt que plus large.

En règle générale, utilisez un agent pour une tâche étroitement périmètrée qui devrait se terminer par un seul changement vérifié. Utilisez plusieurs agents ou produits quand vous voulez comparer des approches, séparer le travail exploratoire local du travail de PR sur le dépôt, ou spécialiser un agent pour les tests et un autre pour l’implémentation.