Claude Code Connector-tutorial: GitHub-repo's triëren in 20 minuten

In deze tutorial laat ik je zien hoe je Claude Code met GitHub verbindt via een Claude-connector (gebaseerd op het Model Context Protocol) en hoe je die gebruikt om een open-source repository end-to-end te triëren. 

De workflow kloont niets, heeft geen vector store nodig en raakt nul rijen in de doelrepo. In plaats daarvan leest Claude Code issues via de connector en schrijft artefacten naar je lokale bestandssysteem, die je bekijkt voordat je beslist wat (zoal) je plaatst.

Aan het eind van deze tutorial heb je:

• Een werkende Claude Code- en GitHub MCP-setup met een alleen-lezen token,
• Een paar herbruikbare prompts die je op elke publieke repo kunt richten,
• Een compleet triage-artefact voor langchain-ai/langchain om tegen te vergelijken.

Wat is de Claude Code GitHub-connector (MCP)?

Claude Code is Anthropics terminalgebaseerde coding agent. 

Out of the box heeft het al toegang tot je filesystem, shell en git. Claude Code Connectors breiden dit uit met externe context, zoals GitHub-issues, Linear-tickets, Slack-berichten, Postgres-queries, enzovoort, waar de terminal op zichzelf niet bij kan.

Het connectorprotocol heet MCP (Model Context Protocol), een open standaard om tools en data aan LLM-agents bloot te stellen. 

Anthropic onderhoudt een directory met kant-en-klare connectors; je kunt ook je eigen bouwen of verbinden met externe MCP-servers.

Voor deze tutorial gebruiken we de officiële GitHub MCP-server, die lokaal via Docker draait. Enkele kernideeën achter de setup:

• Draait als een lokale Docker-container zonder cloud-tussenpersoon, dus de credentials blijven op je machine.
• Geverifieerd met een standaard GitHub Personal Access Token (PAT), dus er is geen OAuth-appregistratie nodig.
• Ondersteunt gescopeerde permissies, zoals een ongescopeerde PAT, die alleen-lezen toegang tot publieke repo's geeft, zodat schrijven op API-niveau van GitHub onmogelijk is.
• Wordt aan Claude Code blootgesteld via het claude mcp add-commando; daarna zijn de tools in elke sessie beschikbaar.

Open-source triage is leesintensief, vraagt om oordeelsvorming en is goedkoop om het mis te hebben. 

Vijftig issues lezen en clusteren is saai voor een mens, maar ideaal voor een model dat alles tegelijk in context kan houden. 

Ook schrijven we outputs eerst als lokale bestanden; een slechte cluster of een onhandige draft kost niets, en je vangt het bij de review.

Claude Code GitHub Connector-tutorial: bouw een triage voor langchain-ai/langchain

In deze sectie zetten we de GitHub-connector op in Claude Code en draaien we vier triage-prompts op langchain-ai/langchain. Het is een grote ML-repo met een echt rommelige issue tracker. Op hoofdlijnen bouwen we dit:

• Verbind Claude Code met GitHub via de officiële MCP-server die in Docker draait,
• Gebruik een PAT zonder scopes zodat de connector per ontwerp alleen-lezen is,
• Draai triage-prompts die resultaten opslaan als lokale bestanden,
• Review de outputs, inclusief gevallen waarin Claude weigerde issues als duplicaten te clusteren.

Laten we dit stap voor stap bouwen.

Stap 1: Installeer vereisten voor Claude Code en Docker

Voordat we de connector opzetten, heb je drie dingen nodig:

• Claude Code: Je kunt dit installeren via Anthropics officiële installatiehandleiding,
• Docker Desktop: de officiële GitHub MCP-server draait in een container, dus Docker moet geïnstalleerd en draaiend zijn,
• Een GitHub-account: vereist om in de volgende stap de PAT te genereren.

Als alle vereisten klaar zijn, controleer dan of Docker draait:

docker info | head -5

Als Docker niet is geïnstalleerd of de daemon niet draait, zie je een "Cannot connect to the Docker daemon"-fout. Op macOS start je Docker Desktop met:

open -a Docker

Docker Desktop heeft 15-60 seconden nodig om volledig klaar te zijn, en docker info zal in dat venster blijven falen. In plaats van handmatig te checken, gebruik je een kleine wait-one-liner die blijft pollen tot de daemon up is:

until 

docker info >/dev/null 2>&1; do sleep 2; echo "waiting..."; done && echo "Docker ready"

Zodra er Docker ready staat, kun je door.

