Claude Code ist weit mehr, als Sie denken

Als ich anfing, Claude Code zu nutzen, behandelte ich es wie einen Chat.

Ich fragte nach etwas, es antwortete, und das war's.

Es funktionierte, aber mit der Zeit bemerkte ich, dass ich nicht das volle Potenzial ausschöpfte.

Ich wiederholte dieselben Prompts. Ich führte dieselben Befehle aus. Mir war nicht klar, wie ich es voll ausnutzen konnte.

Also hielt ich inne und stellte mir eine Frage:

Wie funktioniert Claude Code eigentlich intern?

Ich begann, die Dokumentation zu lesen, zu experimentieren und zu testen.

Und was ich herausfand, ist Folgendes:

Es macht keine Magie. Es besteht aus konkreten Bausteinen, jeder mit einer klaren Rolle. Und wenn man sie versteht, ergibt alles andere einen Sinn.

→ Wenn du immer dieselben Anweisungen wiederholst, machst du daraus ein Skill.

→ Wenn der Faden bei einer langen Aufgabe verloren geht, delegierst du an einen SubAgent.

→ Wenn es manuelle Schritte gibt, die du wiederholst, automatisierst du sie mit Hooks.

Die Grundlagen zu verstehen, befähigt dich zu wissen, was du wann und warum einsetzt.

Heute habe ich über 100 Skills, automatisierte Prozesse, die früher Stunden dauerten, und Agenten, die Code-Reviews durchführen und Themen, die mich interessieren, studieren.

Ich habe diesen Artikel geschrieben, um alles, was ich gelernt habe, mit dir zu teilen.

Los geht's.

Agent Loop: Das Herz von Claude Code

Claude Code ist ein Agent.

Ein System, dem du ein Ziel gibst und das arbeitet, bis es es erfüllt.

Es unterscheidet sich von einem Chat. In einem Chat fragst du "Wie füge ich meiner App Authentifizierung hinzu?" und es erklärt die Schritte.

Aber du musst ins Projekt gehen, den Code ändern und testen, ob es funktioniert.

Du machst die Arbeit.

Mit Claude Code sagst du "Füge meiner App Authentifizierung hinzu" und es kümmert sich darum.

Es liest den Code, wählt die Bibliothek aus, schreibt die Änderungen und benachrichtigt dich, wenn es fertig ist.

Es hat ein Ziel: Authentifizierung hinzufügen.

Und es arbeitet, bis es es erfüllt.

Aber wie weiß es, was nach jedem Schritt zu tun ist? Wie weiß es, ob etwas funktioniert hat? Es braucht etwas, um diese Entscheidungen zu koordinieren.

Das ist der Loop.

Ein Kreislauf, der sich wiederholt.

Claude Code führt eine Aktion aus, beobachtet das Ergebnis, entscheidet, was als Nächstes zu tun ist, und beginnt von vorn. Es hört nicht auf, bis das Ziel erreicht ist.

Wenn etwas fehlschlägt, geht es zurück, korrigiert und fährt fort.

Der Loop hat 3 Phasen:

Kontext sammeln → Versteht, was zu tun ist. Liest Dateien, analysiert Code, erkundet die Projektstruktur.

Aktion ausführen → Führt Änderungen durch. Bearbeitet Dateien, führt Befehle aus, installiert Abhängigkeiten.

Ergebnisse verifizieren → Überprüft, ob das Getane funktioniert. Führt Tests aus, prüft Fehler, korrigiert, wenn etwas fehlschlägt.

Der Loop passt sich an das an, was du fragst.

Eine einfache Frage erfordert vielleicht nur das Sammeln von Kontext. Das Beheben eines Fehlers kann mehrmals alle drei Phasen durchlaufen.

Claude Code entscheidet, was jeder Schritt basierend auf dem, was es aus dem vorherigen gelernt hat, benötigt. Und du bist auch Teil dieses Loops.

Du kannst jederzeit eingreifen, um ihn umzuleiten, Kontext hinzuzufügen oder ihn zu bitten, einen anderen Ansatz zu versuchen.

Das ist das Herz von Claude Code.

