Alles, was ich über KI-Programmierung wusste, war falsch

AAI LABS
Computing/SoftwareInternet Technology

Transcript

00:00:00Du kennst bereits diese KI-Coding-Frameworks wie Beemad,
00:00:03Speckit und andere,
00:00:04aber das sind nicht die einzigen.
00:00:06Es gibt Hunderte von Menschen,
00:00:07die experimentieren und ihre eigenen Workflows einführen,
00:00:09aber wenn du sie ausprobierst,
00:00:10wirst du feststellen,
00:00:11dass sie oft nicht halten,
00:00:12was sie versprechen.
00:00:13Das liegt nicht daran,
00:00:14dass ihre Methoden schlecht sind,
00:00:15sondern daran,
00:00:16dass sie nicht zu deinem spezifischen Anwendungsfall passen.
00:00:18Wenn wir Apps entwickeln,
00:00:19erstellen wir die meiste Zeit unsere eigenen Workflows,
00:00:21anstatt uns auf vorgefertigte zu verlassen.
00:00:23Das liegt daran,
00:00:24dass Workflows um deinen spezifischen Anwendungsfall herum aufgebaut werden sollten und nur funktionieren,
00:00:27wenn sie mit dem Projekt übereinstimmen,
00:00:29das du zu entwickeln versuchst.
00:00:30Wie baust du also einen Workflow für deinen eigenen Prozess?
00:00:32Dafür musst du bestimmte Prinzipien kennen.
00:00:34Dies sind die Prinzipien,
00:00:35die jedes Framework auf die eine oder andere Weise verwendet.
00:00:38Bevor wir die Hauptprinzipien besprechen,
00:00:40ist es wichtig für dich zu wissen,
00:00:42was sich im Kontextfenster dieser KI-Tools befindet.
00:00:44Das ist wirklich wichtig,
00:00:45denn das Verwalten des Kontexts ist im Grunde das,
00:00:47was diese Frameworks tun.
00:00:48Das Kontextfenster ist im Grunde die Menge an Informationen,
00:00:51die sich das Modell auf einmal merken kann.
00:00:53Alles,
00:00:53was aus dem Kontextfenster des Modells verschwindet,
00:00:55verlässt seinen Arbeitsspeicher,
00:00:57und es hat keine Möglichkeit,
00:00:58es abzurufen.
00:00:59Modelle haben ein begrenztes Kontextfenster.
00:01:00Zum Beispiel haben Anthropic-Modelle ein Kontextfenster von 200.000 Token und Gemini-Modelle haben 1 Million.
00:01:06Auch wenn diese wie wirklich große Zahlen in Bezug auf die Nachrichten aussehen mögen,
00:01:10die du sendest,
00:01:10sind sie tatsächlich gar nicht so riesig,
00:01:12denn in diesen KI-Tools besteht das Kontextfenster nicht nur aus deinem System-Prompt und Benutzernachrichten,
00:01:17sondern enthält auch viele andere Dinge wie deine vergangenen Nachrichten,
00:01:21Speicherdateien,
00:01:21Tools,
00:01:22MCP-Aufrufe und so weiter.
00:01:23Du musst lernen,
00:01:24wie du das Beste aus diesem begrenzten Arbeitsbereich herausholst,
00:01:27damit das Modell genau das tut,
00:01:28was du willst,
00:01:29wenn du deine Workflows erstellst.
00:01:30Ich werde Claude Code als mein primäres Coding-Tool im gesamten Video verwenden,
00:01:34aber du kannst deinen Workflow mit jeder Plattform erstellen,
00:01:37da sie alle die für diese Prinzipien benötigten Tools haben.
00:01:39Das wichtigste Prinzip und der Schlüssel zu jedem Workflow-Design ist die progressive Offenlegung.
00:01:44Das bedeutet,
00:01:44dem LLM nur das zu zeigen,
00:01:46was wichtig ist,
00:01:46und die Aufmerksamkeit des Modells auf das zu konzentrieren,
00:01:49was tatsächlich gerade jetzt benötigt wird,
00:01:51anstatt das Kontextfenster mit allem zu füllen,
00:01:53was es in Zukunft brauchen könnte.
00:01:54Nun,
00:01:55fortgeschrittenere Modelle wie Sonnet 4.5 haben eine Kontextbearbeitungsfunktion eingebaut,
00:01:59mit der sie verstehen können,
00:02:01was Rauschen ist,
00:02:02und versuchen,
00:02:02es selbst herauszufiltern,
00:02:04und sie verwenden grep-Befehle,
00:02:05um einzugrenzen,
00:02:06was du willst.
00:02:07Aber das allein ist nicht genug.
00:02:08Wenn wir vage Anweisungen geben,
00:02:10laden selbst diese neueren Modelle viele Dinge,
00:02:12die nicht benötigt werden,
00:02:13und verschmutzen das Fenster.
00:02:14Anstatt Claude zu bitten,
00:02:16den Fehler in deinem Backend zu beheben,
00:02:17ist es besser,
00:02:18es zu bitten,
00:02:19die Endpunkte einzeln zu überprüfen,
00:02:20anstatt es zu bitten,
00:02:21alles auf einmal zu beheben.
00:02:23Die Skills-Funktion in Claude ist jetzt Open Source und alle Tools können sie nutzen.
00:02:27Skills sind so ziemlich die Verkörperung der progressiven Offenlegung.
00:02:29Ihre Beschreibung liefert gerade genug Informationen,
00:02:32damit deine KI-Coding-Plattform weiß,
00:02:34wann jeder Skill verwendet werden sollte,
00:02:36ohne alles in den Kontext zu laden.
00:02:38Ein großer Fehler,
00:02:38den Menschen machen,
00:02:39ist,
00:02:40MCPs für alles zu verwenden.
00:02:41Du solltest MCPs nur verwenden,
00:02:42wenn externe Daten erforderlich sind,
00:02:44und Skills für alles andere verwenden.
00:02:46Das zweite ebenso wichtige Prinzip ist,
00:02:48dass Informationen,
00:02:49die gerade nicht benötigt werden,
00:02:50nicht ins Kontextfenster gehören.
00:02:52Um dies zu erreichen,
00:02:53verwenden die Tools strukturierte Notizen.
00:02:55Und wir können dies zu unserem Vorteil nutzen,
00:02:57indem wir deinem KI-Tool externe Dateien zur Verfügung stellen,
00:02:59die es verwenden kann,
00:03:00um Entscheidungen,
00:03:00Probleme oder technische Schulden zu dokumentieren.
00:03:03Dieser Ansatz ermöglicht es deinem Agenten,
00:03:05kritischen Kontext beizubehalten,
00:03:06der sonst verloren gehen könnte,
00:03:07wenn etwas wirklich Komplexes gebaut wird.
00:03:09Diese Tools haben auch eine Kompaktierungsfunktion,
00:03:12um das Kontextfenster zu verwalten.
00:03:13Und wenn der Kontext zurückgesetzt wird,
00:03:15musst du dich nicht nur auf die Kompaktierungszusammenfassung verlassen.
00:03:17Zum Beispiel kann dein Agent diese Notizen verwenden,
00:03:20um Kontext darüber zu erhalten,
00:03:21was bereits erledigt wurde und was noch zu tun ist.
00:03:23Dieser Ansatz ist besonders hilfreich für langfristige Aufgaben,
00:03:26die von Natur aus komplex sind.
00:03:28Du kennst vielleicht die agent.md.
00:03:30Es ist eine Standard-Kontextdatei,
00:03:32die alle Agenten lesen,
00:03:33bevor sie die Sitzung starten.
00:03:34Einige Agenten folgen diesem nicht und haben ihre eigene,
00:03:37wie die claud.md,
00:03:37und ich verwende sie,
00:03:38um den Agenten anzuleiten,
00:03:39wie die externen Dateien strukturiert sind und was in jede einzelne geschrieben werden soll.
00:03:44Manchmal pausieren diese Agenten zufällig mitten in einer lang laufenden Aufgabe.
00:03:47Dies geschieht häufig,
00:03:49weil der Kontext über 70 % seiner Grenze hinausgegangen ist.
00:03:52Hier kommt das Konzept des Aufmerksamkeitsbudgets ins Spiel.
00:03:55Dein Kontextfenster ist das,
00:03:56worauf das Modell achtet,
00:03:57während es die Ausgabe generiert.
00:03:59Wenn es über 70 % geht,
00:04:00muss sich das Modell mehr konzentrieren und die Wahrscheinlichkeit von Halluzinationen ist höher.
00:04:04Bei KI-Agenten hindert es sie daran,
00:04:06ihre Tools effektiv zu nutzen,
00:04:07und oft entscheiden sie sich einfach,
00:04:09sie zu ignorieren.
00:04:10Um dies zu lösen,
00:04:11gibt es mehrere integrierte Tools,
00:04:12die du verwenden kannst.
00:04:14Wie du bereits weißt,
00:04:14ermöglicht die Kompaktierung dem Modell,
00:04:16mit einer ordentlichen Zusammenfassung dessen,
00:04:18was passiert ist,
00:04:18als Ausgangs-Prompt und einem reduzierten Kontextfenster von vorne zu beginnen.
00:04:21Anstatt es also auf 90 % füllen zu lassen und die Auto-Kompaktierungsfunktion auszulösen,
00:04:25versuche,
00:04:26das Kontextfenster im Auge zu behalten und es selbst zu tun.
00:04:28Wenn du experimentierst,
00:04:29verwende Claudes eingebaute Rückspulfunktion,
00:04:31damit du die unnötigen Teile löschen kannst,
00:04:33anstatt sie fortzusetzen und Claude um Änderungen zu bitten.
00:04:36Du solltest auch das Kontextfenster löschen oder ein neues für jede neue Aufgabe starten,
00:04:40damit der vorherige Kontext das Modell nicht verlangsamt.
00:04:42Eine weitere Sache,
00:04:43die aus dem Prinzip der progressiven Offenlegung stammt,
00:04:46ist die Fähigkeit dieser Agenten,
00:04:47Aufgaben im Hintergrund auszuführen,
00:04:49ohne das Hauptkontextfenster zu verschmutzen.
00:04:51Unter-Agenten arbeiten in ihrem eigenen isolierten Kontextfenster und melden nur die Ausgabe an den Hauptagenten zurück.
00:04:57Dies ist besonders hilfreich,
00:04:58wenn man an Aufgaben arbeitet,
00:04:59die voneinander isoliert sind,
00:05:00weil dein Hauptkontextfenster davor geschützt ist,
00:05:02mit den Tool-Aufrufen und Suchen aufgebläht zu werden,
00:05:04die der Unter-Agent durchführt,
00:05:06wodurch sichergestellt wird,
00:05:07dass die Informationen in ihrer dedizierten Arbeitszone bleiben.
00:05:10Da diese Agenten im Hintergrund laufen,
00:05:11kannst du weiterhin mit deinem Hauptagenten interagieren und ihn an etwas arbeiten lassen,
00:05:15das tatsächlich deine Aufmerksamkeit erfordert.
00:05:17Wann immer ich etwas recherchiert haben möchte,
00:05:19wie die Regeln eines neuen Frameworks,
00:05:21mit dem ich arbeite,
00:05:21verwende ich einfach diese Unter-Agenten.
00:05:23Auf diese Weise sind ihre Tool-Aufrufe und Suchen isoliert und sie geben nur die Antwort an den Hauptagenten zurück.
00:05:29Wenn du das Prinzip der Notizen verstehst,
00:05:30solltest du auch wissen,
00:05:32welches Dateiformat du für welche Aufgabe verwenden solltest.
00:05:34Da diese Dateien unterschiedliche Formate haben,
00:05:36beeinflussen sie die Token-Anzahl und damit die Effizienz deines Workflows.
00:05:40YAML ist am Token-effizientesten,
00:05:41daher verwende ich es hauptsächlich für Datenbank-Schemas,
00:05:44Sicherheitskonfigurationen und API-Details.
00:05:46Die Einrückung hilft Modellen,
00:05:47Informationen richtig zu strukturieren.
00:05:49Markdown ist besser für Dokumentation wie deine claud.md,
00:05:52weil die Überschriftenebenen es dem Modell leicht machen,
00:05:54zwischen Abschnitten zu navigieren.
00:05:56XML ist speziell für Claude-Modelle optimiert.
00:05:59Anthropic erklärt,
00:06:00dass ihre Modelle feinabgestimmt sind,
00:06:02um diese Tags als Container und Trenner zu erkennen,
00:06:04was nützlich ist,
00:06:05wenn du unterschiedliche Abschnitte wie Einschränkungen,
00:06:07Zusammenfassungen oder visuelle Details hast.
00:06:10Andere Modelle bevorzugen im Allgemeinen Markdown und YAML gegenüber XML.
00:06:13Und schließlich JSON.
00:06:14Es ist am wenigsten Token-effizient wegen all der zusätzlichen Klammern und Anführungszeichen,
00:06:18daher verwende ich es nur für kleine Dinge wie Aufgabenzustände und empfehle es größtenteils nicht wirklich.
00:06:23Git ist eines der grundlegendsten Dinge,
00:06:25die man beim Programmierstart lernt.
00:06:26Wir haben einen weiteren Trend bei diesen Kontext-Workflows gesehen,
00:06:29bei dem die Leute tatsächlich den Git-Commit-Verlauf als Erinnerung für das Modell an den Fortschritt verwenden,
00:06:34der gemacht wurde,
00:06:35sei es im gesamten Projekt oder bei einer einzelnen Aufgabe.
00:06:37Selbst wenn du es nicht verwenden willst,
00:06:39um den Fortschritt zu speichern,
00:06:40solltest du diese Context-Engineering-Workflows im Allgemeinen in einem mit Git initialisierten Repository verwenden.
00:06:44Ein Context-Engineering-Workflow bedeutet,
00:06:46dass man dem Modell nicht erlaubt,
00:06:48alles auf einmal zu tun,
00:06:49sondern stattdessen geplante Schritte nacheinander abzuarbeiten.
00:06:51Wenn du an irgendeiner Stelle auf ein Problem stößt,
00:06:53ermöglicht dir Git zu kontrollieren,
00:06:55auf welche Version du zurücksetzen möchtest,
00:06:56und hilft dabei zu ermitteln,
00:06:57welche Änderung Probleme verursacht.
00:06:59Manche haben auch Parallelisierung mit Git-Worktrees implementiert.
00:07:02Ich habe auch zahlreiche Workflows gezeigt,
00:07:03bei denen Sub-Agenten in dedizierten Worktrees für parallele Arbeit arbeiten.
00:07:07Egal welchen Workflow du letztendlich erstellst,
00:07:09es wird immer Fälle geben,
00:07:10in denen du Anweisungen für gängige Verfahren wiederholst.
00:07:13Ein gutes Beispiel ist,
00:07:14wie du die KI-Tools bittest,
00:07:15Git-Commits durchzuführen oder deine Dokumentation zu aktualisieren.
00:07:18In fast allen diesen KI-Tools gibt es Möglichkeiten,
00:07:20deine am häufigsten wiederholten Prompts wiederzuverwenden.
00:07:22Ich nutze oft custom/commands in meinen eigenen Projekten,
00:07:25weil sie Claude im Grunde eine wiederverwendbare Anleitung geben.
00:07:28Ich verwende oft einen Catchup-Befehl,
00:07:30der Anweisungen enthält,
00:07:31wie ich Informationen außerhalb des Kontextfensters strukturiere,
00:07:33damit Claude weiß,
00:07:34wie es sich mit dem Projekt auf den neuesten Stand bringen kann,
00:07:37ohne jede Datei lesen zu müssen.
00:07:38Sie eignen sich auch gut dafür, Strukturen durchzusetzen.
00:07:40Damit meine Commits und Dokumentationen einem definierten Format folgen,
00:07:43verwende ich einen commit/command,
00:07:44der einer spezifischen Struktur folgt,
00:07:46wie Commit-Nachrichten geschrieben werden sollen und welche Pre-Commit-Checks vor dem Committen durchgeführt werden sollten.
00:07:51Auf diese Weise halten die /commands alles standardisiert,
00:07:53und ich muss Claude nicht immer wieder anweisen,
00:07:55Aufgaben auf die von mir bevorzugte Weise auszuführen.
00:07:58Wie du weißt,
00:07:58sollten MCPs immer dann verwendet werden,
00:08:00wenn externe Daten benötigt werden.
00:08:01Jira ist die am weitesten verbreitete Team-Management-Software.
00:08:04Wenn du Informationen aus Tickets abrufen möchtest,
00:08:06kannst du das Jira-MCP verwenden,
00:08:08damit es direkt auf Tickets zugreifen und Änderungen umsetzen kann.
00:08:11Ebenso verwende ich das Figma-MCP,
00:08:13um Claude Code mit dem Style Guide der App zu versorgen,
00:08:16den es dann zum Erstellen des Designs nutzt.
00:08:18Für Aufgaben,
00:08:19bei denen die eingebauten Fähigkeiten des Modells nicht ausreichen,
00:08:22sind MCPs unverzichtbar für die effiziente Interaktion mit externen Quellen.
00:08:25Du kannst diese MCPs direkt in deine /commands einbinden,
00:08:28sodass sie Teil deines gesamten Workflows werden.
00:08:31Damit sind wir am Ende dieses Videos angekommen.
00:08:32Wenn du den Kanal unterstützen und uns helfen möchtest,
00:08:35weiterhin solche Videos zu produzieren,
00:08:36kannst du das über den Super-Thanks-Button unten tun.
00:08:39Wie immer,
00:08:39danke fürs Zuschauen und wir sehen uns im nächsten Video.