Stap 2: Maak een alleen-lezen GitHub-token

Als Docker is opgezet, ga dan naar github.com/settings/tokens en genereer een nieuw classic token.

Let op: laat alle scopes uitgevinkt. Een ongescopeerd token kan nog steeds publieke repositories lezen via de GitHub API, en dat is alles wat onze agent nodig heeft. Zonder geselecteerde scopes kan het token niets op GitHub schrijven, wijzigen of verwijderen, wat we Claude ook vragen. Dit is een harde garantie die aan GitHub-zijde wordt afgedwongen, geen belofte over het gedrag van de agent.

Kopieer en bewaar het token direct na het genereren en exporteer het vervolgens in je shell:

export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_your_token_here"

Als je al in een Claude Code-sessie zit, ben je misschien geneigd de !-prefix te gebruiken om het export-commando rechtstreeks in je shell te draaien (bijv. ! export GITHUB_PERSONAL_ACCESS_TOKEN="..."). 

Maar omdat ! een tijdelijke subshell start, verdwijnt de variabele zodra het commando klaar is, en ziet Claude hem niet.

Om het token veilig te zetten zonder het in de modelprompt te plakken, heb je twee opties:

1. Typ /exit om Claude te verlaten, voer het export-commando uit in je normale terminal en start claude opnieuw.
2. Of sla het token op in een lokale .env in je werkdirectory; Claude Code leest die automatisch bij het opstarten.

Controleer dat beide vereisten klaar zijn zonder het token zelf te echoën:

docker info | head -3
echo "Token set: ${GITHUB_PERSONAL_ACCESS_TOKEN:+yes}"

Het tweede commando print Token set: yes als de variabele bestaat en Token set: (niets na de dubbele punt) als hij leeg is. 

Dit is veiliger dan het token direct echoën, omdat het zo niet in platte tekst in je shellgeschiedenis kan belanden.

Stap 3: Registreer de GitHub-connector bij Claude Code

De officiële GitHub MCP-server wordt geleverd als een Docker-image. 

We registreren die bij Claude Code met claude mcp add:

claude mcp add github \
  -e GITHUB_PERSONAL_ACCESS_TOKEN=$GITHUB_PERSONAL_ACCESS_TOKEN \
  -- docker run -i --rm \
  -e GITHUB_PERSONAL_ACCESS_TOKEN \
  ghcr.io/github/github-mcp-server

De twee -e-vlaggen zijn hier geen typfout:

• De eerste -e (voor --) zet een omgevingsvariabele voor het MCP-proces dat Claude Code start,
• De tweede -e (binnen de docker run-argumenten) zegt tegen Docker dat die variabele de container in moet.

Als je er een mist en de container start met een leeg token, lukt authenticatie tegen de GitHub API niet.

Om te controleren of de connector succesvol is geregistreerd:

claude mcp list

Je zou dit moeten zien:

github — docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server —  Connected

Als je Failed to connect ziet, zijn de twee meest voorkomende oorzaken dat Docker niet draait of dat GITHUB_PERSONAL_ACCESS_TOKEN niet is geëxporteerd in dezelfde shell waarin je claude mcp add draaide.

Stap 4: Sanity-check van de verbinding

Ons GitHub-token staat nu goed. Vervolgens maken we een werkdirectory en openen we de Claude Code CLI:

mkdir demo && cd demo
claude

Het commando claude start een interactieve sessie in de huidige directory. 

Alle bestanden die Claude tijdens de triage schrijft, komen hier terecht. 

Stel daarna een eenvoudige alleen-lezen vraag om te bevestigen dat de connector wordt gebruikt:

Using the GitHub MCP connector, fetch the 5 most recently updated open issues in langchain-ai/langchain. Just list titles and numbers.

De eerste keer dat Claude Code een GitHub-tool gebruikt, vraagt het om goedkeuring. 

Keur alleen-lezen tools goed zoals list_issues, get_issue, search_issues, enz. 

Als Claude terugvalt op curl tegen de publieke GitHub API in plaats van MCP-tools te gebruiken, is de connector niet geladen. Verlaat dan je sessie en start opnieuw.

Een succesvolle run geeft zoiets terug:

Zodra je echte issue-nummers via MCP ziet terugkomen, zijn we klaar om de echte triage te draaien.

Stap 5: Genereer een backlogsamenvatting

De warming-uptaak is puur alleen-lezen. We willen nu een kaart van wat er in de issue tracker staat voordat we iets anders doen.

