27 Einstellungen, um Claude Code in ein autonomes Agentensystem zu verwandeln

Warum sich dein Workflow nicht geändert hat, obwohl du Claude Code täglich nutzt

„Ich erinnere mich, dass ich /init ausgeführt habe. Aber ich habe keine Ahnung, wann ich es das letzte Mal aktualisiert habe."

Kommt dir das bekannt vor? Du hast Claude Code installiert, die ersten Tage mit der Konfiguration verbracht, und unterhältst dich täglich damit. Dennoch ist die Struktur deiner Arbeit im Vergleich zu vor drei Monaten weitgehend unverändert.

Das ist kein Problem der Nutzung, sondern ein Problem der Positionierung.

Wenn du Claude Code weiterhin als „Tool, das antwortet, wenn man es anspricht" verwendest, wirst du jeden Morgen dieselben Anweisungen tippen, ähnliche Antworten erhalten und sie in deine Arbeit kopieren. Du bist vielleicht effizienter, aber die Art und Weise, wie deine Arbeit voranschreitet, hat sich nicht grundlegend verändert.

Eine Veränderung tritt ein, wenn du beginnst, Claude Code als „Design-Ziel" zu betrachten. Wer weiß was in welchem Kontext? Welche Aufgaben werden an wen delegiert? Was bewegt sich, selbst wenn kein Mensch anwesend ist? Wenn du beginnst, dies als Design zu betrachten, verhält sich Claude Code ganz anders.

