Wenn du zum ersten Mal mit Codex oder anderen Coding-Agenten arbeitest, hilft dir dieser Leitfaden, schneller bessere Ergebnisse zu erzielen. Er zeigt dir, wie du Codex in der CLI, der IDE-Erweiterung und der ChatGPT-Desktop-App effektiv einsetzt: vom Formulieren von Prompts über die Planung und die Prüfung der Ergebnisse bis hin zu MCP, Skills und geplanten Aufgaben.
Codex arbeitet am besten, wenn du es als Teil deines Teams einsetzt, seine Arbeitsweise anpasst und die Zusammenarbeit mit der Zeit verbesserst. Das bringt dir mehr, als Codex nur für einzelne Anfragen zu nutzen.
Gib Codex zunächst den passenden Kontext für die Aufgabe. Halte dauerhafte Anweisungen in AGENTS.md fest, passe die Konfiguration an deinen Arbeitsablauf an und binde externe Systeme über MCP an. Fasse wiederkehrende Arbeit in Skills zusammen und automatisiere Abläufe, sobald sie zuverlässig funktionieren.
Gut einsteigen mit Kontext und klaren Prompts
Codex kann dir schon mit einem unvollkommenen Prompt weiterhelfen. Oft reicht wenig Vorbereitung, um auch bei einem schwierigen Problem ein gutes Ergebnis zu erzielen. Du musst das Formulieren von Prompts also nicht erst beherrschen, um Codex sinnvoll zu nutzen. Klare Prompts machen die Ergebnisse aber zuverlässiger, besonders bei großen Codebasen oder Aufgaben, bei denen viel auf dem Spiel steht.
Wenn du in einem großen oder komplexen Repository arbeitest, hilft es vor allem, Codex den passenden Kontext zu geben und klar zu gliedern, was zu tun ist.
Ein guter Prompt beantwortet vier Fragen:
- Ziel: Was möchtest du ändern oder entwickeln?
- Kontext: Welche Dateien, Ordner, Dokumente, Beispiele oder Fehler sind für die Aufgabe relevant? Mit @ kannst du bestimmte Dateien als Kontext angeben.
- Vorgaben: Welche Standards, Architekturvorgaben, Sicherheitsanforderungen oder Konventionen soll Codex einhalten?
- Abschlusskriterien: Woran erkennst du, dass die Aufgabe erledigt ist? Müssen bestimmte Tests erfolgreich durchlaufen, soll sich ein Verhalten ändern oder darf sich ein Fehler nicht mehr reproduzieren lassen?
So kann sich Codex auf die vereinbarte Aufgabe beschränken, muss weniger Annahmen treffen und liefert Ergebnisse, die du leichter überprüfen kannst.
Verwende GPT-6.1 Sol, wenn das Modell für dein Konto und in deinem Client verfügbar ist. Beginne mit dem Reasoning-Aufwand, der in deinem Client voreingestellt ist. Wähle für GPT-6 Luna zunächst Hoch und für GPT-6 Astra Leicht (low in der Konfiguration). Passe den Reasoning-Aufwand je nach Aufgabe und Ergebnis an. Die verfügbaren Stufen findest du in der Modellübersicht.
- Niedrig für schnelle, klar abgegrenzte Aufgaben
- Mittel oder Hoch für komplexere Änderungen oder die Fehlersuche
- Sehr hoch für längere Aufgaben, bei denen der Agent eigenständig arbeitet und einen hohen Reasoning-Aufwand benötigt
Mit der Diktierfunktion der ChatGPT-Desktop-App kannst du schneller Kontext geben. Sprich einfach aus, was Codex tun soll, statt es einzutippen.
Schwierige Aufgaben zuerst planen
Wenn eine Aufgabe komplex, mehrdeutig oder schwer zu beschreiben ist, bitte Codex um einen Plan, bevor es mit dem Programmieren beginnt.
Diese Ansätze haben sich bewährt:
Nutze den Planungs-Modus: Für die meisten ist das die einfachste und wirksamste Option. In diesem Modus kann Codex Kontext zusammentragen, Rückfragen stellen und vor der Umsetzung einen fundierten Plan ausarbeiten. Mit /plan oder Umschalt+Tab schaltest du den Modus ein oder aus.
Bitte Codex, dir Fragen zu stellen: Wenn du schon eine grobe Idee hast, sie aber schwer in Worte fassen kannst, lass dich zuerst von Codex befragen. Bitte Codex, deine Annahmen zu hinterfragen und die Idee mit dir zu konkretisieren, bevor es Code schreibt.
Nutze eine Vorlage für PLANS.md: Für anspruchsvollere Arbeitsabläufe kannst du Codex so konfigurieren, dass es bei längeren oder mehrstufigen Aufgaben einer PLANS.md-Datei oder einer Vorlage für Ausführungspläne folgt. Einzelheiten findest du im Leitfaden zu Ausführungsplänen.
Anweisungen mit AGENTS.md wiederverwenden
Wenn sich bestimmte Anweisungen in deinen Prompts bewähren, musst du sie nicht jedes Mal neu eingeben. Dafür gibt es AGENTS.md.
AGENTS.md ist eine README-Datei in einem offenen Format für Agenten. Codex lädt sie automatisch in den Kontext. Hier kannst du am besten festhalten, wie Codex in einem Repository für dich und dein Team arbeiten soll.
Eine gute AGENTS.md beschreibt:
- den Aufbau des Repositorys und wichtige Verzeichnisse
- wie du das Projekt startest
- mit welchen Befehlen du Builds, Tests und Lint-Prüfungen ausführst
- welche Entwicklungskonventionen gelten und was das Team bei Pull Requests erwartet
- welche Einschränkungen gelten und was Codex unterlassen soll
- wann eine Aufgabe erledigt ist und wie sich das Ergebnis überprüfen lässt
Mit dem Slash-Befehl /init erstellst du in der CLI ein Grundgerüst für eine AGENTS.md im aktuellen Verzeichnis. Passe diese erste Fassung daran an, wie dein Team Code baut, testet, überprüft und ausliefert.
Du kannst AGENTS.md-Dateien auf mehreren Ebenen anlegen: eine globale AGENTS.md für persönliche Voreinstellungen in ~/.codex, eine Datei auf Repository-Ebene für gemeinsame Standards und weitere Dateien in Unterverzeichnissen für lokale Regeln. Gibt es näher an deinem aktuellen Verzeichnis eine spezifischere Datei, haben deren Anweisungen Vorrang.
Halte die Regeln konkret. Eine kurze, präzise AGENTS.md hilft mehr als eine lange Datei voller vager Regeln. Beginne mit den Grundlagen und ergänze Regeln erst, wenn dir wiederholt dieselben Fehler auffallen.
Wenn AGENTS.md zu umfangreich wird, halte die Hauptdatei knapp und verweise für Themen wie Planung, Codeüberprüfung oder Architektur auf separate Markdown-Dateien.
Wenn Codex denselben Fehler zweimal macht, bitte es, die Ursachen rückblickend zu analysieren, und aktualisiere AGENTS.md. So orientieren sich deine Anweisungen an konkreten Problemen aus der Praxis.
Codex für einheitliches Verhalten konfigurieren
Über die Konfiguration kannst du dafür sorgen, dass Codex in verschiedenen Sitzungen und Oberflächen einheitlich arbeitet. Du kannst etwa Voreinstellungen für das Modell, den Reasoning-Aufwand, den Sandbox-Modus, die Genehmigungsrichtlinie, Profile und das MCP-Setup festlegen.
Für den Einstieg hat sich folgende Aufteilung bewährt:
- Speichere persönliche Voreinstellungen in
~/.codex/config.toml(in der ChatGPT-Desktop-App unter Einstellungen > Konfiguration > config.toml öffnen). - Lege Einstellungen für das jeweilige Repository in
.codex/config.tomlfest. - Wenn du die CLI nutzt, überschreibe Einstellungen über die Befehlszeile nur im Einzelfall.
In config.toml legst du dauerhafte Einstellungen fest, etwa für MCP-Server, die Zusammenarbeit mehrerer Agenten und Feature-Flags. Abweichende Einstellungen für einzelne Profile stehen in separaten Dateien namens $CODEX_HOME/profile-name.config.toml.
Codex nutzt Sandboxing auf Betriebssystemebene. Zwei Einstellungen sind dabei entscheidend. Der Genehmigungsmodus legt fest, wann Codex deine Genehmigung für die Ausführung eines Befehls anfordert. Der Sandbox-Modus bestimmt, ob Codex im Verzeichnis lesen oder schreiben kann und auf welche Dateien der Agent zugreifen darf.
Wenn du zum ersten Mal mit Coding-Agenten arbeitest, beginne mit den Standardberechtigungen. Halte die Vorgaben für Genehmigungen und Sandboxing zunächst streng. Erweitere die Berechtigungen erst bei konkretem Bedarf und nur für vertrauenswürdige Repositorys oder bestimmte Arbeitsabläufe.
Die CLI, die IDE-Erweiterung und die ChatGPT-Desktop-App verwenden dieselben Konfigurationsebenen. Mehr dazu findest du in der Beispielkonfiguration.
Passe Codex frühzeitig an deine tatsächliche Arbeitsumgebung an. Qualitätsprobleme liegen häufig am Setup, etwa an einem falschen Arbeitsverzeichnis, fehlendem Schreibzugriff, ungeeigneten Modellvoreinstellungen oder fehlenden Tools und Konnektoren.
Zuverlässigkeit durch Tests und Reviews verbessern
Bitte Codex bei einer Änderung auch darum, bei Bedarf Tests zu erstellen, die relevanten Prüfungen auszuführen, das Ergebnis zu bestätigen und die Arbeit zu überprüfen, bevor du sie übernimmst.
Codex kann diesen Ablauf für dich übernehmen, wenn es deine Qualitätskriterien kennt. Halte sie im Prompt oder in AGENTS.md fest.
Dazu kann gehören:
- Tests für die Änderung schreiben oder aktualisieren
- die passenden Testsuiten ausführen
- Lint-Prüfungen, Formatierungsprüfungen oder Typprüfungen ausführen
- bestätigen, dass das tatsächliche Verhalten der Anforderung entspricht
- den Diff auf Fehler, Regressionen und riskante Muster prüfen
Blende in der ChatGPT-Desktop-App den Diff-Bereich ein, um Änderungen direkt lokal zu überprüfen. Klicke auf eine Zeile, um Feedback zu geben. Codex erhält es im nächsten Chat-Schritt als Kontext.
Mit dem Slash-Befehl /review kannst du Code auf verschiedene Arten überprüfen lassen:
- Änderungen wie bei einem Pull Request mit einem Basis-Branch vergleichen
- Änderungen überprüfen, für die du noch keinen Commit erstellt hast
- einen Commit überprüfen
- eigene Anweisungen für die Überprüfung verwenden
Wenn dein Team eine code_review.md pflegt und in AGENTS.md darauf verweist, kann Codex diese Anweisungen auch bei der Überprüfung befolgen. So kann das Team in verschiedenen Repositorys nach denselben Kriterien arbeiten, unabhängig davon, wer den Code beiträgt.
Codex sollte mehr tun, als Code zu generieren. Mit den passenden Anweisungen hilft es dir auch, den Code zu testen, Prüfungen auszuführen und ein Review durchzuführen.
Wenn du GitHub Cloud nutzt, kannst du Codex so einrichten, dass es Code Reviews für deine Pull Requests durchführt. Bei OpenAI überprüft Codex 100 % der Pull Requests. Du kannst automatische Reviews aktivieren oder mit einer Erwähnung von @Codex bei Bedarf ein Review auslösen.
Externen Kontext über MCP einbinden
Nutze MCP, wenn der Kontext, den Codex braucht, außerhalb des Repositorys liegt. So kann Codex auf die Tools und Systeme zugreifen, die du bereits verwendest, und du musst aktuelle Informationen nicht immer wieder in Prompts kopieren.
Das Model Context Protocol, kurz MCP, ist ein offener Standard, über den sich Codex mit externen Tools und Systemen verbinden lässt.
Nutze MCP, wenn:
- der benötigte Kontext außerhalb des Repositorys liegt
- sich die Daten häufig ändern
- Codex ein Tool verwenden soll, statt sich auf eingefügte Anweisungen zu stützen
- du dieselbe Integration für mehrere Personen oder Projekte brauchst
Codex unterstützt sowohl STDIO-Server als auch Streamable-HTTP-Server mit OAuth.
Öffne in der ChatGPT-Desktop-App Einstellungen > MCP-Server, um benutzerdefinierte und empfohlene Server zu sehen. Codex kann dir oft helfen, die benötigten Server zu installieren. Bitte es einfach darum. In der CLI kannst du mit dem Befehl codex mcp add auch eigene Server hinzufügen und dabei Namen, URL und weitere Details angeben.
Binde Tools dann an, wenn du sie für einen konkreten Arbeitsablauf brauchst. Du musst nicht gleich alle deine Tools verbinden. Beginne mit ein oder zwei Tools, die dir häufig wiederkehrende Handgriffe abnehmen, und ergänze bei Bedarf weitere.
Wiederkehrende Arbeit in Skills zusammenfassen
Sobald du einen Arbeitsablauf wiederholen kannst, brauchst du dafür keine langen Prompts oder mehrere Gesprächsrunden mehr. Bündle in einem Skill die Anweisungen in einer SKILL.md-Datei sowie den Kontext und die ergänzende Logik, die Codex jedes Mal anwenden soll. Skills funktionieren in der CLI, der IDE-Erweiterung und der ChatGPT-Desktop-App.
Beschränke jeden Skill auf eine Aufgabe. Beginne mit zwei bis drei konkreten Anwendungsfällen und lege die Ein- und Ausgaben fest. Beschreibe, was der Skill tut und wann er zum Einsatz kommen soll. Nenne dabei typische Formulierungen, mit denen jemand die Aufgabe tatsächlich anfordern würde.
Du musst nicht gleich jeden Ausnahmefall abdecken. Beginne mit einer typischen Aufgabe. Wenn der Ablauf gut funktioniert, mache daraus einen Skill und verbessere ihn nach und nach. Füge Skripte oder zusätzliche Ressourcen nur hinzu, wenn sie den Ablauf zuverlässiger machen.
Als Faustregel gilt: Wenn du immer wieder denselben Prompt verwendest oder denselben Arbeitsablauf korrigierst, lohnt sich dafür wahrscheinlich ein Skill.
Skills eignen sich besonders für wiederkehrende Aufgaben wie:
- Logs sichten und Probleme einordnen
- Versionshinweise entwerfen
- Pull Requests anhand einer Checkliste überprüfen
- Migrationen planen
- Telemetriedaten oder Vorfälle zusammenfassen
- typische Abläufe zur Fehlersuche durchführen
Mit dem Skill $skill-creator erstellst du am besten das Grundgerüst für die erste Version deines Skills. Entwickle diese Version zunächst lokal weiter. Sobald der Skill für einen größeren Kreis einsatzbereit ist, kannst du ihn als Plugin verpacken. Einer der wichtigsten Bestandteile eines Skills ist seine Beschreibung. Sie sollte erklären, was der Skill tut und wann er zum Einsatz kommen soll.
Persönliche Skills liegen in $HOME/.agents/skills. Gemeinsame Skills kannst du im Repository unter .agents/skills einchecken. Das erleichtert neuen Teammitgliedern den Einstieg.
Geplante Aufgaben für wiederkehrende Arbeit nutzen
Sobald ein Arbeitsablauf zuverlässig funktioniert, kannst du festlegen, wann Codex ihn im Hintergrund ausführt. Für geplante Aufgaben wählst du in der ChatGPT-Desktop-App das Projekt, den Prompt, das Ausführungsintervall und die Umgebung aus.
Erstelle auf der Seite Geplant eine geplante Aufgabe. Wähle das Projekt, den Prompt und das Ausführungsintervall aus. Lege fest, ob die Aufgabe in einem eigenen Git-Worktree oder in deiner lokalen Umgebung laufen soll. Der Prompt kann Skills aufrufen. Mehr dazu erfährst du im Abschnitt zu Git-Worktrees.
Dafür eignen sich zum Beispiel folgende Aufgaben:
- die letzten Commits zusammenfassen
- Code nach möglichen Fehlern durchsuchen
- Versionshinweise entwerfen
- fehlgeschlagene CI-Läufe prüfen
- Zusammenfassungen für Stand-ups erstellen
- wiederkehrende Analysen nach einem Zeitplan ausführen
Als Faustregel gilt: Skills legen fest, wie eine Aufgabe abläuft. Geplante Aufgaben bestimmen, wann sie ausgeführt wird. Wenn du einen Ablauf noch häufig korrigieren musst, erstelle zuerst einen Skill dafür. Sobald der Ablauf vorhersehbar ist, kann dir die zeitgesteuerte Ausführung Arbeit abnehmen.
Nutze geplante Aufgaben auch, um deine Arbeitsweise zu überprüfen und zu pflegen. Sieh dir die letzten Chats an, fasse wiederkehrende Schwierigkeiten zusammen und verbessere nach und nach deine Prompts, Anweisungen oder die Konfiguration deiner Arbeitsabläufe.
Längere Chats organisieren
In einem Chat kommen mit der Zeit immer mehr Kontext, Entscheidungen und Aktionen zusammen. Wie du deine Chats organisierst, wirkt sich daher deutlich auf die Qualität der Ergebnisse aus.
In der ChatGPT-Desktop-App kannst du Chats anheften und Worktrees erstellen. Wenn du die CLI verwendest, sind diese Slash-Befehle besonders hilfreich:
- Mit
/experimentalschaltest du experimentelle Funktionen ein oder aus und trägst sie in deineconfig.tomlein. - Mit
/resumesetzt du einen gespeicherten Chat fort. - Mit
/forkstartest du einen neuen Chat und behältst den ursprünglichen Chatverlauf bei. - Mit
/compactlässt du den bisherigen Kontext zusammenfassen, wenn der Chat lang wird. Codex fasst Chats auch automatisch zusammen. - Mit
/subagentswechselst du zwischen den Threads der Subagenten im aktuellen Chat. - Mit
/themewählst du ein Farbschema für die Syntaxhervorhebung aus. - Mit
/appsnutzt du ChatGPT-Apps direkt in Codex. - Mit
/statussiehst du den aktuellen Sitzungsstatus.
Nutze für jede zusammenhängende Aufgabe einen eigenen Chat. Solange du am selben Problem arbeitest, lohnt es sich meist, im selben Chat zu bleiben. So bleiben die bisherigen Überlegungen nachvollziehbar. Forke den Chat erst, wenn sich die Arbeit tatsächlich in getrennte Aufgaben aufteilt.
Mit Subagenten kannst du klar abgegrenzte Aufgaben aus dem Haupt-Thread auslagern. Der Hauptagent kann sich so auf das Kernproblem konzentrieren, während Subagenten etwa das Repository erkunden, Tests ausführen oder Probleme einordnen.
Häufige Fehler
Vermeide beim Einstieg in Codex diese häufigen Fehler:
- Den Prompt mit dauerhaften Regeln überladen, statt sie in
AGENTS.mdoder einem Skill festzuhalten. - Dem Agenten keine genauen Hinweise zur Ausführung der Build- und Testbefehle geben, sodass er seine Arbeit nicht selbst überprüfen kann.
- Bei mehrstufigen und komplexen Aufgaben die Planung überspringen.
- Codex Vollzugriff auf deinen Computer geben, bevor du den Arbeitsablauf verstehst.
- Mehrere Aufgaben gleichzeitig an denselben Dateien ausführen, ohne Git-Worktrees zu verwenden.
- Eine wiederkehrende Aufgabe zeitgesteuert ausführen lassen, bevor sie bei manueller Ausführung zuverlässig funktioniert.
- Codex bei jedem Schritt beobachten, statt es parallel zu deiner eigenen Arbeit einzusetzen.
- Einen einzigen Chat für ein ganzes Projekt nutzen, statt für jedes klar abgegrenzte Ergebnis einen eigenen Chat zu führen. Dadurch wächst der Kontext unnötig an und die Ergebnisse werden mit der Zeit schlechter.