Key Takeaway

Erfolgreiche KI-Programmierungs-Workflows basieren auf intelligentem Kontextmanagement durch progressive Offenlegung, strukturierte Notizen und spezifisch angepasste Prozesse statt vorgefertigter Frameworks.

Highlights

Progressive Offenlegung ist das wichtigste Prinzip im Workflow-Design - zeige dem LLM nur die aktuell relevanten Informationen

Kontextfenster-Management ist entscheidend: Bei über 70% Auslastung steigt die Halluzinationsgefahr und Agenten nutzen Tools ineffektiv

Skills sollten für interne Workflows verwendet werden, MCPs nur für externe Daten - ein häufiger Fehler ist MCPs für alles zu nutzen

Strukturierte Notizen in externen Dateien ermöglichen es, wichtigen Kontext zu bewahren ohne das Kontextfenster zu belasten

YAML ist am Token-effizientesten für Schemas und Konfigurationen, XML ist speziell für Claude-Modelle optimiert

Git-Commit-Verlauf dient als Gedächtnis für den Fortschritt und ermöglicht kontrolliertes Zurücksetzen bei Problemen

Custom Commands vermeiden Wiederholungen und standardisieren Prozesse wie Commits und Dokumentation

Timeline

Einführung: Problem mit vorgefertigten KI-Frameworks