Alles, was folgt, existiert, um diesen Loop leistungsfähiger zu machen.

Tools: Wie Claude Code in der Welt handelt

Ein LLM verarbeitet von Natur aus nur Text.

Es empfängt Text und generiert Text. Es hat keinen Zugriff auf dein Dateisystem, es kann keine Befehle ausführen, es weiß nicht, was in deinem Projekt ist.

Es ist isoliert.

Wie öffnet Claude Code dann eine Datei oder ändert sie?

Es verwendet Tools.

Tools sind Funktionen, die Claude Code aufrufen kann, um mit der realen Welt zu interagieren.

Stell es dir wie mobile Apps vor. Das Telefon allein tut nichts: Es sind die Apps, die ihm spezifische Fähigkeiten verleihen: Fotos machen, Nachrichten senden, navigieren.

Tools sind das Gleiche für Claude Code.

Jedes Mal, wenn es ein Tool verwendet, sendet es eine Anfrage mit dem, was es braucht, an das System. Das System führt sie aus und gibt das Ergebnis zurück.

Claude Code verwendet dieses Ergebnis, um zu entscheiden, was als Nächstes zu tun ist.

1Deine Anfrage
2    ↓
3Claude Code entscheidet, welches Tool verwendet wird
4    ↓
5┌─────────────────────────────────┐
6│  Lesen · Bearbeiten · Schreiben · Bash │
7│  Grep · Glob · WebFetch · WebSearch │
8└─────────────────────────────────┘
9    ↓
10System führt das Tool aus
11    ↓
12Ergebnis wird an Claude Code zurückgegeben
13    ↓
14Fertig? → Nein → verwende ein anderes Tool
15             Ja → antworte

Claude Code bringt native Tools für die häufigsten Operationen mit:

Lesen / Bearbeiten / Schreiben → Dateien lesen, ändern und erstellen. Die am häufigsten verwendeten. Jedes Mal, wenn Claude Code "deinen Code versteht" oder "eine Änderung vornimmt", verwendet es diese drei.

Bash → Voller Zugriff auf das Terminal. Wenn du es von der Kommandozeile aus machen kannst, kann es Claude Code auch: Abhängigkeiten installieren, Tests ausführen, Commits machen.

Grep und Glob → Suche innerhalb des Projekts. Glob findet Dateien nach Name oder Muster. Grep sucht nach bestimmtem Inhalt in Dateien.

WebFetch und WebSearch → Internetzugriff. Dokumentation konsultieren, eine API lesen, einen Fehler untersuchen, den es noch nie gesehen hat.

Um auf das Beispiel mit dem Fehler im Login-Button zurückzukommen.

Wenn Claude Code daran arbeitet, verwendet es mehrere Tools zusammen:

→ Es verwendet Glob, um die Komponentendatei zu finden

→ Es verwendet Lesen, um den Code zu lesen und zu verstehen, was passiert

→ Es verwendet Bearbeiten, um den Fehler zu beheben

→ Es verwendet Bash, um die Tests auszuführen und zu überprüfen, ob es funktioniert hat

All das, ohne dass du eingreifst. Das ist der Unterschied zwischen einem Chat und einem Agenten.

Kontext und Gedächtnis: Woran sich Claude Code erinnert

Claude Code arbeitet, führt Aktionen aus, erhält Ergebnisse und entscheidet, was als Nächstes zu tun ist.

Aber wie weiß es, was es im Laufe der Zeit getan hat?

Alles dank des Kontexts.

Der Kontext sind die Informationen, die Claude Code zu diesem Zeitpunkt zur Verfügung hat. Jedes Mal, wenn es eine Aktion ausführt, wird das Ergebnis dort angesammelt.

Nicht nur dein ursprünglicher Prompt, sondern alles, was es findet: Dateien, die es geöffnet hat, was es im Code entdeckt hat, die Aktionen, die es ausgeführt hat, und deren Ergebnisse.

Deshalb kann es Schritte aneinanderreihen, sich selbst korrigieren und die Aufgabe allein zu Ende bringen.

Dieser Kontext hat 2 Probleme.

