Wie Skills, Agents und MCP-Server in Claude Code zusammenarbeiten

Du bist wahrscheinlich schon mal auf diese Mauer gestoßen: Du fügst deine gesamte Codebasis in einen KI-Chat ein, fügst einen detaillierten Prompt hinzu und bekommst zurück... nichts Brauchbares. Oder schlimmer noch, das Modell beginnt, Funktionsnamen zu halluzinieren, die nicht existieren, weil es den Überblick darüber verloren hat, was es vor 50.000 Token gelesen hat.

Das ist das Kontextfenster-Problem. Und deshalb macht es die KI nicht schlauer, wenn man ihr mehr Code gibt.

Claude Code löst das anders. Nicht durch ein größeres Kontextfenster (obwohl das hilft), sondern indem es intelligent mit dem verfügbaren Platz umgeht. Das geschieht durch drei Dinge, die zusammenarbeiten: Skills, Sub-Agents und MCP-Server.

Lass mich dir zeigen, wie diese Teile zusammenpassen. Wenn du das verstehst, wirst du aufhören, gegen die KI zu kämpfen, und anfangen, mit ihr zu arbeiten.

Das Kontextfenster-Problem

Hier ist etwas, das ich eine Weile brauchte, um es zu verinnerlichen: LLMs "erinnern" sich nicht wirklich an den Anfang einer langen Konversation, wie man es erwarten würde. Das Kontextfenster ist eher wie ein Scheinwerfer als ein Aktenschrank. Je mehr Token du hinzufügst, desto weniger Aufmerksamkeit bekommt der frühere Inhalt. Füge 100.000 Token Code ein, und das Modell überfliegt im Grunde nur noch, wenn es zu deiner Frage kommt.

Das erklärt viel frustrierendes KI-Verhalten. Das Modell scheint anfangs intelligent, wird dann aber verwirrt. Es vergisst Dinge, die du ihm früher gesagt hast. Es halluziniert Details aus Dateien, die es "gelesen", aber offensichtlich nicht behalten hat.

Die Lösung ist nicht ein größeres Kontextfenster. Die Lösung ist, keins zu brauchen.

Wie Claude Code tatsächlich denkt

Claude Code ist ein Agent. Das klingt fancy, bedeutet aber nur, dass es planen, ausführen, Ergebnisse beobachten und iterieren kann. Wenn du es bittest, "die fehlschlagenden Tests in meinem Projekt zu beheben", versucht es nicht, deine gesamte Codebasis auf einmal zu verstehen. Stattdessen arbeitet es in fokussierten Schritten:

1. Lese die Projektstruktur, um zu verstehen, was wo ist
2. Führe die Tests aus, um zu sehen, was tatsächlich fehlschlägt
3. Schaue dir den spezifischen fehlschlagenden Test und den Code an, den er testet
4. Mache eine Korrektur
5. Führe die Tests erneut aus
6. Wenn immer noch kaputt, versuche etwas anderes

Jeder Schritt arbeitet nur mit dem Kontext, den er braucht. Der Agent führt eine Arbeitszusammenfassung dessen, was er gelernt hat, nicht ein rohes Protokoll von allem, was er gesehen hat. So kann Claude Code 20 Mal an einem komplexen Bug iterieren, ohne dass der Kontextspeicher ausgeht.

Stell es dir so vor, wie du tatsächlich etwas debuggen würdest. Du hältst nicht deine gesamte Codebasis im Kopf. Du konzentrierst dich auf einen Bereich, bildest eine Hypothese, testest sie und passt an. Claude Code arbeitet genauso.

Sub-Agents: Der echte Game Changer

Hier wird es richtig interessant. Claude Code kann Sub-Agents erzeugen.

Ein Sub-Agent ist eine separate Claude-Instanz mit ihrem eigenen sauberen Kontextfenster. Du kannst Claude Code sagen, dass es einen starten soll, ihm eine fokussierte Aufgabe geben, ihn unabhängig arbeiten lassen und eine Zusammenfassung dessen zurückbekommen, was er gefunden hat. Der vollständige Kontext des Sub-Agents verschmutzt niemals deine Hauptkonversation.

Das ist enorm. Anstatt dass ein Agent versucht, alles zu halten:

Du: "Analysiere diese Codebasis auf Sicherheitsprobleme, Performance-Probleme und Testabdeckung"

Hauptagent erzeugt Sub-Agents: ├── Sub-Agent 1: Sicherheitsanalyse (eigener Kontext, liest sicherheitsrelevante Dateien) ├── Sub-Agent 2: Performance-Review (eigener Kontext, fokussiert auf Hot Paths)
└── Sub-Agent 3: Testabdeckung (eigener Kontext, untersucht Testdateien)

Jeder Sub-Agent gibt eine Zusammenfassung an den Hauptagenten zurück Hauptagent synthetisiert alles zu einer Antwort

Die Sub-Agents können jeweils Tausende von Codezeilen lesen. Aber der Hauptagent erhält nur ihre verdichteten Erkenntnisse. Dein Hauptkontext bleibt sauber, während du trotzdem tiefgehende Analysen über mehrere Bereiche hinweg erhältst.

Stell es dir vor wie das Delegieren an Junior-Entwickler. Du musst nicht jede Zeile lesen, die sie überprüft haben. Du brauchst ihre Schlussfolgerungen und alle Red Flags, die sie gefunden haben. Sub-Agents funktionieren genauso.

Wie man Sub-Agents tatsächlich verwendet

Du kannst Claude Code explizit bitten, einen Sub-Agent zu erzeugen:

• "Erzeuge einen Sub-Agent, um das Authentifizierungsmodul im Detail zu analysieren"
• "Verwende einen Sub-Agent, um alle Datenbankabfragen auf N+1-Probleme zu überprüfen"
• "Lass einen Sub-Agent die Testdateien durchgehen und über Lücken in der Abdeckung berichten"

Der Sub-Agent bekommt seinen eigenen frischen Kontext, macht die tiefgehende Arbeit und gibt eine Zusammenfassung zurück. Deine Hauptkonversation wird nicht mit der gesamten Rohanalyse aufgebläht.

Das ist besonders leistungsstark für große Codebasen. Anstatt dass Claude Code auf halbem Weg den Überblick verliert, bekommst du fokussierte Analysen, die tatsächlich skalieren.

Wo Skills ins Spiel kommen

Also kann Claude Code Aufgaben aufteilen, Sub-Agents erzeugen und in fokussierten Schritten arbeiten. Aber woher weiß es, wie es bestimmte Dinge gut macht? Da kommen Skills ins Spiel.

Skills sind verpackte Anweisungen, die Claude liest, bevor es bestimmte Arten von Aufgaben angeht. Wenn du Claude Code bittest, eine PowerPoint-Präsentation zu erstellen, liest es zuerst die Skill-Datei unter /mnt/skills/public/pptx/SKILL.md. Diese Datei enthält Best Practices, häufige Fallstricke und exakte Code-Muster, die tatsächlich funktionieren.

Ein Skill umfasst typischerweise:

• Eine SKILL.md-Datei mit detaillierten Anweisungen
• Code-Templates und Beispiele
• Bekannte Einschränkungen und Workarounds
• Spezifikationen für Ausgabeformate

Die wichtigste Erkenntnis ist, dass Skills bei Bedarf geladen werden. Claude verschwendet keinen Kontextfenster-Platz für PowerPoint-Anweisungen, wenn du Python debuggst. Es lädt den relevanten Skill, wenn es ihn braucht, nutzt diese Expertise für die Aufgabe und macht weiter.

Das unterscheidet sich von Tools. Tools sind Funktionen, die Claude aufruft, um Daten zurückzubekommen, wie web_search oder bash_tool. Skills sind Wissenspakete, die ändern, wie Claude Probleme angeht. Die Unterscheidung ist wichtig, weil Tools Token im System-Prompt kosten (mehr Tools = weniger Platz für deinen Code), während Skills nur bei Relevanz geladen werden.

Sub-Agents können auch Skills laden. Ein Sub-Agent, der Sicherheit analysiert, kann sicherheitsspezifische Skills laden, ohne dass diese Anweisungen deine Hauptkonversation überladen.

Die Iterationsschleife