Prompt:
Using the GitHub MCP connector, pull the 50 most recently updated open issues from langchain-ai/langchain. 
Read their titles, bodies, and labels. Group them by likely area — bugs, feature requests, documentation, questions, and "needs more info." 
For each group, give me a count and 3-5 representative issue numbers with a one-line reason. Save as backlog-summary.md in the current directory.

Claude Code haalt de issues op via de connector, leest ze door en schrijft een markdownbestand dat ze groepeert per gebied met representatieve issue-nummers. Dit bestand op zich is al nuttig: een maintainer kan het in 60 seconden scannen en weten in wat voor week hij of zij terechtkomt.

Stap 6: Markeer duplicaatkandidaten

Duplicaatdetectie is waar een agent zijn waarde bewijst. 

Vijftig issues van begin tot eind lezen en clusteren op onderliggend probleem is saai voor een mens, maar een model kan ze allemaal in context houden en overlap zien die een keyword-zoektocht mist.

Prompt:
From the same 50 issues you already pulled, identify clusters of likely duplicates: issues describing the same underlying problem, even if titles differ. For each cluster, output issue numbers, a one-sentence shared-problem description, and confidence (high/medium/low). Save as duplicate-candidates.md.

Dit is wat Claude in mijn run daadwerkelijk produceerde:

Het interessantste deel van deze output zijn clusters 2 tot en met 4. 

Een naïeve, keyword-gebaseerde duplicaatdetector had alle vier de clusters als duplicaten gesloten. 

Claude weigerde expliciet om ze duplicaten te noemen. 

Het markeerde ze als componentclusters met hetzelfde subsysteem, verschillende root causes, en vertelde me welke ik echt moest sluiten (alleen Cluster 1) versus welke ik gezamenlijk moest triëren maar open moest houden.

Dat is het gedrag dat je van een zorgvuldige menselijke triager zou willen, en precies waarom het patroon lokaal-bestanden-dan-review die extra stap waard is. 

Als we dit direct aan de GitHub API hadden gehangen en alles automatisch hadden gesloten wat Claude markeerde, hadden we drie echte bugs gesloten.

Stap 7: Review en beslis wat je post

Dit is het hele punt van het lokale-bestandenpatroon. 

Voordat er iets GitHub raakt, bekijk je elk door Claude opgeslagen .md-bestand en check je of de groepering bij je intuïtie past. 

Lijken de high-confidence clusters echt duplicaten? Lees 2-3 conceptreacties en kijk of ze klinken zoals jij zou schrijven.

Als je de comments of labels daadwerkelijk wilt plaatsen, heb je twee opties:

• Handmatig: je kunt de drafts zelf in GitHub plakken. Voor een eenmalige triagesessie op iemand anders' repo is dit prima en vaak de juiste keus.
• Schrijfrechten autoriseren op een repo die je bezit: Genereer een apart PAT met repo-scope, voeg die toe als een aparte connector-entry (bijv. github-write) en draai de prompts opnieuw met de vraag aan Claude om labels toe te passen en comments te posten. Claude Code zal de eerste keer om goedkeuring vragen voor elke schrijvende tool.

De belangrijkste veiligheidsmaatregel voor de schrijfroute is het gescheiden houden van lees- en schrijftokens. 

Conclusie

In deze tutorial heb ik laten zien hoe je Claude Code via MCP met GitHub verbindt en het gebruikt om een echte open-source repository end-to-end te triëren. 

In plaats van een aangepaste GitHub-bot te bouwen of webhooks te koppelen, leest de workflow issues via de officiële GitHub MCP-server, schrijft vier triage-artefacten als lokale bestanden en laat je alles reviewen voordat je beslist wat je post.

De bredere les is dat connectors van Claude Code een coding agent maken die je tools kan lezen en werk voor je kan voorbereiden om te reviewen. 

De juiste default is om dat werk lokaal te houden tot je het gezien hebt, en zodra je het patroon vertrouwt, kun je de agent selectief actie laten ondernemen waar de kosten van een fout laag zijn.

Vanaf hier kun je het project op verschillende manieren uitbreiden:

• Voeg write-capable connectors toe op repo's die je bezit, zodat labels en comments automatisch worden toegepast na review,
• Koppel Linear- of Slack-connectors om triagebeslissingen te syncen met de workflow van je team,
• Maak van de prompts een geplande CI-job die wekelijks een triage-PR oplevert,
• Of generaliseer de bovenstaande prompts tot een herbruikbaar Claude Code slash-commando dat werkt op elke repo-URL.