1. Er hat eine begrenzte Kapazität. Wenn die Sitzung sehr lang ist, füllt sich der Kontext und Claude Code beginnt zu vergessen, was vorher passiert ist. Später wirst du sehen, wie SubAgents dies lösen.

2. Er wird jedes Mal geleert, wenn du eine neue Konversation öffnest. Claude Code weiß nicht, in welchem Projekt du dich befindest, wie dein Team arbeitet oder welche Entscheidungen bereits getroffen wurden. Wenn du es ihm nicht sagst, leitet es es ab oder fragt dich.

Das Gedächtnis löst das zweite Problem.

Es ist ein Markdown-Dateisystem, in dem du alles speicherst, was Claude Code wissen muss: deinen Stack, Teamkonventionen, wie Projekte strukturiert sind.

Claude Code liest sie zu Beginn jeder Sitzung und fügt diese Informationen in den Kontext ein, bevor du die erste Zeile schreibst.

Ohne Gedächtnis: Du sagst "füge einen Endpunkt zum Erstellen von Benutzern hinzu" und Claude Code fragt dich: "Welches Framework verwendest du? Hast du eine Datenbank konfiguriert? Wie sind die Routen strukturiert?"

Mit Gedächtnis: Du sagst dasselbe und es weiß bereits, dass du Express mit Prisma verwendest, dass Routen in /src/routes liegen und dass Fehler mit einer zentralisierten Middleware behandelt werden. Es beginnt zu arbeiten, ohne zu fragen.

Claude Code hat 2 Gedächtnissysteme:

→ CLAUDE.md - Markdown-Dateien, die du schreibst, mit allem, was Claude Code wissen muss. Sie können auf verschiedenen Ebenen existieren:

→ ~/.claude/CLAUDE.md - Gilt für alle deine Projekte. Hier kommen deine persönlichen Vorlieben hin: wie du möchtest, dass es Code schreibt, Konventionen, die du immer verwendest. Anweisungen müssen spezifisch sein: "verwende 2 Leerzeichen Einrückung" ist klarer als "formatiere den Code gut."

→ /dein-projekt/CLAUDE.md - Spezifisch für das Repository. Hier kommen Architektur, Teamkonventionen und wichtige Befehle hin. Wenn du ein neues Projekt startest, führe /init aus und Claude Code generiert es automatisch. Halte es unter 200 Zeilen: wenn es zu groß wird, beginnt Claude Code, Anweisungen zu ignorieren. Und wenn du es im Repo commitest, teilt sich das gesamte Team denselben Kontext.

→ .claude/rules/ - Modulare Regeln, die je nach Dateityp aktiviert werden. Nützlich, wenn das Projekt wächst und du nicht alles in eine einzige Datei packen möchtest.

Auto Memory - Das Gedächtnis, das Claude Code selbstständig aufbaut. Während du arbeitest, macht es sich Notizen: Muster, die es erkennt, Korrekturen, die du vornimmst, Entscheidungen, die ihr gemeinsam getroffen habt. Es wird gespeichert in

~/.claude/projects/<project>/memory/ und wird zu Beginn jeder Sitzung geladen.

Überprüfe es oft: Claude Code könnte schlechte Praktiken gespeichert haben, ohne dass du es merkst.

Tipp: Du kannst alles, woran sich Claude Code erinnert, einsehen und bearbeiten, indem du /memory ausführst.

Hooks und Skills: Übernimm die Kontrolle

1. Hooks

Claude Code arbeitet autonom.

Es führt Aktionen aus, trifft Entscheidungen, macht Fortschritte.

Aber diese Autonomie hat eine Seite, die nicht so oft erwähnt wird: Claude Code tut, was es in jedem Schritt für richtig hält.

Wenn etwas schiefgeht oder es etwas tut, das du nicht wolltest, ist es bereits passiert.

Wie kontrollierst du es? Mit Hooks.

Ein Hook ist ein Befehl, der automatisch zu bestimmten Zeitpunkten im Zyklus ausgeführt wird. Bevor Claude Code ein Tool verwendet, nachdem es es verwendet hat, wenn die Sitzung endet.