Ein Muster, das du ständig sehen wirst, ist die Iterationsschleife. Claude Code generiert etwas, prüft, ob es funktioniert, und behebt Probleme, bis es stimmt.

1. Code generieren
2. Ausführen (oder linten, oder Typ-Prüfung)
3. Schauen, ob es funktioniert
4. Wenn nicht, Fehler analysieren und erneut versuchen
5. Wiederholen, bis es durchläuft

Deshalb kann Claude Code Bugs beheben, die ein Single-Shot-Prompt verpassen würde. Es generiert nicht nur Code und hofft. Es testet seine eigene Arbeit und reagiert auf echtes Feedback.

Wenn Claude Code eine React-Komponente erstellt und dann den Dev-Server ausführt, um nach Fehlern zu suchen, verwendet es diese Schleife. Wenn es eine Funktion schreibt und die Tests ausführt, um zu überprüfen, ob sie funktioniert, dasselbe. Die Generierungs- und Verifizierungsschritte arbeiten zusammen.

Das erklärt auch, warum Claude Code manchmal länger braucht, als du erwarten würdest. Es ist nicht langsam. Es ist gründlich. Es führt deine Tests aus, prüft auf Typfehler und iteriert, bis die Dinge tatsächlich funktionieren.

MCP-Server: Verbindung zu externen Systemen

Bisher haben wir darüber gesprochen, wie Claude Code denkt (agentische Schritte, Sub-Agents) und was es weiß (Skills). Aber was ist mit der Verbindung zu externen Systemen? Da kommt MCP ins Spiel.

Das Model Context Protocol ist die Art, wie Claude Code mit Datenbanken, GitHub, Dateisystemen, CI/CD-Pipelines und so ziemlich allem anderen kommuniziert. Stell dir MCP wie USB-C für KI vor: eine Standardschnittstelle, die es jedem kompatiblen KI-System ermöglicht, sich mit jedem kompatiblen Dienst zu verbinden.

MCP-Server stellen drei Arten von Fähigkeiten bereit:

Tools: Funktionen, die Claude aufrufen kann, wie das Abfragen einer Datenbank oder das Erstellen eines Pull Requests

Resources: Datenquellen, die Claude lesen kann, wie Dateiinhalte oder Datenbankschemata

Prompts: Wiederverwendbare Templates für häufige Interaktionen

Für die Webentwicklung sind die nützlichsten MCP-Server:

• Filesystem-Server: Dateien in deinem Projekt lesen und schreiben (aus Sicherheitsgründen in einer Sandbox)
• GitHub-Server: Repos, PRs, Issues und Workflows verwalten
• Datenbank-Server: PostgreSQL, MySQL, SQLite durch natürliche Sprache abfragen

So sieht ein einfacher MCP-Server in TypeScript aus: 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);

Die Stärke von MCP-Servern kommt davon, wie sie mit Sub-Agents zusammenarbeiten. Ein Sub-Agent kann eine Datenbank über MCP abfragen, Tausende von Zeilen analysieren und nur die relevanten Erkenntnisse zurückgeben. Die Rohdaten berühren niemals deinen Hauptkontext.

Alles zusammenfügen

Lass uns ein echtes Beispiel durchgehen. Du fragst Claude Code: "Überprüfe diesen PR und prüfe, ob die Datenbankmigrationen sicher sind."

Hier ist, was tatsächlich passiert:

1. Hauptagent lädt relevante Skills für Code-Review
2. Er erzeugt einen Sub-Agent, um die PR-Änderungen im Detail zu analysieren
3. Dieser Sub-Agent ruft den GitHub-MCP-Server auf, um PR-Details abzurufen
4. Ein weiterer Sub-Agent liest Migrationsdateien und fragt das aktuelle Datenbankschema über MCP ab
5. Sub-Agents geben fokussierte Zusammenfassungen zurück: "Migration fügt Index hinzu, sieht sicher aus" oder "Warnung: Dies löscht eine Spalte, auf die noch verwiesen wird"
6. Hauptagent synthetisiert die Erkenntnisse der Sub-Agents zu einer klaren Antwort

Beachte, wie die schwere Arbeit in Sub-Agents mit ihren eigenen Kontexten stattfindet. Der Hauptagent orchestriert und fasst zusammen. Deine Konversation bleibt sauber, während du tiefgehende Analysen erhältst.