Das Video behandelt KI-Coding-Frameworks wie Beemad und Speckit und erklärt, warum viele experimentelle Workflows nicht die erwarteten Ergebnisse liefern. Das Problem liegt nicht in schlechten Methoden, sondern darin, dass die Workflows nicht zum spezifischen Anwendungsfall passen. Bei der App-Entwicklung werden meist eigene Workflows erstellt statt vorgefertigte zu nutzen. Der Sprecher kündigt an, die fundamentalen Prinzipien zu erklären, die jedes Framework verwendet und die nötig sind, um eigene Workflows zu bauen.

Grundlagen des Kontextfensters

Das Kontextfenster wird als die Menge an Informationen definiert, die sich das Modell gleichzeitig merken kann - alles außerhalb ist nicht mehr abrufbar. Anthropic-Modelle haben 200.000 Token, Gemini-Modelle 1 Million Token Kontextfenster. Diese Zahlen erscheinen zwar groß, sind aber begrenzt, da das Kontextfenster nicht nur System-Prompts und Benutzernachrichten enthält, sondern auch vergangene Nachrichten, Speicherdateien, Tools und MCP-Aufrufe. Das Verwalten des Kontexts ist die Kernfunktion dieser Frameworks. Der Sprecher verwendet Claude Code als primäres Tool im Video, betont aber dass die Prinzipien für alle Plattformen gelten.