Du definierst, was in jedem Moment passiert.

Der Schlüssel ist, dass Hooks deterministisch sind.

Sie hängen nicht davon ab, dass Claude Code sich "erinnert", etwas zu tun. Sie werden immer ausgeführt, ausnahmslos.

Die vier wichtigsten Hooks sind:

PreToolUse - Wird ausgeführt, bevor Claude Code ein Tool verwendet. Es ist der einzige Hook, der eine Aktion blockieren kann. Beispiel: Blockiere jeden Befehl, der versucht, .env-Dateien zu ändern.

PostToolUse - Wird ausgeführt, nachdem Claude Code ein Tool verwendet hat. Beispiel: Führe Prettier automatisch aus, jedes Mal wenn Claude Code eine Datei bearbeitet.

Notification - Wird ausgeführt, wenn Claude Code deine Aufmerksamkeit benötigt. Beispiel: Erhalte eine Benachrichtigung auf deinem Mac, wenn Claude Code eine lange Aufgabe beendet hat.

Stop - Wird ausgeführt, wenn Claude Code die Antwort beendet hat. Beispiel: Automatisches Pushen zum Staging, wenn der Agent fertig ist.

Sie werden in .claude/settings.json konfiguriert:

1{
2  "hooks": {
3    "PostToolUse": [
4      {
5        "matcher": "Edit|Write",
6        "hooks": [
7          {
8            "type": "command",
9            "command": "npx prettier --write $file_path"
10          }
11        ]
12      }
13    ]
14  }
15}

Dieser Hook führt Prettier automatisch aus, jedes Mal wenn Claude Code eine Datei bearbeitet oder erstellt.

Ohne dass du fragst. Ohne dass Claude Code sich daran erinnern muss.

Ohne Hook: Claude Code bearbeitet eine Datei, der Code bleibt unformatiert, und du bemerkst es beim nächsten Commit.

Mit Hook: Claude Code bearbeitet eine Datei, PostToolUse wird automatisch ausgelöst, Prettier formatiert die Datei, und der Code bleibt immer sauber.

Hooks ermöglichen es dir, dem Zyklus des Agenten garantiertes Verhalten hinzuzufügen. Keine Vorschläge, keine Anweisungen, die das Modell ignorieren kann. Regeln, die immer ausgeführt werden.

2. Skills

Es gibt ein weiteres Problem: Konsistenz.

Du bittest es zweimal um dieselbe Aufgabe und erhältst unterschiedliche Ergebnisse. Jedes Mal, wenn du eine neue Konversation öffnest, startet Claude Code, ohne zu wissen, wie du es beim letzten Mal gemacht hast.

Wie löst du es? Mit Skills.

Ein Skill ist eine Markdown-Datei, in der du Claude Code den genauen Prozess für eine Aufgabe erklärst: was zu überprüfen ist, in welcher Reihenfolge, welches Format zu verwenden ist, was zu ignorieren ist.

Jedes Mal, wenn diese Aufgabe auftaucht, befolgt Claude Code diese Anweisungen.

Ohne Skill: Du bittest es, eine API zu dokumentieren, und es generiert etwas, aber jedes Mal mit einem anderen Format. Mal mit Beispielen, mal ohne.

Mit Skill: Du bittest es, eine API zu dokumentieren, und es befolgt den genauen Prozess, den du definiert hast. Immer mit denselben Schritten, demselben Format, denselben Kriterien. Jedes Mal gleich.

Um einen Skill zu erstellen, definierst du einen Ordner mit dieser Struktur:

1mein-skill/
2├── SKILL.md          # Hauptanweisungen (erforderlich)
3├── template.md       # Vorlage, die Claude ausfüllt
4├── examples/
5│   └── sample.md    # Beispiel für erwartete Ausgabe
6└── scripts/
7    └── validate.sh  # Skript, das Claude ausführen kann

Die einzige obligatorische Datei ist SKILL.md. Der Rest ist optional und wird je nach Bedarf der Aufgabe hinzugefügt.

Die SKILL.md hat 2 Teile:

Der Frontmatter - Ein YAML-Block mit Name und Beschreibung. Der Name ist der Befehl, um es manuell aufzurufen. Die Beschreibung ist das, was Claude Code liest, um zu entscheiden, wann es automatisch aktiviert werden soll.

Der Hauptteil - Die Anweisungen in Markdown. Der Workflow, die Kriterien, das Ausgabeformat.

1---
2name: api-docs
3description: Dokumentiert API-Endpunkte. Verwende es, wenn der Benutzer
4             darum bittet, eine API zu dokumentieren oder "swagger" oder "endpoints" erwähnt
5---
6
7## Prozess
81. Identifiziere alle Endpunkte
92. Für jeden: Methode, Pfad, Parameter, erwartete Antwort
103. Füge ein Anfrage- und Antwortbeispiel hinzu
114. Schließe mit einer Zusammenfassungstabelle ab

Einmal erstellt, kannst du es auf zwei Arten aufrufen.

Indem du /api-docs direkt in den Chat schreibst, oder indem du Claude Code einfach in natürlicher Sprache darum bittest.

Wenn die Beschreibung zu dem passt, worum du bittest, aktiviert es sich von selbst.

Du kannst sie für jede Aufgabe erstellen, die du mit einem klaren Prozess dahinter wiederholst: API-Dokumentation, Changelogs, Zusammenfassungen von Meetings, Code-Migrationen.

SubAgents: Delegieren, wenn das Problem wächst

Wir haben bereits gesehen, dass der Kontext eine begrenzte Kapazität hat.

Je länger die Sitzung, desto mehr füllt er sich. Und wenn er sich füllt, beginnt Claude Code, Informationen darüber zu verlieren, was vorher passiert ist.

Stell dir vor, du bittest es, dein gesamtes Projekt auf Sicherheitsprobleme zu überprüfen. Es liest Dutzende von Dateien, analysiert den Code, erstellt einen detaillierten Bericht.

All das füllt den Kontext schnell.

Und während es das tut, ist deine Hauptkonversation blockiert.

Wie löst du es? Mit SubAgents.

Ein SubAgent ist eine separate Instanz von Claude Code, die mit ihrem eigenen Kontext läuft.

Der Hauptagent delegiert eine Aufgabe an ihn, der SubAgent führt sie unabhängig aus, und wenn er fertig ist, sendet er eine Zusammenfassung mit den Ergebnissen.

Der Kontext des Hauptagenten füllt sich nicht mit dem gesamten Prozess, sondern nur mit dem Ergebnis.

1Haupt-Agent
2    ↓
3"Überprüfe das Projekt auf Sicherheitsprobleme"
4    ↓
5┌─────────────────────────────┐
6│    SubAgent: security-reviewer    │
7│                             │
8│  Liest Projektdateien       │
9│  Analysiert Code            │
10│  Erkennt Schwachstellen     │
11│  Erstellt Bericht           │
12└─────────────────────────────┘
13    ↓
14Gibt Zusammenfassung an Haupt-Agent zurück
15    ↓
16Haupt-Agent fährt mit dem Loop fort

Und das ist nicht alles.

SubAgents können parallel ausgeführt werden.

Anstatt drei Teile des Codes nacheinander zu analysieren, kann Claude Code alle drei gleichzeitig delegieren.

Was früher Minuten dauerte, kann Sekunden dauern.

1Haupt-Agent
2    ↓
3Teilt Arbeit in unabhängige Aufgaben auf
4    ↓
5┌──────────────┐  ┌──────────────┐  ┌──────────────┐
6│  SubAgent 1  │  │  SubAgent 2  │  │  SubAgent 3  │
7│              │  │              │  │              │
8│ Prüft Auth   │  │ Prüft DB     │  │ Prüft externe│
9│              │  │              │  │ APIs         │
10└──────────────┘  └──────────────┘  └──────────────┘
11        ↓                 ↓                 ↓
12        Haupt-Agent erhält die drei Zusammenfassungen
13                          ↓
14                Fährt mit dem Loop fort

Claude Code hat 3 native SubAgents, die es automatisch verwendet:

→ Explore - Ein schneller, schreibgeschützter Agent, der auf die Suche und Analyse des Projekts spezialisiert ist. Ergebnisse bleiben im Kontext des SubAgents, nicht in deinem.

→ Plan - Aktiviert im Plan-Modus. Bevor es dir einen Plan präsentiert, delegiert Claude Code die Projektuntersuchung an diesen Agenten.

→ General-purpose - Für komplexe Aufgaben, die sowohl Erkundung als auch Änderungen erfordern.

Du kannst auch eigene erstellen.

SubAgents werden in Markdown-Dateien mit YAML-Frontmatter definiert und in .claude/agents/ gespeichert.

1---
2name: security-reviewer
3description: Überprüft Code auf Sicherheitslücken.
4             Verwende es, wenn der Benutzer nach einem Sicherheits-Review fragt.
5tools: Read, Grep, Glob
6---
7
8Du bist ein Sicherheitsexperte. Analysiere den Code auf:
9- SQL-Injection
10- Offenlegung sensibler Daten
11- Authentifizierungsschwachstellen
12
13Schließe mit einer Zusammenfassung der Ergebnisse ab, geordnet nach Schweregrad.

Beachte, dass wir im Frontmatter die Tools auf Read, Grep und Glob beschränken.

Dieser Agent kann analysieren, aber niemals etwas ändern.

Wenn du eine feine Kontrolle darüber benötigst, was jeder Agent tun kann, ist diese Tool-Einschränkung entscheidend.

Einmal erstellt, erkennt Claude Code es automatisch anhand der Beschreibung und ruft es auf, wenn die Aufgabe passt. Oder du kannst es explizit aufrufen: "verwende den security-reviewer Agenten, um diesen PR zu überprüfen."

Wann sollten SubAgents verwendet werden und wann nicht?

Es ist sinnvoll, wenn die Aufgabe lang ist und viele Ergebnisse produziert, wenn die Arbeit in unabhängige Teile aufgeteilt werden kann, die parallel laufen, oder wenn ein spezialisierter Agent mit eingeschränkten Tools benötigt wird.

Es lohnt sich nicht für kurze Aufgaben, die den Kontext nicht füllen. Die Koordination von SubAgents fügt Komplexität hinzu, die keinen Sinn ergibt, wenn der Hauptagent die Aufgabe in zwei Minuten lösen kann.

MCP: Den Agenten mit der Außenwelt verbinden

Tools geben Claude Code die Fähigkeit, auf deinem Rechner zu handeln.

Aber es gibt eine Grenze: Alles, was passiert, passiert dort drin.

Es kann keinen PR auf GitHub öffnen, keine Produktionsdatenbank abfragen oder ein Ticket in Jira erstellen. Dafür musstest du zuvor den Agenten verlassen und es selbst von Hand erledigen.

Wie löst du es? Mit MCP.

MCP (Model Context Protocol) ist ein offenes Protokoll, das definiert, wie Claude Code sich mit externen Diensten verbindet.

Es funktioniert mit einer Client-Server-Architektur: Claude Code ist der Client, und jeder externe Dienst hat seinen eigenen MCP-Server, der offenlegt, was er kann.

Wenn du einen MCP-Server verbindest, erhält Claude Code eine Liste der verfügbaren Tools mit deren Namen und Beschreibung.

Von dort aus verwendet es sie genau wie native Tools. Der einzige Unterschied ist, dass die Aktion im externen Dienst stattfindet, nicht auf deinem Rechner.

1Claude Code
2    ↓
3Entscheidet, ein Tool des GitHub MCP-Servers zu verwenden
4    ↓
5┌─────────────────────────────┐
6│      GitHub MCP Server      │
7│                             │
8│   Öffnet den PR             │
9│   Weist Reviewer zu         │
10│   Gibt Bestätigung zurück   │
11└─────────────────────────────┘
12    ↓
13Claude Code erhält das Ergebnis und fährt fort

Ohne MCP: Du sagst "Ich habe die Änderungen abgeschlossen, öffne den PR" und Claude Code kann es nicht. Du musst zu GitHub gehen, das Formular ausfüllen, Reviewer zuweisen und es selbst mergen.