Warum das für deinen Workflow wichtig ist

Das Verständnis dieser Architektur verändert, wie du mit Claude Code arbeitest:

Du hörst auf, gegen das Kontextfenster zu kämpfen. Sobald du erkennst, dass Sub-Agents tiefgehende Analysen separat durchführen, hörst du auf zu versuchen, deine gesamte Codebasis in die Hauptkonversation einzufügen. Lass die Sub-Agents das schwere Lesen erledigen.

Du verwendest Sub-Agents explizit für große Aufgaben. Anstatt zu hoffen, dass Claude Code es herausfindet, sage ihm: "Verwende einen Sub-Agent, um das Zahlungsmodul zu analysieren" oder "Erzeuge Sub-Agents für Sicherheit, Performance und Test-Review." Du arbeitest mit der Architektur statt gegen sie.

Du verstehst, warum manche Aufgaben besser funktionieren als andere. Aufgaben, die an Sub-Agents delegiert werden können, skalieren großartig. Aufgaben, die ständiges Hin und Her in einem Kontext erfordern, stoßen schneller an Grenzen.

Du vertraust der Iterationsschleife. Beim Beheben von Bugs lass Claude iterieren. Es wird oft Probleme finden, die du nicht erwartet hast, indem es den Code tatsächlich ausführt und Fehler beobachtet. Unterbrich es nicht nach dem ersten Versuch.

Praktische Tipps

Frage explizit nach Sub-Agents bei großen Aufgaben. "Erzeuge einen Sub-Agent, um das Auth-System zu überprüfen" funktioniert besser, als zu hoffen, dass Claude Code herausfindet, dass es delegieren muss.

Lass Claude zuerst Skills lesen. Wenn du Dokumente erstellst oder mit bestimmten Dateiformaten arbeitest, funktioniert Claude besser, wenn es die relevante Skill-Datei liest, bevor es beginnt.

Verbinde MCP-Server für wiederkehrende Integrationen. Anstatt Datenbankausgaben oder GitHub-PR-Details in deine Prompts zu kopieren, verbinde die relevanten MCP-Server. Claude zieht genau das, was es braucht.

Prüfe das Ökosystem, bevor du eigene Tools baust. Das MCP-Ökosystem ist auf über 5.000 Community-Server gewachsen, die Stripe, Cloudflare, CI-Systeme und die meisten Dienste abdecken, die du integrieren möchtest. Jemand hat wahrscheinlich schon gebaut, was du brauchst.

Gib Feedback, wenn es falsch ist. Wenn Claude Code falsche Ergebnisse liefert, sage ihm, was schiefgelaufen ist. Die Iterationsschleife funktioniert auch für dein Feedback.

Das große Ganze

MCP wurde kürzlich an die Linux Foundation gespendet, wobei OpenAI, Google und Microsoft als unterstützende Mitglieder beigetreten sind. Das signalisiert, dass das Protokoll zur Industriestandard-Infrastruktur wird, nicht nur zu einer Anthropic-Sache.

Die Kombination aus Sub-Agents (parallele Arbeit in separaten Kontexten), Skills (Domain-Expertise bei Bedarf geladen) und MCP-Servern (saubere Verbindungen zu externen Systemen) repräsentiert, wie moderne KI-Coding-Assistenten tatsächlich funktionieren. Es ist keine Magie. Es ist gute Architektur, die echte Einschränkungen löst.

Besonders das Sub-Agent-Muster ist es wert, tief verstanden zu werden. Es ist der Unterschied zwischen einer KI, die an großen Codebasen erstickt, und einer, die skaliert. Wenn du Claude Code bittest, etwas Großes zu analysieren, stopft es nicht alles in einen Kontext und betet. Es delegiert an fokussierte Sub-Agents, jeder mit sauberem Kontext, und synthetisiert ihre Erkenntnisse.

Das Verständnis dieser Teile hilft dir, mit dem System zu arbeiten, anstatt gegen es. Du wirst bessere Ergebnisse erzielen, auf weniger Mauern stoßen und wissen, wann du der KI vertrauen kannst und wann du manuell übernehmen solltest.