Progressive Offenlegung als Hauptprinzip

Progressive Offenlegung wird als wichtigstes Prinzip vorgestellt: dem LLM nur das Wichtige zeigen und die Aufmerksamkeit auf aktuell Benötigtes fokussieren, statt das Kontextfenster mit zukünftig möglicherweise nötigen Informationen zu füllen. Obwohl fortgeschrittene Modelle wie Sonnet 4.5 eingebaute Kontextbearbeitung und grep-Befehle nutzen, reicht das allein nicht aus. Bei vagen Anweisungen laden selbst neuere Modelle unnötige Dinge und verschmutzen das Fenster. Konkret sollte man Claude bitten, Backend-Endpunkte einzeln zu überprüfen, statt alles auf einmal zu beheben. Die Skills-Funktion in Claude verkörpert dieses Prinzip perfekt: ihre Beschreibungen liefern gerade genug Information, damit die Plattform weiß, wann Skills verwendet werden sollen, ohne alles in den Kontext zu laden.

Strukturierte Notizen und externe Dateien

Ein häufiger Fehler ist die übermäßige Nutzung von MCPs - sie sollten nur für externe Daten verwendet werden, Skills für alles andere. Das zweite wichtige Prinzip: Informationen, die aktuell nicht benötigt werden, gehören nicht ins Kontextfenster. Tools verwenden strukturierte Notizen, die man nutzen kann, indem man dem KI-Tool externe Dateien zur Verfügung stellt für Entscheidungen, Probleme oder technische Schulden. Dieser Ansatz ermöglicht es dem Agenten, kritischen Kontext beizubehalten, der bei komplexen Projekten sonst verloren ginge. Die Kompaktierungsfunktion verwaltet das Kontextfenster, und nach einem Kontext-Reset kann der Agent diese Notizen nutzen statt sich nur auf die Zusammenfassung zu verlassen. Dieser Ansatz ist besonders hilfreich für langfristige, komplexe Aufgaben.