Mit MCP: Du sagst dasselbe und Claude Code öffnet den PR, schreibt die Beschreibung, weist die Reviewer zu und benachrichtigt dich, wenn es fertig ist. Alles, ohne dass du den Agenten verlässt.

Einige MCP-Server, die du heute verbinden kannst:

→ GitHub - PRs, Reviews, Issues

→ Postgres / Supabase - Datenbanken abfragen und ändern

→ Slack - Nachrichten und Kanäle

→ Jira - Tickets und Projekte

Native Tools für deine lokale Umgebung. MCP für die Außenwelt.

Wie alles zusammenspielt

Claude Code ist ein Agent: ein System, das ein Ziel aufnimmt und in einem autonomen Loop arbeitet, bis es es erfüllt.

Jedes Teil, das du in diesem Artikel gesehen hast, existiert, um diesen Loop leistungsfähiger zu machen. Aber der beste Weg, es zu verstehen, ist zu sehen, wie sie zusammen interagieren.

Fall 1: Einen PR überprüfen und mergen

Du sagst zu Claude Code: "Überprüfe PR #42 und merge ihn, wenn alles in Ordnung ist."

→ Es verwendet GitHub MCP, um die geänderten Dateien zu lesen und die Änderungen zu verstehen

→ Es delegiert die Sicherheitsanalyse an einen spezialisierten SubAgent, um den Hauptkontext nicht zu füllen

→ Ein Hook führt die Tests lokal aus und überprüft, ob alles bestanden wird

→ Wenn die Tests bestehen, verwendet es GitHub MCP, um den Merge durchzuführen, ohne dass du die Oberfläche berührst

Du hast eine Zeile geschrieben. Claude Code hat vier Systeme koordiniert.

Fall 2: Eine API dokumentieren und das Team benachrichtigen

Du sagst zu Claude Code: "Dokumentiere die neuen Endpunkte und informiere das Team."

→ Es aktiviert ein Dokumentations-Skill, das das genaue Format definiert: was aufzunehmen ist, wie zu strukturieren ist, welche Beispiele hinzuzufügen sind

→ Es verwendet Tools, um den Code zu lesen und die Endpunkte zu extrahieren

→ Ein Hook formatiert die Ausgabe, bevor sie gespeichert wird

→ Es verwendet Slack MCP, um die Zusammenfassung an den Team-Kanal zu senden

Jedes Mal, wenn du es tust, wird das Ergebnis dasselbe sein. Ohne Abweichungen, ohne dass du etwas erklären musst.

Alles dreht sich um den Loop.

Gedächtnis, um jede Sitzung informiert zu starten. Tools, um zu handeln. Hooks, um zu kontrollieren. Skills, um zu standardisieren. SubAgents, um zu skalieren. MCP, um sich mit der Außenwelt zu verbinden.

Wenn du das verstehst, verstehst du Claude Code.

Und nicht nur Claude Code: Cursor, Copilot und jeder Agent, den du von nun an verwendest, basieren auf denselben Grundlagen.

Die Namen ändern sich, die Oberfläche ändert sich, aber der Loop ist derselbe.

KI macht schnell Fortschritte.

Jede Woche gibt es etwas Neues. Aber die Grundlagen ändern sich nicht so oft. Sie klar zu haben, wird es dir ermöglichen, dich schneller anzupassen und mehr aus dem herauszuholen, was als Nächstes kommt.

Nutze Claude Code nicht nur zum Prompts-Schreiben. Achte darauf, was darunter passiert. Dort liegen die Chancen.

Einige Startpunkte, um heute zu beginnen:

→ Überprüfe dein Auto Memory und verbessere, was Claude Code gespeichert hat

→ Erstelle eine CLAUDE.md für dein Projekt, falls du noch keine hast

→ Verbinde den GitHub MCP

→ Baue einen SubAgent für Aufgaben, die den Kontext füllen

→ Konfiguriere einen Hook, der nach jeder Änderung Tests ausführt

Das war's, bis morgen.

Marcus