Die 27 Funktionen, die von @sairahul1 veröffentlicht wurden (https://x.com/sairahul1/status/2070428662080618607), listen systematisch Funktionen auf, die aus dieser Design-Perspektive verwendet werden sollten. Swarm hat diese durch die Linse des Agenten-Designs interpretiert und in ein Format organisiert, das auf reale Geschäftskontexte anwendbar ist.

Siebenundzwanzig mag viel erscheinen, aber es gibt nur drei Kernprinzipien. Wir werden diese Struktur ab dem nächsten Kapitel der Reihe nach erklären.

Die drei Disziplinen, die die 27 Funktionen verbinden

Betrachtet man die 27 Funktionen, wirken sie vielleicht verstreut. Es gibt Tastenkürzel, Dateieinstellungen, Spracheingabe und Testausführung. Wenn man sie jedoch entschlüsselt, lassen sie sich in Gruppen einteilen, die drei Fragen beantworten.

Disziplin 1: Kontext-Design (Funktionen 1–5)

Einen Zustand schaffen, in dem Claude weiß, „wessen Projekt es ist, zu welchem Zweck und wie viel es derzeit versteht." Wenn dies nicht funktioniert, musst du jedes Mal alles von Grund auf erklären.

Disziplin 2: Delegations-Design (Funktionen 6–14)

Aufgaben und Befugnisse strukturiert an Claude übergeben. Anstatt zu sagen „Behebe den Fehler", organisierst du und übergibst „was kaputt ist und welche Einschränkungen es gibt", was die Wahrscheinlichkeit einer Lösung beim ersten Mal verändert.

Disziplin 3: Autonomie-Design (Funktionen 15–27)

Entwicklung eines Mechanismus, bei dem Claude sich ohne ständige menschliche Anweisungen weiterbewegen kann.

Diese drei Stufen sind auch die Reihenfolge, in der du sie verwenden solltest. Wenn der Kontext nicht gesetzt ist, wird die Delegation schlampig. Wenn die Delegation nicht gestaltet ist, läuft die Autonomie aus dem Ruder.

Worauf du hier achten musst, ist, wie du die Struktur von „ich unterweise Claude jeden Morgen" änderst. Wenn du jeden Morgen dieselben Aufgaben in den Chat wirfst, ist der Mensch immer noch das Subjekt. Wenn das Design auf eine Struktur umschaltet, die Claude bewegt, ändert sich, was du morgens tust.

Schauen wir uns zunächst die fünf Funktionen des Kontext-Designs an.

Grundlagen des Kontext-Designs

Das Ziel des Kontext-Designs ist es, Claude den „Kontext dieses Projekts" zu geben. Ohne Kontext beginnt jedes Gespräch mit einer leeren Tafel.

Das erste, was ausgeführt werden sollte, ist `/init`.

Wenn du ein Projekt zum ersten Mal öffnest, führe dies zuerst aus. Claude scannt die Codebasis-Struktur, Abhängigkeiten und Build-Befehle, um automatisch CLAUDE.md zu generieren. Diese Datei wird zum „Bauplan" des Projekts.

Hier hören viele Leute auf. Sie erinnern sich, dass sie /init ausgeführt haben, wissen aber nicht, wann es zuletzt aktualisiert wurde. Wenn es so belassen wird, wie es generiert wurde, weicht der Inhalt von CLAUDE.md mit der Zeit von der Realität ab, wenn sich das Projekt ändert. Indem man von wöchentlichen Aktualisierungen ausgeht, kann sich Claude immer im aktuellsten Kontext bewegen.

Als nächstes ist es nützlich, `/statusline` einzurichten.

Eine Statuszeile wird am unteren Bildschirmrand erscheinen. Du kannst visuell erfassen, was läuft und welche Prozesse aktiv sind. Es kann auch mit benutzerdefinierten Statuszeilen in Vim oder Neovim integriert werden, sodass du es gemäß deiner bestehenden Editor-Umgebung einrichten kannst.

Die dritte ist die Spracheingabe.

Du kannst komplexe Anforderungen per Sprache übergeben, indem du unter Mac ⌃⌘Leertaste oder die native Spracheingabe unter iOS und Android verwendest. Du kannst lange Anweisungen wie „Ich möchte, dass sich diese Komponente aus diesem Grund so bewegt, aber ändere nicht die vorhandenen Stile" übergeben, ohne zu tippen. Da du Gedanken so weitergeben kannst, wie sie fließen, sparst du Zeit, die sonst für das Ordnen beim Tippen aufgewendet werden müsste.

Verwende `/context`, um den Zustand des Kontexts zu überprüfen.

Du kannst sehen, was sich gerade im Gespräch befindet und die Nutzung des Kontextfensters in Echtzeit. In langen Sitzungen neigt der Inhalt des anfänglichen Bauplans dazu, zu verblassen. Mit diesem Befehl kannst du dies überwachen.

Die Reset-Operationen dafür sind `/compact` und `/clear`.

/compact komprimiert den gesamten Kontext in eine Zusammenfassung. /clear ist ein vollständiger Reset. Wenn du eine lange Sitzung fortsetzt, können Claudes Antworten vage werden. Dies ist ein Zeichen dafür, dass der Kontext verstopft ist. Durch regelmäßiges Verwenden von /compact kannst du die Ausgabequalität aufrechterhalten.

Vorher: In der zweiten Hälfte einer langen Sitzung gibt Claude eine unpassende Antwort, selbst wenn es sagt, „der zuvor besprochenen Designrichtlinie folgend".

Nachher: Das Komprimieren mit /compact vor dem Fortsetzen hält die Ausgabe genau an der Richtlinie.

Die fünf Funktionen tun eines: Sie erhalten den Zustand, dass Claude „weiß", als Design. Das wird die Grundlage für den nächsten Schritt, das Delegations-Design.

Die Kunst, Probleme zu übergeben

Sobald der Kontext gesetzt ist, besteht der nächste Schritt darin, das Problem zu übergeben. Die Genauigkeit der Antwort ändert sich vollständig, je nachdem, ob du sagst „Behebe den Fehler" oder es strukturiert übergibst.

Verwende zuerst den Planmodus (`Umschalt+Tab`).

Vor größeren Änderungen gibt dieser Modus „nur den Plan" aus, anstatt ihn auszuführen. Du kannst vorab überprüfen, was Claude zu ändern beabsichtigt und in welcher Reihenfolge.

Anstatt Fehler zu beheben, nachdem sie aufgetreten sind, kannst du bereits in der Planungsphase darauf hinweisen, dass „das falsch ist". Allein die Integration dieses einen Schritts in dein Design verändert die Häufigkeit unerwarteter Änderungen erheblich. Mit der Zeit wirst du feststellen, dass es den Aufwand reduziert, im Nachhinein zu überprüfen, „warum wurde diese Datei umgeschrieben?".

Zweitens: die Strukturierung von Problem, Einschränkungen und Kontext.

Wenn du nur sagst „Behebe den Fehler", versucht Claude, die Annahmen selbst zu füllen. Wenn diese Annahmen falsch sind, wird auch die Lösung falsch sein.

Das offiziell empfohlene Format ist, in die erste Zeile zu schreiben, „was kaputt ist", und ab der zweiten Zeile „was versucht wurde, Einschränkungen und das erwartete Ausgabeformat". Allein die Übergabe in diesem Format verändert die Rate der Lösungen beim ersten Versuch. Die Art und Weise, wie du das Problem übergibst, wird selbst zu einer Fähigkeit.

Drittens: `AskUserQuestion`.

Dies ist eine Funktion, bei der Claude um Klärung bittet, bevor es fortfährt, wenn es auf mehrdeutige Anforderungen stößt. Nacharbeit, die durch die Umsetzung mit vagen Anforderungen verursacht wird, tritt oft auf, wenn diese Funktion nicht verwendet wird. Es ist ein Design, das die Kosten der Bestätigung vor der Implementierung zahlt.

Viertens: der Selbstverifikationsschritt.

Sage ihm am Ende einer Aufgabe: „Führe Tests aus und bestätige, dass der Build erfolgreich ist, bevor du abschließt". Anstatt dies jedes Mal manuell hinzuzufügen, stelle sicher, dass es durch das Schreiben in CLAUDE.md automatisch am Ende jeder Aufgabe ausgeführt wird. Anstatt dass Claude in einem Zustand anhält, in dem nach einer Änderung etwas nicht funktioniert, wird die Schleife inklusive Verifikation als eine einzige Aufgabe abgeschlossen.

Proaktive Schritte mit dem Planmodus unternehmen und reaktive Schritte mit Selbstverifikation automatisieren. Die Struktur des Entwicklungsablaufs ändert sich in dem Moment, in dem diese beiden in das Design integriert sind.

Im nächsten Kapitel werden wir uns mit dem Design der Delegation kontinuierlicher Aufgaben an Claude befassen.

Delegation gestalten

In den vorherigen Kapiteln haben wir organisiert, wie man mit Claude kommuniziert und wie man es Erinnerungen behalten lässt. Als nächstes geht es darum zu ändern, „wer das Subjekt wird".

10. Subagenten

Wenn ein Mensch bei langen Aufgaben Abläufe verwaltet, bleibt er zwangsläufig stecken. Ständig zu sagen „mach das als nächstes, dann mach das, wenn du fertig bist", bedeutet, dass der Mensch und nicht Claude die Koordination übernimmt.

Mithilfe von TodoWrite- oder Task-Tools zerlegt Claude Aufgaben in Unteraufgaben und führt sie parallel aus. Offiziell heißt dies „gleichzeitige Ausführung von Subagenten" – eine Struktur, bei der sich mehrere Kind-Claudes gleichzeitig bewegen. Verschiedene Claudes führen gleichzeitig Recherche, Implementierung und Tests durch. Menschen müssen den Ablauf nicht im Kopf behalten.

11. Benutzerdefinierte Skills (Workflow-Vorlagendateien)

Durch das Ablegen von Markdown-Dateien im Verzeichnis .claude/commands/ kannst du Anweisungssätze mit /Befehlsname aufrufen. Im Kontext von Swarm ist es einfacher, sich diese als „SKILL.md (Workflow-Vorlagendateien)" vorzustellen.

Vorher: Jedes Mal schreiben: „Bitte führe eine Wettbewerbsanalyse durch. Die Schritte sind 1, 2, 3..."

Nachher: Einfach /wettbewerbsanalyse in einer Zeile tippen.

Die Zeit, die mit dem wiederholten Schreiben derselben Anweisungen verbracht wird, entfällt. Wenn es im Team geteilt wird, wird es zu einer Vorlage, bei der jeder die gleiche Ausgabequalität erzielen kann.

12. Modellauswahl

Du kannst Modelle innerhalb einer Sitzung durch Drücken von Alt+P wechseln. Ein realistischer Dreistufen-Einsatz ist: Modelle mit hoher Argumentationsfähigkeit für die Design- und Konzeptphase, leichte Modelle für einfache Implementierung und Modelle der mittleren Stufe für das Debugging.

Die Leistung des Modells an das Gewicht des Prozesses anzupassen, verbessert gleichzeitig die Kosteneffizienz und die Reaktionsgeschwindigkeit.

13. Automatische `CLAUDE.md`-Aktualisierungen

Wenn du Claude anweist, „füge das, was du in diesem Projekt gelernt hast, zu CLAUDE.md hinzu", wird Claude CLAUDE.md selbst aktualisieren. Es ist eine Struktur, bei der der Bauplan von selbst wächst.

Indem du diesen Befehl einmal pro Woche hinzufügst, wird CLAUDE.md zu einem „lebendigen Dokument". Selbst wenn Menschen keine Reflexionen schreiben, sammelt Claude, was es gelernt hat.

14. Externe Dateiverlinkung

Du kannst Dateien, URLs oder Issues als Kontext mit @{Dateipfad} übergeben. Es ist ein Mechanismus, um »lies diese Datei, bevor du arbeitest« in einer Zeile zu erledigen.

Vorher: Dateiinhalte kopieren und in den Prompt einfügen.

Nachher: Einfach „Überprüfe die Einstellungen, indem du auf @src/config.yaml verweist." schreiben.

Delegation zu gestalten bedeutet, ein System zu schaffen, das das Subjekt an Claude übergibt. Wenn Abläufe, Vorlagen, Referenzen und Gedächtnis alle vorhanden sind, müssen Menschen nur noch darüber nachdenken, „was zu erstellen ist".

Doch je mehr Delegation stattfindet, desto größer wird auch das Risiko, dass „Claude sich in eine andere Richtung bewegt als beabsichtigt". Im nächsten Kapitel werden wir uns ansehen, wie man diese Abweichung frühzeitig stoppen kann.

Abweichungen frühzeitig stoppen

Je mehr Aufgaben an Claude delegiert werden, desto wahrscheinlicher tritt ein Problem auf: die Erkenntnis, dass es in eine völlig andere Richtung als beabsichtigt gegangen ist. Wir nennen das Abweichung (Drift).

Abweichung ist nichts, was man später behebt; sie kann durch proaktive Designschritte verhindert werden.

15. Sofortiger Stopp

Wenn du das Gefühl hast, dass die Ausgabe in eine offensichtlich falsche Richtung geht, kannst du sie sofort mit der Escape-Taste stoppen. „Ich repariere es, nachdem es fertig ist" ist ein Fehler. Je weiter die Generierung fortschreitet, desto höher sind die Korrekturkosten. Das Stoppen auf halbem Weg und das Korrigieren des Prompts spart sowohl Zeit als auch Token.

Wenn du intuitiv das Gefühl hast, dass etwas nicht stimmt, stoppe es ohne Zögern. Die Geschwindigkeit dieser Beurteilung wirkt sich direkt auf die Genauigkeit aus.

16. Die erste Ausgabe als Beweis anfordern

Ein proaktives Design besteht darin, zu sagen: „Zeig mir zuerst nur die erste Ausgabe, und ich entscheide, ob ich fortfahre", bevor du mit der Arbeit beginnst.

Anstatt es 10 Minuten in die falsche Richtung laufen zu lassen, bestätige mit der ersten Ausgabe, bevor du es weiterlaufen lässt. Das ist die Idee, Abweichungen im Keim zu ersticken. Es ist unerlässlich für lang andauernde Aufgaben oder Arbeiten, die mit vagen Anweisungen beginnen.

Bevor du sagst: „Den Rest überlasse ich dir", füge ein: „Lass mich den Anfang überprüfen." Es ist nur ein Schritt, aber dieser proaktive Schritt verändert das Ergebnis.

17. Benachrichtigungs-Hooks

Auf den Bildschirm zu starren und auf das Ende einer langen Aufgabe zu warten, ist Zeitverschwendung. Indem du ein Skript in ~/.claude/hooks/ platzierst, kannst du Desktop-Benachrichtigungen erhalten, wenn eine Aufgabe abgeschlossen ist.

Richte es einmal ein. Von da an wird Claude dich benachrichtigen, wenn es fertig ist, selbst wenn du andere Arbeiten erledigst. Es ist ein Design, das den Akt des Wartens eliminiert.

18. Screenshots übergeben

UI-Fehler in Worten zu erklären, ist überraschend schwierig. Anstatt mündlich zu sagen: „Ein roter Fehler erschien oben links und der Knopf kann nicht gedrückt werden", ist es schneller, einen Screenshot zu übergeben.

Claude empfängt das Bild und gibt den Fehlerinhalt, die Ursache und Lösungsvorschläge direkt zurück. Es ist erledigt mit „Schau dir diesen Bildschirm an".

Die bisher vorgestellten 18 Funktionen basieren alle auf der Prämisse, dass eine Person sie bedient. Im nächsten Kapitel betreten wir die Struktur der „Nutzung im Team", bei der mehrere Claudes parallel laufen und integriert werden.

Paralleler Betrieb und Integration

Wenn du Claude Code als Chat-Tool verwendest, kannst du mit der nächsten Aufgabe erst beginnen, wenn eine abgeschlossen ist. Aber durch eine Änderung des Designs kannst du eine Struktur schaffen, in der sich mehrere Claudes gleichzeitig bewegen.

Beginne mit der Chrome DevTools-Integration. Da du Browser-Fehlerprotokolle und Netzwerkprotokolle direkt an Claude Code übergeben kannst, musst du Situationen nicht mehr mündlich erklären wie: „Da ist ein roter Fehler in der Konsole, aber ich weiß nicht, was los ist." Die offizielle Dokumentation hat eine eigene Seite dafür und positioniert es als das Tor zum Debugging.

Auch die Sitzungsverwaltung ändert sich. Du kannst die letzte Sitzung mit claude --continue sofort fortsetzen oder mit claude --resume aus einer Liste von Sitzungen auswählen. Darüber hinaus kannst du durch die Benennung von Sitzungen mit /rename mehrere Aufgaben parallel mit dem gleichen Gefühl wie bei Git-Branches verwalten. Durch die Verwendung von Sitzungen mit den Namen „Auth", „Payment" und „Dashboard" werden die Kosten für den Kontextwechsel nahezu Null.

Und der Kern des parallelen Betriebs ist die Kombination mit git worktrees. Die Eingabe von claude --worktree feature-auth startet eine Sitzung, bei der der Branch durch den Worktree vollständig isoliert ist. Wenn du Auth, Payment und Dashboard in separaten Worktrees ausführst, werden drei Claudes die Entwicklung parallel vorantreiben. Da sich jeder in einem unabhängigen Arbeitsbereich befindet, treten keine Konflikte auf. Die Struktur, eine Woche Entwicklungsarbeit an einem Tag zu erledigen, ist hier als Design etabliert.

Es ist auch notwendig, die Gedanken zu MCP zu ordnen. Ein MCP-Server ist nicht immer die optimale Lösung. Die offizielle Dokumentation besagt, dass „CLI-Tools der kontext-effizienteste Weg sind, um mit externen Diensten zu interagieren", und CLI-Tools wie gh oder aws sollen eine hohe Kontexteffizienz haben und seltener Ratenbegrenzungen auslösen. Allein mit dem Befehl gh kann Claude Code autonom GitHub Issues erstellen, aktualisieren und schließen. Eine Beurteilungsachse zu haben, um zu prüfen, ob ein CLI-Tool verwendet werden kann, bevor ein MCP hinzugefügt wird, hält das Design einfach.

Wenn paralleles Design möglich ist, müssen Menschen die Reihenfolge nicht mehr verwalten. Dies liegt daran, dass das Design darauf umschaltet, mehrere Subjekte gleichzeitig an Claude zu übergeben. Als nächstes werden wir dieses gestaltete parallele Verarbeiten zu einem System weiterentwickeln, das sich auch dann weiterbewegt, wenn du nicht an deinem Schreibtisch bist.

Autonomer Betrieb

Die nächste Frage nach dem parallelen Design ist: „Wo muss ich während dieser Zeit sein?" Wenn der autonome Betrieb gestaltet ist, entsteht ein Zustand, in dem die Arbeit auch ohne Anwesenheit eines Menschen voranschreitet.

/loop ist eine Funktion, die automatisches Abfragen innerhalb einer Sitzung ausführt. Die offizielle Erklärung lautet „Schnelles Abfragen, während eine Sitzung geöffnet ist", und es wiederholt angegebene Operationen, solange die Sitzung geöffnet ist. Die Verwendung von --resume oder --continue ermöglicht es, Sitzungen fortzusetzen, die noch nicht abgelaufen sind, und laut Erfahrungsberichten im Originalartikel wurden Fälle von unbeaufsichtigtem Betrieb von bis zu drei Tagen berichtet. Obwohl wir diese Anzahl von Tagen nicht direkt mit offiziellen Quellen bestätigt haben, fungiert es sicherlich als Einstiegspunkt für lang andauernden autonomen Betrieb.

Remote Control, hinzugefügt im Q1 2026, ist eine Funktion, um lokal laufende Claude Code-Sitzungen von einem Smartphone oder PC-Browser aus zu bedienen. Während der Code lokal bleibt, werden nur Nachrichten über einen verschlüsselten Kanal ausgetauscht. Es wurde im Februar 2026 als Research Preview veröffentlicht. Ein Szenario ist etabliert, bei dem sich der lokale Claude Code weiterbewegt, indem man einfach von unterwegs vom Smartphone aus „Überprüfe, ob die Tests bestanden wurden" sendet.

Natürlichsprachliche Abfragen an Datenbanken können ebenfalls in das Design integriert werden. Die Verbindung mit SQLite, PostgreSQL oder MySQL über MCP ermöglicht es dir, Daten mit Deutsch (oder Englisch) abzurufen, wie zum Beispiel „Sag mir die Benutzer, die letzte Woche registriert wurden". Der offizielle Leitfaden schlägt vor, claude mcp add auszuführen, um externe Tools wie deine Datenbank zu verbinden, sodass du Datenbestätigungsroutinen an Claude delegieren kannst, ohne SQL schreiben zu müssen.

Es gibt auch vier Funktionen, um die Tiefe des Denkens zu steuern. ultrathink löst erweitertes Denken von bis zu 31.999 Token aus, indem es dieses Schlüsselwort einfach in den Prompt aufnimmt. Es gibt eine Hierarchie: think sind 4.000 Token, megathink sind 10.000 Token und ultrathink sind 31.999 Token. Die richtige Verwendung ist nur für die wirklich schwierigen 10 % der Probleme, wie komplexe Architekturentscheidungen, Sicherheitsimplementierungen, Leistungsoptimierung und großangelegte Refaktorisierungen. Die Verwendung für jede Anfrage wird die Kosten sinnlos in die Höhe treiben.

/effort ultracode ist eine Einstellung, um xhigh Reasoning und dynamische Workflows für die gesamte Sitzung zu aktivieren. Während ultrathink ein einmaliges Schlüsselwort ist, bleibt ultracode während der gesamten Sitzung aktiv. Es eignet sich für „sitzungsweite Schwerstarbeit" wie das Auditieren einer gesamten Codebasis, die Migration von Hunderten von Dateien oder risikoreiche Aufgaben. Da die Token-Kosten jedoch erheblich steigen, bestimmt die situationsgerechte Unterscheidung die Effektivität.

Claude Code, das damit begann, durch Tippen in einen Chat bewegt zu werden, hat das Tor zu einem System erreicht, das Ereignisse erkennt und sich autonom bewegt. Anstatt dass Menschen es bewegen, bewegt das Design Claude. Als nächstes werden wir anhand all dieser Funktionen bestätigen, wo im Wesentlichen der Unterschied in der Produktivität entsteht.

Warum sich die Ergebnisse mit demselben Claude Code unterscheiden

Leute, die schnell entwickeln, haben nicht unbedingt besondere Fähigkeiten. Sie gestalten lediglich systematischer.

Stelle dir zum Beispiel die Situation vor, /init auszuführen. Selbst wenn derselbe Befehl eingegeben wird, wird die Ausgabequalität mehrere Monate später völlig unterschiedlich sein zwischen einer CLAUDE.md, die wöchentlich aktualisiert wird, und einer, die seit der Einrichtung unberührt geblieben ist. Dies liegt daran, dass sich die Aktualität und Genauigkeit des Kontexts, den Claude liest, direkt auf die Qualität der Ausgabe auswirken.

Um eine Küchenanalogie zu verwenden: Das Niveau des Kochens wird mehr dadurch bestimmt, wie die Küche selbst organisiert ist, als durch die verwendeten Zutaten. Die Modellleistung von Claude wird allen Nutzern gleichermaßen zur Verfügung gestellt. Der Unterschied liegt in der Genauigkeit dieser drei Punkte: wie der Kontext organisiert wurde, wie Anweisungen systematisiert wurden und wie der autonome Betrieb gestaltet wurde.

Bevor du darüber diskutierst, „welches Modell verwendet werden soll", versuche zu überprüfen, wann deine aktuelle CLAUDE.md zuletzt aktualisiert wurde. Das wird dir den aktuellen Stand deines Designs verraten.

Wo solltest du also tatsächlich anfangen? Im nächsten Kapitel werden wir eine schrittweise Einführungsanleitung organisieren.

Wo anfangen: Eine schrittweise Einführungsanleitung

Du musst nicht versuchen, dich an alle 27 auf einmal zu erinnern.

In der ersten Woche beschränke dich auf nur vier.

• Erstelle eine Projektübersicht mit /init.
• Komprimiere den Kontext regelmäßig mit /compact.
• Trenne Erkundung und Ausführung mit dem Planmodus (Umschalt+Tab).
• Übergib Selbstverifikationsschritte (Tests, Builds) an Claude.

Allein mit diesen vier wird sich die Qualität der Sitzung grundlegend ändern. Da Claude beginnt, sich mit einer genauen Vorstellung davon zu bewegen, „was getan werden sollte", wird der Umfang der Nacharbeit sichtbar abnehmen.

Ab der zweiten Woche füge zu dieser Grundlage das Delegations-Design hinzu. Fasse Anweisungen mit benutzerdefinierten Skills in einem wiederverwendbaren Format zusammen, passe das Gewicht und die Geschwindigkeit der Verarbeitung mit der Modellauswahl (Alt+P) an und etabliere die Gewohnheit, CLAUDE.md wöchentlich zu aktualisieren. Dies ist die Stufe, in der Anweisungen von „etwas, das jedes Mal geschrieben wird" zu „etwas, das sich ansammelt" werden.

Nach einem Monat fahre mit Subagenten, git worktrees und parallelen Sitzungen fort. Du wirst ein System haben, in dem du dich auf Design und Bestätigung konzentrieren kannst, während du gleichzeitig mehrere Funktionen entwickelst.

ultrathink und ultracode sind Werkzeuge, die in diesem Ablauf zum ersten Mal verwendet werden sollten, wenn du auf „wirklich schwierige Probleme" stößt. Sie sind keine Werkzeuge, die für jedes Problem hervorgeholt werden sollten.

Indem du diese Schritte befolgst, wirst du durch Erfahrung verstehen, „warum jede Funktion notwendig ist". Bitte beginne mit den vier Punkten für die erste Woche.

Alles ändert sich in dem Moment, in dem du es als Design-Ziel behandelst

In dem Moment, in dem du beginnst, Claude Code als Design-Ziel zu behandeln, ändert sich die Qualität der Sitzung grundlegend.

Ich fasse den Inhalt dieses Artikels in einer Form zusammen, die du speichern und später nachschlagen kannst.

• Die vier Punkte – /init + /compact + Planmodus + Selbstverifikation – sind die grundlegendsten Basisdesigns.
• Systematisiere die Wiederverwendung von Anweisungen mit benutzerdefinierten Skills und pflege CLAUDE.md als wöchentlich aktualisierten „lebendigen Bauplan".
• Wenn du mit Subagenten arbeitest, wechselt die Produktivität von Addition zu Multiplikation.
• Die eiserne Regel ist, Abweichungen frühzeitig zu erkennen und sofort zu stoppen. Fordere immer Beweise in der ersten Ausgabe an.
• Du kannst mehrere Funktionen gleichzeitig mit git worktrees + parallelen Sitzungen entwickeln.
• Richte den autonomen Betrieb mit /loop ein, und bestätige oder weise von einem Smartphone aus mit Remote Control an.
• ultrathink ist ein dediziertes Werkzeug für die „wirklich schwierigen 10 %". Es ist nicht für jedes Problem gedacht.

Wenn du auch nur eine der in diesem Artikel erwähnten Funktionen ausprobierst, wird sich deine Beziehung zu Claude Code allmählich zu verändern beginnen.

An diejenigen, die sich für KI-Agenten interessieren

Swarm (@swarm_japan) teilt wesentliche Designphilosophien und Geschäftsanwendungsfälle für Agenten.

Folge uns, um das für die KI-Agenten-Ära notwendige Geschäftswissen zu erwerben 👇

★ Erklärung der neuesten KI-Agenten-Informationen aus einer einzigartigen Perspektive

★ Vorstellung von Geschäftsanwendungsfällen für Agenten

★ Veröffentlichung von eigenem Know-how

Wenn du interessiert bist, folge uns und schau vorbei! 👀