Kontextdateien und Aufmerksamkeitsbudget

Die agent.md wird als Standard-Kontextdatei vorgestellt, die alle Agenten vor Sitzungsstart lesen (manche Agenten nutzen claud.md). Der Sprecher verwendet sie, um Agenten anzuleiten, wie externe Dateien strukturiert sind und was in jede geschrieben werden soll. Agenten pausieren oft mitten in lang laufenden Aufgaben, wenn der Kontext über 70% seiner Grenze geht - hier greift das Konzept des Aufmerksamkeitsbudgets. Das Kontextfenster ist das, worauf das Modell bei der Ausgabe-Generierung achtet. Über 70% muss sich das Modell mehr konzentrieren, die Halluzinationsgefahr steigt, und bei KI-Agenten können sie ihre Tools nicht mehr effektiv nutzen oder ignorieren sie komplett. Lösungen umfassen manuelle Kompaktierung statt Auto-Kompaktierung bei 90%, Claudes Rückspulfunktion zum Löschen unnötiger Teile, und das Starten neuer Kontextfenster für neue Aufgaben.

Sub-Agenten für isolierte Aufgaben

Sub-Agenten als Erweiterung der progressiven Offenlegung arbeiten in ihrem eigenen isolierten Kontextfenster und melden nur die Ausgabe an den Hauptagenten zurück. Dies ist besonders hilfreich bei voneinander isolierten Aufgaben, da das Hauptkontextfenster vor Tool-Aufrufen und Suchen des Sub-Agenten geschützt bleibt. Informationen bleiben in ihrer dedizierten Arbeitszone. Da Sub-Agenten im Hintergrund laufen, kann man weiterhin mit dem Hauptagenten interagieren und ihn an Aufgaben arbeiten lassen, die tatsächlich Aufmerksamkeit erfordern. Der Sprecher verwendet Sub-Agenten für Recherchen wie Framework-Regeln - ihre Tool-Aufrufe und Suchen sind isoliert und nur die Antwort wird an den Hauptagenten zurückgegeben.

Dateiformat-Effizienz für Workflows

Verschiedene Dateiformate beeinflussen die Token-Anzahl und damit die Workflow-Effizienz unterschiedlich. YAML ist am Token-effizientesten und wird hauptsächlich für Datenbank-Schemas, Sicherheitskonfigurationen und API-Details verwendet - die Einrückung hilft Modellen bei der Strukturierung. Markdown ist besser für Dokumentation wie claud.md, weil Überschriftenebenen dem Modell die Navigation zwischen Abschnitten erleichtern. XML ist speziell für Claude-Modelle optimiert, da Anthropic erklärt, dass ihre Modelle feinabgestimmt sind, diese Tags als Container und Trenner zu erkennen - nützlich für unterschiedliche Abschnitte wie Einschränkungen oder Zusammenfassungen. Andere Modelle bevorzugen generell Markdown und YAML gegenüber XML. JSON ist am wenigsten Token-effizient wegen zusätzlicher Klammern und Anführungszeichen und wird nur für kleine Dinge wie Aufgabenzustände empfohlen.

Git als Gedächtnis und Versionskontrolle

Git wird als eines der grundlegendsten Dinge beim Programmierstart beschrieben. Ein Trend bei Kontext-Workflows ist die Nutzung des Git-Commit-Verlaufs als Erinnerung für das Modell an den gemachten Fortschritt, sowohl im gesamten Projekt als auch bei einzelnen Aufgaben. Context-Engineering-Workflows sollten generell in einem mit Git initialisierten Repository verwendet werden. Ein solcher Workflow bedeutet, dem Modell nicht zu erlauben, alles auf einmal zu tun, sondern geplante Schritte nacheinander abzuarbeiten. Bei Problemen ermöglicht Git die Kontrolle, auf welche Version zurückgesetzt wird, und hilft ermitteln, welche Änderung Probleme verursacht. Manche haben auch Parallelisierung mit Git-Worktrees implementiert, wobei Sub-Agenten in dedizierten Worktrees für parallele Arbeit arbeiten.

Custom Commands für Wiederverwendbarkeit

Egal welcher Workflow erstellt wird, es gibt immer Fälle, in denen Anweisungen für gängige Verfahren wiederholt werden, wie Git-Commits oder Dokumentation-Updates. Fast alle KI-Tools bieten Möglichkeiten, häufig wiederholte Prompts wiederzuverwenden. Der Sprecher nutzt custom/commands in eigenen Projekten, weil sie Claude wiederverwendbare Anleitungen geben. Ein Catchup-Befehl enthält Anweisungen, wie Informationen außerhalb des Kontextfensters strukturiert sind, damit Claude sich mit dem Projekt auf den neuesten Stand bringen kann ohne jede Datei lesen zu müssen. Commands eignen sich auch gut, um Strukturen durchzusetzen: ein commit/command folgt einer spezifischen Struktur für Commit-Nachrichten und definiert Pre-Commit-Checks. So halten Commands alles standardisiert ohne Claude wiederholt anweisen zu müssen.

MCPs für externe Daten und Abschluss

MCPs sollten immer dann verwendet werden, wenn externe Daten benötigt werden. Jira wird als weitverbreitete Team-Management-Software genannt - das Jira-MCP ermöglicht direkten Zugriff auf Tickets und Umsetzung von Änderungen. Ebenso verwendet der Sprecher das Figma-MCP, um Claude Code mit dem Style Guide der App zu versorgen, der dann zum Erstellen des Designs genutzt wird. Für Aufgaben, bei denen die eingebauten Modell-Fähigkeiten nicht ausreichen, sind MCPs unverzichtbar für effiziente Interaktion mit externen Quellen. MCPs können direkt in custom/commands eingebunden werden und werden so Teil des gesamten Workflows. Das Video endet mit einem Hinweis auf den Super-Thanks-Button zur Unterstützung des Kanals.

Community Posts

View all posts