So meistern Sie Codex im Jahr 2026 (Kurs für Entwickler)

Ich habe Claude Code 12 Monate lang genutzt. Dann bin ich für 30 Tage zu Codex gewechselt.

Das habe ich herausgefunden

Was Codex im Jahr 2026 tatsächlich ist

Die meisten denken immer noch, Codex sei eine intelligentere Autovervollständigung. Das ist es nicht.

Codex ist eine vollständige agentische Softwareentwicklungsplattform. Sie liest deine Codebasis, schreibt und testet Code, reviewt Pull Requests, steuert deinen Mac-Desktop, surft im Web, generiert Bilder, plant wiederkehrende Aufgaben und merkt sich deine Präferenzen über Sitzungen hinweg.
Die mentale Umstellung, die das erfordert, ist beträchtlich. Du hörst auf, die Person zu sein, die Code schreibt. Du wirst zur Person, die Code reviewt, der von einem Junior-Entwicklerteam geschrieben wurde, das nie schläft.

Die meisten Entwickler installieren Codex, senden zwei Wochen lang Einzeiler-Prompts, erzielen mittelmäßige Ergebnisse und geben auf. Sie richten niemals AGENTS.md ein.

Sie schreiben nie eine Skill. Sie nutzen nie Sub-Agenten. Sie verwenden 5 % der Oberfläche und beurteilen das Tool anhand dieser 5 %.

Dieser Kurs behandelt die anderen 95 %.

Die fünf Oberflächen

Bevor du etwas installierst, verstehe, wo Codex lebt. Die von dir gewählte Oberfläche bestimmt, wie genau du seiner Arbeit folgst und wo der Code ausgeführt wird.

CLI ist für skriptgesteuerte Workflows, Einzelaufgaben und unbeaufsichtigte Automatisierung. Dein Code verlässt deinen Rechner nie, es sei denn, du pushst ihn. Open Source, in Rust entwickelt, läuft auf macOS, Windows und Linux.

IDE-Erweiterung ist für interaktives Bearbeiten mit präzisem Dateikontext. Installiert in VS Code, Cursor, Windsurf oder JetBrains. Verwendet deine CLI-Authentifizierung ohne separaten Login.

Desktop-App ist die Heimat von Multi-Thread-Workflows, dem In-App-Browser, Computer Use, Goal-Modus, Appshots und Automatisierungen. Gestartet auf macOS im Februar 2026 und auf Windows am 4. März 2026.

Cloud ist für asynchrone Hintergrundaufgaben, parallele PRs und Arbeiten, während du schläfst. Aufgaben laufen in sandboxed Containern, die mit deinem GitHub-Repo vorausgeladen sind. Nichts blockiert deinen lokalen Rechner.

In-App-Browser und Computer Use sind für UI-Verifikation, Frontend-Iteration und End-to-End-Tests. Codex öffnet deinen lokalen Dev-Server, interagiert damit, macht Screenshots vom Ergebnis und überprüft, ob die Code-Änderungen die korrekte visuelle Ausgabe erzeugt haben.

Ein echter Workflow verwendet mehrere Oberflächen:

CLI für skriptgesteuerte Dinge
IDE für interaktive Feature-Arbeit
Cloud für parallele Aufgaben, die du nicht überwachen musst
App für zielgetriebene, lang laufende Aufgaben

Der Hauptfaktor bei der Wahl einer Oberfläche ist, wie genau du der Arbeit des Agenten folgen möchtest. Wenn du Änderungen überwachen möchtest, während sie gemacht werden, belassen CLI oder IDE die Arbeit auf deinem Rechner und vor deinen Augen. Wenn du lieber eine längere Sitzung delegieren und am Ende überprüfen möchtest, ist Cloud die richtige Wahl.

Das mentale Modell: Agent, nicht Autovervollständigung

Nachdem die Oberflächen klar sind, geht es als nächstes um das Verständnis der Arbeitseinheit.

Die Arbeitseinheit ist eine Aufgabe, nicht eine Runde. Die Ausgabe ist ein PR, nicht eine Chat-Antwort.

Denke weniger „Schreibe eine Funktion, die X tut“ und mehr „Implementiere Feature Y, hier sind die Randbedingungen, führe die Tests aus, wenn du fertig bist“.

Jede Codex-Aufgabe folgt derselben internen Schleife. Codex liest deine Aufgabe und den Kontext, erstellt einen internen Plan, führt Schritt für Schritt aus und überprüft seine eigene Arbeit.

Hör auf, Codex als Code-Assistenten zu betrachten. Fang an, es als ein Junior-Entwicklerteam zu sehen, das du morgens einweist und nachmittags reviewst.

Ein reales Beispiel dafür in der Praxis: Entwickler bei WorkOS stellen jetzt vier bis fünf Codex-Aufgaben in die Warteschlange, bevor sie ihren Morgenkaffee holen. Wenn sie sich wieder hinsetzen, warten zwei bis drei fertige PRs auf Review, die die Wartungsarbeit erledigen, die früher 30 bis 40 Prozent ihres Tages verschlungen hat.

Die aktuellen Modelle (Stand Mai 2026):

GPT-5.5 (Standard) – erledigt die meisten Aufgaben, gleiche Latenz wie zuvor, aber deutlich weniger Tokens für die gleiche Arbeit
GPT-5.3-Codex – speziell für lange autonome Läufe, große Refactorings und parallele Cloud-Ausfächerung gebaut; 25 % schneller als der vorherige Codex-Spezialist
GPT-5.5 Pro – höchste Reasoning-Fähigkeit; nur Pro-, Business- und Enterprise-Pläne
Codex Mini – dauerhaft kostenlos auf ChatGPT Free; geeignet zum Lernen

Lass Codex standardmäßig auf GPT-5.5. Wechsel zu GPT-5.3-Codex für große agentische Aufgaben, bei denen Codex lange autonom läuft.

Erste Schritte: Deine erste echte Sitzung

Der schnellste Weg zu einer funktionierenden Codex-Sitzung folgt fünf Schritten. Vergiss das Fizzbuzz-Tutorial. Starte mit einer echten Codebasis.

Schritt 1: Installiere die CLI.

Schritt 2: Öffne ein echtes Projekt.

Navigiere zu einem risikoarmen Repository, das du bereits gut kennst. Das ist wichtig.

Codex funktioniert besser, wenn du die Ausgabe erkennen und Fehler bemerken kannst. Die erste Sitzung mit einer unvertrauten Codebasis führt zu unvorhersehbaren Ergebnissen.

Melde dich mit deinem ChatGPT-Konto an, wenn du dazu aufgefordert wirst. Dein Browser öffnet sich automatisch. Klicke auf „Weiter“ und kehre zum Terminal zurück.

Schritt 3: Führe /init aus, bevor du irgendetwas anderes tust.

Diesen einzelnen Befehl überspringen die meisten Tutorials. Codex durchsucht dein Verzeichnis und deine Git-Historie, identifiziert Sprachen, Frameworks, Build- und Testbefehle und erstellt eine AGENTS.md-Datei mit dem, was es findet.

Überprüfe die generierte Datei, korrigiere alles, was falsch ist, und committe sie. Jede zukünftige Codex-Sitzung in diesem Projekt wird sie automatisch lesen.

Schritt 4: Gib Codex eine Orientierungsaufgabe.

Bitte es, die Codebasis zu erklären, bevor du ihm etwas zu ändern gibst. Das schafft Vertrauen in den Kontext, den es geladen hat:

Lies die Ausgabe. Wenn sie deine tatsächliche Codebasis genau beschreibt, hat es den benötigten Kontext. Wenn sie vage oder falsch ist, muss deine AGENTS.md detaillierter sein.

Schritt 5: Gib ihm eine kleine, echte Aufgabe. Wähle etwas Konkretes und Abgegrenztes.

Das ist die richtige Form eines Codex-Prompts: spezifischer Dateikontext, erwartetes Ergebnis, Randbedingungen und ein definierter Verifikationsschritt. Überprüfe den Diff, den es zurückgibt. Du verwendest Codex jetzt richtig.

Schritt 6: Installiere die Desktop-App. Lade sie von der OpenAI-Website herunter. Melde dich mit demselben ChatGPT-Konto an.

Schritt 7: Installiere die IDE-Erweiterung. Suche im Erweiterungsfenster deines Editors nach „OpenAI Codex“. Es liest deine CLI-Authentifizierung automatisch.

Schritt 8: Verbinde GitHub. Gehe in der Codex-App zu Einstellungen und verbinde dein GitHub-Konto. Verknüpfe mindestens ein Repository, bevor du Cloud-Aufgaben verwendest.

Wo die Dinge liegen:

~/.codex/config.toml: Hauptkonfiguration: Genehmigungsmodus, Sandbox-Modus, MCP-Server, Standardmodelle
~/.codex/AGENTS.md: persönliche AGENTS.md, gilt für alle Projekte
<projekt>/AGENTS.md: projektbezogene Anweisungen
<projekt>/.agents/skills/: projektbezogene Skills
<projekt>/.codex/config.toml: projektspezifische Konfiguration (nur vertrauenswürdige Projekte)

AGENTS.md: Die wichtigste Datei in deinem Repo

Nachdem du nun eine funktionierende Sitzung hast, besteht der nächste Schritt darin, sicherzustellen, dass jede zukünftige Sitzung mit der gleichen Qualität beginnt. Das macht AGENTS.md.

AGENTS.md ist die einzelne Datei, die mittelmäßige Codex-Ausgabe von konsistenter, hochwertiger Ausgabe trennt.
Es ist eine einfache Markdown-Datei im Stammverzeichnis deines Repos. Jedes Mal, wenn eine Codex-Sitzung in deinem Projekt startet, liest der Agent sie automatisch, bevor er irgendetwas anderes tut.
Es ist ein offener Standard. Codex, Cursor, Gemini CLI, Windsurf und GitHub Copilot lesen sie alle. Schreibe sie einmal und jeder Agent in deinem Toolkit liest dieselbe Quelle der Wahrheit.

Auflösungsreihenfolge: Codex liest ~/.codex/AGENTS.md (Heimverzeichnis, alle Projekte) plus <projekt>/AGENTS.md (Projektebene). AGENTS.override.md-Dateien haben auf jeder Ebene Vorrang. Kombiniertes Limit: 32 KiB.

Was hineingehört:

Stack, Frameworks, Sprachversionen, Paketmanager
Exakte Build-, Test- und Dev-Befehle; kopierbar, nicht „führe die üblichen Tests aus“
Dateistruktur-Konventionen und Namensregeln
Stil- und Musterregeln
Verbotene Zonen: Was nicht angefasst werden soll
Versandanforderungen: CI, PR-Konventionen, Bereitstellungsmechanismus

Was nicht hineingehört:

Geheimnisse oder Anmeldeinformationen (die Datei ist unter Versionskontrolle)
Vage Anleitungen („schreibe sauberen Code“ bedeutet einem Agenten nichts)
Dokumentation, die deine README dupliziert

Halte es unter 500 Wörtern. Überflüssiger Inhalt drängt nützlichen Kontext aus dem Arbeitsgedächtnis des Modells.

Eine funktionierende Vorlage:

Überprüfe, ob Codex sie liest: Fordere es auf, die aktuellen geladenen Anweisungen zusammenzufassen
Für große Monorepos platziere zusätzliche AGENTS.md-Dateien in Unterverzeichnissen.
Eine Datei unter packages/api/AGENTS.md hat Vorrang vor der Stammdatei für Aufgaben innerhalb dieses Pakets.
Führe codex trust . aus, um eine projektbezogene .codex/config.toml zu aktivieren. Dies verhindert, dass ein bösartig geklontes Repo Codex hinter deinem Rücken konfiguriert.

Die CLI im Detail

Nachdem AGENTS.md eingerichtet ist, besteht der nächste Schritt darin, die CLI selbst zu meistern. Die meisten Benutzer geben nur codex ein und verpassen die Befehle, die sie wirklich leistungsfähig machen.

Es gibt vier Befehle, die 95 % der täglichen Nutzung abdecken.

codex öffnet den interaktiven Modus für Erkundung, Iteration und Hin-und-Her-Gespräche mit deiner Codebasis.

codex exec „<task>“ führt Codex nicht-interaktiv aus. Es streamt nach stdout und beendet sich, wenn es fertig ist. Das ist das Werkzeug für alles Skriptbare:

Binde exec in Git-Hooks, CI-Pipelines und Cron-Jobs ein. Es ist der Baustein für alles Automatisierte.

codex resume --last setzt genau dort fort, wo du aufgehört hast. Jede Sitzung wird gespeichert:

codex cloud verwaltet asynchrone Cloud-Aufgaben, die im Cloud-Abschnitt unten behandelt werden.

Nützliche Flags:

--json: JSONL-Ereignisstrom zur Weiterleitung an andere Tools
--model <name>: GPT-5.5 oder GPT-5.3-Codex auswählen
--reasoning <stufe>: low, medium oder high
--search: Websuche während der Aufgabe erlauben
-C <verz>: in einem anderen Arbeitsverzeichnis ausführen
--sandbox <modus>: Sandbox-Modus für diese Sitzung überschreiben
--approval <richtlinie>: Genehmigungsrichtlinie für diese Sitzung überschreiben

Sandbox und Genehmigungen

Die CLI gibt dir Kraft. Die Sandbox kontrolliert, wie viel dieser Kraft Codex ohne Nachfrage ausüben kann. Das richtig einzustellen hält deinen Workflow schnell, ohne Risiken zu schaffen.

Die Sandbox ist die Grenze, die kontrolliert, was Codex tun kann und was nicht. Die richtige Einstellung verhindert Überraschungen.

Die drei Sandbox-Modi:

workspace-write (Standard): Lesen und Schreiben innerhalb des Workspace, Routine-Befehle, kein Netzwerk, sofern nicht erlaubt. Verwende dies fast immer.
read-only: Nur lesen, keine Schreibvorgänge, keine Shell. Verwende für Code-Reviews und Erkundung.
danger-full-access: Keine Einschränkungen. Verwende fast nie. Hebe es für getestete, verifizierte Automatisierungen auf.

Die zwei Genehmigungsrichtlinien:

untrusted – fragt vor jedem nicht vertrauenswürdigen Befehl. Verwende beim Lernen oder in einem unvertrauten Projekt.
on-request (Standard) – genehmigt automatisch Routine-Befehle in der Sandbox, fragt vor allem, was die Sandbox-Grenze überschreitet.

auto_review ist ein Reviewer-Sub-Agent, der basierend auf deiner AGENTS.md automatisch genehmigt oder ablehnt.

Aktiviere es mit approvals_reviewer = "auto_review" in der Konfiguration. Funktioniert gut für lange asynchrone Aufgaben und den Goal-Modus, bei dem du nicht jeden Schritt beaufsichtigen möchtest.

Füge Befehle hinzu, die dich ständig um Genehmigung bitten. Füge niemals etwas Destruktives hinzu.

Codex effektiv prompten

Sandbox konfiguriert, Sitzungen laufen. Der nächste Hebel ist die Prompt-Qualität, die einen größeren Einfluss auf die Ausgabe hat als jede andere Variable.

Der größte einzelne Hebel für die Qualität der Codex-Ausgabe ist die Prompt-Struktur. Vage Prompts erzeugen vagen Code.

Das Framework: Sag, Zeig, Beschreib, Erinnere.

Sag ihm das gewünschte Ergebnis, nicht die Methode
Zeig ihm Beispiel-Eingaben und erwartete Ausgaben
Beschreib die APIs, Bibliotheken und Muster, die verwendet werden sollen
Erinnere es an Konventionen aus AGENTS.md

Nicht alle vier werden jedes Mal benötigt. Ein kleiner Bugfix braucht vielleicht nur Sag und Erinnere. Eine neue Funktion benötigt normalerweise alle vier.

Die Einzeländerungsregel: Codex funktioniert bei einer Sache dramatisch besser als bei fünf. „Repariere den Auth-Bug, füge Tests hinzu, refaktorisiere das User-Repo und aktualisiere die README“ ist ein Münzwurf. Die gleiche Arbeit auf vier Prompts verteilt ist zuverlässig.
Erzwinge bei allem Nichttrivialen zuerst einen Plan: „Erstelle zuerst einen Plan, schreibe erst Code, wenn ich genehmige.“ Dreißig Sekunden Planprüfung sind besser als dreißig Minuten Debuggen einer falschen Implementierung.
Gib das Fehlerverhalten explizit an. Wenn man es sich selbst überlässt, wird Codex Tests um jeden Preis bestehen lassen:

Beschränke den Kontext explizit. Nenne bestimmte Dateien zum Lesen. „Lies oder ändere nichts anderes. Wenn du Informationen von woanders brauchst, frage mich.“

Reasoning-Aufwandsstufen:

Low: triviale Änderungen, Formatierung, einfache Refactorings
Medium (Standard): die meisten Feature-Arbeiten und Bugfixes
High: Architekturentscheidungen, schwieriges Debugging, große Multi-File-Refactorings

Goal-Modus

Wenn sich das Prompten von Einzelaufgaben natürlich anfühlt, besteht die nächste Stufe darin, Codex ein mehrtägiges Ziel zu geben und es die Arbeit selbst sequenzieren zu lassen.

Der Goal-Modus ist für Arbeiten, die zu groß sind, um sie Aufgabe für Aufgabe zu besprechen, aber kohärent genug für ein einziges Ziel. Er wurde im Mai 2026 stabil.

Verwalte ein laufendes Ziel mit diesen Befehlen:

codex goal status: aktive Ziele und deren Fortschritt anzeigen
codex goal logs <id>: anzeigen, was Codex bisher getan hat
codex goal pause <id>: Ausführung anhalten und auf deine Eingabe warten
codex goal resume <id>: von der angehaltenen Stelle fortfahren
codex goal cancel <id>: stoppen und das Ziel verwerfen

Beginne mit begrenzten Zielen. „Maximal 5 PRs“, bis du vertraust, wie Codex deine Ziele interpretiert. Ein ausuferndes Ziel, das selbstbewusst das Falsche tut, ist der Worst-Case.

Begrenze immer mit: max PRs, max Codezeilen pro PR, CI-Gates zwischen PRs und klaren Abbruchbedingungen. Pausiere bei jeder Architekturentscheidung, die nicht in AGENTS.md abgedeckt ist. Pausiere bei jeder breaking API-Änderung.

Skills: Wiederverwendbare Workflows

Der Goal-Modus bewältigt große Initiativen. Skills bewältigen die sich wiederholenden Mikro-Workflows, die in jedem Projekt auftauchen. Wenn du feststellst, dass du dieselben Anweisungen über mehrere Sitzungen hinweg wiederholst, ist das dein Signal, eine Skill zu schreiben.

Eine Skill ist ein wiederverwendbarer Workflow, der als Verzeichnis gepackt ist: Anweisungen in einer SKILL.md-Datei plus optionale Ressourcen und Skripte.

Codex findet Skills nach Namen und Beschreibung. Es lädt die vollständigen Anweisungen nur, wenn eine Aufgabe die Skill auslöst. Du kannst 50 Skills haben, ohne Kontextkosten, bis eine ausgelöst wird.

Wo Skills leben:

Persönlich: $HOME/.agents/skills/: projektübergreifend, spiegelt wider, wie du unabhängig vom Repo arbeitest
Team: .agents/skills/ innerhalb des Repos: projektspezifisch, versioniert, mit Mitarbeitern geteilt

Das SKILL.md-Format:

Die drei Skills, die jeder Power-User zuerst schreiben sollte:

open-pr ist der Standard-PR-Workflow: Branch überprüfen, pushen, PR mit strukturiertem Body erstellen, Labels anwenden und Review anfordern. Die am häufigsten verwendete Skill im täglichen Arbeiten.
new-feature liest die PRD und AGENTS.md, identifiziert vorhandene Komponenten zur Wiederverwendung, gibt einen Plan aus, wartet auf Genehmigung, implementiert, testet und öffnet einen PR über die open-pr-Skill. Wenn etwas in der PRD mehrdeutig ist, fragt es, bevor es Code generiert.
investigate ist die „Diagnostizieren-ohne-Reparieren“-Skill. Sie bestätigt die Reproduktion, liest relevante Codepfade, bildet eine Hypothese („Ich glaube, X passiert, weil Y“) und gibt die Hypothese und den Validierungsplan als Markdown aus. Sie implementiert keine Lösung. Die Ausgabe ist Verständnis, nicht Code.

Die investigate-Skill ist wichtig, weil Codex die Ursachenanalyse jedes Mal überspringt, wenn du es lässt. Es wird direkt zu einer Lösung springen, und diese Lösung wird oft falsch sein. Die Durchsetzung von „Untersuchen zuerst“ ist die größte einzelne Verbesserung der Debugging-Ausgabequalität.

Überprüfe, ob deine Skills geladen sind: Verfügbare Skills auflisten

Sub-Agenten und Parallelisierung

Skills bewältigen deine wiederholbaren Workflows. Sub-Agenten bewältigen deine parallelen. Der Unterschied ist wichtig, weil falsch gemachte Parallelisierung mehr Probleme schafft als löst.

Ein Sub-Agent ist eine separate, isolierte Agenteninstanz. Er läuft in seinem eigenen Kontext, gibt eine Zusammenfassung zurück, und sein Kontext wird verworfen. Er unterscheidet sich von einer Skill, die im Kontext des Hauptagenten läuft.

Drei Muster, bei denen Sub-Agenten das richtige Werkzeug sind:

Erkundung: Einen Sub-Agenten starten, um 30 Dateien zu lesen und zusammenzufassen; das Lesen geschieht in seinem Kontext, nicht in deinem.
Parallele Implementierung: Fünf unabhängige Funktionen als fünf gleichzeitige Sub-Agenten, jeder mit eigenem Kontext und Plan.
Verifikation: Ein frischer Reviewer-Sub-Agent ist nicht voreingenommen, weil er gerade den Code geschrieben hat.

Benutzerdefinierte Sub-Agenten werden in .codex/agents/<name>.md definiert:

Sub-Agent-Adressierung wurde im März 2026 ausgeliefert. Sprich einen laufenden Sub-Agenten mit Spitznamen über @<spitzname> an.
Nützlich, wenn mehrere parallel laufen und du einen umleiten möchtest, ohne die anderen zu stören.
Das Fan-Out-Muster: N Sub-Agenten parallel auf unabhängigen Aufgaben starten und Ergebnisse zurückführen.
Fünf Aufgaben werden in der Zeit abgeschlossen, die der langsamste braucht. Faustregel: Wenn eine Aufgabe im Hauptkontext unter 30 Sekunden dauert, erledige sie einfach dort.

Die Desktop-App: Codex für alles

Sub-Agenten und Skills laufen gleichermaßen gut auf CLI, IDE-Erweiterung und Desktop-App. Aber die Desktop-App ist der Ort, an dem die Funktionen leben, die kein CLI-Äquivalent haben.

Das Update „Codex für (fast) alles“ vom 16. April 2026 verwandelte die Desktop-App von einem Codierungswerkzeug in eine vollständige Entwickler-Workstation.

Computer Use

Codex bedient deinen Mac: Klicken, Tippen, Scrollen, Apps öffnen, Menüs navigieren und neben dir laufen, ohne den Cursor-Fokus zu stehlen.

Der Killer-Anwendungsfall ist die Verhaltensverifikation. Unit-Tests bestehen, aber die UI ist immer noch kaputt.
Computer Use schließt diese Lücke, indem es Codex erlaubt, den Dev-Server zu öffnen, durch den relevanten Fluss zu klicken und das Ergebnis zu screenshoten.
Um es zu aktivieren, gehe zu Codex-Einstellungen, Computer Use, Installieren. Gewähre Bildschirmaufzeichnungs- und Eingabehilfen-Berechtigungen, wenn macOS dazu auffordert. Rufe es von jedem Prompt aus auf:

Gesperrter Computer Use erlaubt Codex, Desktop-Apps weiter zu bedienen, nachdem dein Bildschirm gesperrt ist. Aktiviere es in den Einstellungen unter Computer Use. Starte eine Aufgabe vor dem Schlafengehen, sperre deinen Rechner, überprüfe die Ergebnisse am Morgen.

Appshots

Drücke Befehl-Befehl und das vorderste macOS-Fenster geht direkt in deinen Codex-Thread.

Codex erfasst den Screenshot, den sichtbaren Text und den Eingabehilfetext; oftmals auch Inhalte, die außerhalb des Bildschirms gescrollt sind.

Ohne Appshots: Einen Fehler sehen, zu Codex wechseln, eine Frage eintippen, einen Screenshot machen, hineinziehen, mehr Kontext eintippen. Eine halbe Minute Reibung.
Mit Appshots: Den Fehler sehen, Befehl-Befehl drücken, deine Frage stellen. Fünf Sekunden.

Wenn du in den letzten 60 Sekunden mit einem Codex-Thread interagiert hast, geht der Appshot in diese Unterhaltung.

Andernfalls öffnet er einen neuen Thread. Mehrere Appshots in einer Sitzung stapeln sich in einem Thread. Erfordert Bildschirmaufzeichnungs- und Eingabehilfen-Berechtigungen.

Der In-App-Browser

Der In-App-Browser ist ein nativer agentischer Browser, keine Seitenvorschau. Er öffnet deinen lokalen Dev-Server, klickt, füllt Formulare aus, inspiziert den DOM-Zustand, erfasst Screenshots und überprüft, ob der gerade geschriebene Patch den visuellen Bug behoben hat.

Öffne einen lokalen Entwicklungsserver darin und füge dann natürliche Sprachkommentare direkt auf gerenderten Elementen hinzu.
Schreibe „mache diesen Button 20 Pixel höher“ auf das Element, und Codex führt die Änderung in deiner Codebasis aus und lädt die Seite neu.
Der In-App-Browser bietet direkten DOM-Zugriff ohne Fensterverwaltungs-Overhead und ist von deinem echten Browser abgesandboxt.

Memory

Memory erlaubt Codex, Kontext über Sitzungen hinweg zu behalten.

Nach jeder Sitzung fasst Codex die Interaktion zusammen und schreibt sie nach ~/.codex/memories/.
In der nächsten Sitzung liest es diese Dateien, bevor es deinen Prompt lädt.
Codex lernt dein bevorzugtes Commit-Nachrichtenformat, Test-Frameworks, Architekturmuster und die Fehler, die es letztes Mal gemacht hat, ohne dass du diesen Kontext wiederholen musst.
Aktiviere es in den Einstellungen oder füge memories = true unter [features] in config.toml hinzu.

Das Plugin-Ökosystem mit über 90 Plugins

Plugins sind kuratierte Bündel von Skills, MCPs und Integrationen. Installiere sie mit codex plugins install <name>.

Wichtige Plugin-Kategorien:

Projektmanagement: Linear, JIRA, GitHub
CI/CD: CircleCI, Vercel, GitHub Actions
Datenbanken: Neon, Postgres, PlanetScale
Codequalität: Sentry, CodeRabbit
Produktivität: Notion, Remotion

Installiere nur für Tools, die du täglich nutzt. Beschränke sie wenn möglich auf Projektebene. Überprüfe sie vierteljährlich. Jedes Plugin kostet Kontext-Token, egal ob du es nutzt oder nicht.

Codex Cloud: Asynchrone Arbeit in großem Maßstab

Die Desktop-App treibt deine lokale und interaktive Arbeit an. Cloud verwendest du, wenn die Arbeit zu groß für eine einzelne interaktive Sitzung ist oder wenn du mehrere Aufgaben parallel laufen lassen möchtest, während du dich auf etwas anderes konzentrierst.

Codex Cloud ist die Funktion, die Codex von einem schnellen Code-Assistenten in ein Junior-Entwicklerteam verwandelt, das horizontal skaliert.

Sende eine Aufgabe, Codex startet eine Sandbox, die mit deinem Repo vorausgeladen ist, arbeitet, führt Tests aus und eröffnet einen PR. Nichts blockiert deinen lokalen Rechner.

Senden einer einzelnen Aufgabe:

Parallele Aufgaben; das Kernmuster:

Zwanzig Minuten später sind vier PRs offen. Reviewen, priorisieren, mergen.

CSV-Fan-Out erlaubt es dir, eine Datei mit Aufgaben einzureichen, und Codex fächert sie als parallele Cloud-Agenten mit Fortschrittsverfolgung auf:

codex cloud durchsucht aktive und abgeschlossene Aufgaben. codex cloud apply <task-id> zieht Änderungen lokal, bevor du mergst.

GitHub-Integration

Cloud-Aufgaben landen in deinem Repo als PRs. Die GitHub-Integration bestimmt, wie diese PRs reviewed werden und wie Codex in deine bestehende CI/CD-Pipeline eingebunden wird.

Codex und GitHub integrieren sich auf drei Ebenen: Repository-Umgebungen, Pull-Request-Reviews und codex-action für CI/CD.

Repository-Umgebungen sind die Grundlage. Verknüpfe ein GitHub-Repository in den Codex-Einstellungen, und Cloud-Aufgaben klonen das Repo, führen Aufgaben in einem sandboxed Container aus und pushen das Ergebnis als Branch oder PR. AGENTS.md wird für jede Cloud-Aufgabe automatisch gelesen.

Pull-Request-Reviews funktionieren auf zwei Arten:

Erwähne @codex review in einem PR-Kommentar. Codex reagiert mit einem Augen-Emoji zur Bestätigung und postet dann ein strukturiertes Review, das sich auf schwerwiegende Probleme konzentriert, die anhand deiner AGENTS.md überprüft wurden.
Aktiviere Automatische Reviews, damit Codex bei jedem neuen PR ohne manuellen Auslöser postet.

Nachdem Codex ein Review gepostet hat, bitte es, die markierten Probleme direkt im PR-Kommentar-Thread zu beheben. Es committed die Lösung auf denselben Branch und aktualisiert den PR.

codex-action ist eine offizielle GitHub Action, die die Codex CLI in deiner CI/CD-Pipeline bei jedem Auslöser ausführt: Push, Zeitplan, Issue-Erstellung oder PR-Eröffnung. Dies ist die empfohlene Methode, um Codex in vollautomatische Pipelines zu integrieren, bei denen kein Mensch anwesend ist.

Automatisierungen: Unbeaufsichtigte Arbeit

Die GitHub-Integration kümmert sich darum, was passiert, wenn ein Mensch einen PR eröffnet. Automatisierungen kümmern sich darum, was passiert, wenn kein Mensch eingreifen muss.

Automatisierungen sind geplante Codex-Aufgaben, die in dedizierten Worktrees laufen. Richte sie über das Automatisierungen-Panel ein: Name, Projekt, Prompt, Zeitplan und Ausführungsumgebung.

Thread-Wiederverwendung wurde im April 2026 eingeführt. Automatisierungen können einen Thread über Läufe hinweg wiederverwenden, Kontext ansammeln und mit der Zeit intelligenter werden.

Drei Starter-Automatisierungen, die jedes Projekt haben sollte:

Wöchentliche Abhängigkeitsüberprüfung (Montag 6 Uhr): Führe pnpm outdated und pnpm audit aus. Melde kritische, große und kleine Erkenntnisse. Automatische PRs für sichere kleine und Patch-Upgrades. Greife kritische und große Updates nicht an; diese erfordern menschliche Entscheidungen.
Tägliches Sentry-Triage (Werktag 8 Uhr): Rufe die letzten 24 Stunden an Fehlern ab, gruppiert nach Fingerabdruck. Identifiziere für jede Gruppe mit 3 oder mehr Vorkommnissen die Datei und Zeile, lese relevanten Code und identifiziere die Ursache. Poste einen Triage-Bericht. Nur Diagnose, keine Lösungen.
Wöchentliche Bereinigung alter PRs (Freitag 17 Uhr): Liste offene PRs auf, die älter als 7 Tage sind. Bestimme für jeden, ob er auf dich wartet, auf Review wartet oder veraltet ist, und poste einen Erinnerungskommentar. Schließe oder merge nichts.

Stoppe jede Automatisierung, deren Ausgabe nicht mehr gelesen wird. Eine gute Automatisierung erspart eine wiederkehrende Aufgabe, die du auf jeden Fall ohnehin erledigen würdest, produziert eine einzige überfliegbare Ausgabe und führt keine zerstörerischen Aktionen unbeaufsichtigt durch.

MCP-Integration

Automatisierungen arbeiten mit dem, was in deinem Repo ist. MCP-Server erweitern Codex, um mit allem außerhalb davon zu arbeiten.

MCP (Model Context Protocol) ist der offene Spezifikation hinter Plugins. Verwende ein Plugin, wenn eines existiert. Verwende rohes MCP für benutzerdefinierte Integrationen mit internen Tools.

STDIO: Codex startet einen lokalen Prozess und kommuniziert über stdin/stdout. Deckt 95 % der Solo-Nutzung ab.
Streamable HTTP: Codex verbindet sich mit einem Netzwerk-Endpunkt. Wird für gehostete Team-MCPs verwendet.

Hinzufügen eines rohen MCP-Servers:

Oder direkt in ~/.codex/config.toml:

Konfiguriere tool-spezifische Genehmigungen: Lesevorgänge automatisch genehmigen, vor Schreibvorgängen nachfragen. Jeder MCP-Server fügt Tool-Definitionen zum Kontext von Codex hinzu, was Tokens kostet und die Aufmerksamkeit verwässert. Aktiviere nur das, was du wirklich nutzt.

Das Docker MCP Toolkit verbindet Codex mit über 220 vorgefertigten Servern mit einem Befehl: docker mcp-client configure codex

Mobile App

MCP-Server erweitern, was Codex erreichen kann. Die Mobile App erweitert, wo du Codex erreichen kannst.

Am 14. Mai 2026 ist Codex in der ChatGPT Mobile App auf iOS und Android verfügbar.

Mobile Codex ist eine Fernsteuerungs- und Überwachungsoberfläche, kein Code-Editor.

Der typische Anwendungsfall ist das Überprüfen einer lang laufenden Cloud-Aufgabe oder eines Goal-Mode-Laufs von deinem Telefon aus, während du nicht am Schreibtisch bist.

Von deinem Telefon aus kannst du:

Live-Läufe über Laptops, Devboxes oder verbundene Remote-Umgebungen verfolgen
Threads durchsuchen und zwischen parallelen Aufgaben wechseln
Diffs überprüfen, bevor sie in einen Branch gemergt werden
Befehle genehmigen oder ablehnen, die Codex auf deiner Hardware ausführen möchte
Das Modell während einer Aufgabe wechseln, wenn ein stärkeres benötigt wird
Neue Aufgaben von einem neuen Prompt aus oder direkt von einem GitHub-Issue starten
Einen von Codex erstellten Pull Request kommentieren

Zur Einrichtung aktualisiere ChatGPT auf das Release vom 13. Mai 2026 oder neuer, melde dich mit demselben Desktop-Konto an und stelle sicher, dass mindestens eine Cloud-Umgebung in den Einstellungen unter Codex, Umgebungen konfiguriert ist. Die Mobile App übernimmt automatisch alle vorhandenen Threads und verbundenen Hosts.

Der praktische Kreislauf, den dies ermöglicht: Starte morgens vor dem Verlassen des Hauses einen Goal-Mode-Lauf, überprüfe seinen Fortschritt auf dem Arbeitsweg, genehmige eine angehaltene Entscheidung von deinem Telefon aus und geh mit den ersten beiden bereits geöffneten PRs ins Büro.

Chrome-Erweiterung

Die Mobile App erweitert deine Reichweite. Die Chrome-Erweiterung erweitert die Reichweite von Codex in jede Website, bei der du bereits angemeldet bist.

Das bedeutet, sie kann auf authentifizierte Dienste zugreifen: LinkedIn, Salesforce, Gmail, Workday und jedes interne Tool, das eine Anmeldung erfordert.
Installiere sie, indem du in der Codex Desktop-App zu Plugins gehst, das Chrome-Plugin hinzufügst und der geführten Einrichtung folgst.
Die Erweiterung zeigt den Status Verbunden an, wenn sie aktiv ist. Rufe sie von einem beliebigen Codex-Thread auf:

Codex kann mehrere Chrome-Tabs über Sub-Agents in verschiedenen Threads steuern, wobei jeder Tab isoliert ist.

Ein großer Vorteil gegenüber Headless-Browser-Automation: Die Chrome-Erweiterung kann auf Webentwicklertools zugreifen. Codex kann das DOM inspizieren, Konsolenfehler lesen und Laufzeitprobleme in einer Live-Browser-Sitzung diagnostizieren. Funktioniert auf macOS und Windows.

Das Codex SDK

Die Chrome-Erweiterung kümmert sich um Browser-Automation. Das SDK kümmert sich um programmatische Automation; es bettet Codex als Infrastruktur in deine eigenen Anwendungen und Pipelines ein.

Das Codex SDK gibt Entwicklern programmatische Kontrolle über Codex aus ihren eigenen Anwendungen und CI-Pipelines.

Installiere das JavaScript SDK:

Grundlegende Nutzung:

Rufe run() erneut im selben Thread auf, um das Gespräch fortzusetzen. Setze einen gespeicherten Thread mit codex.resumeThread(threadId) fort.
Das Python SDK verwendet from codex_app_server import Codex. Übergib einen Modellnamen beim Start: thread = codex.thread_start(model="gpt-5.5").
Das SDK ist derzeit experimentell und erfordert eine lokale Codex CLI-Installation.
Es kommuniziert mit dem lokalen App-Server über JSON-RPC; es steuert denselben Agenten, mit dem du in der Desktop-App interagierst.

Verifikation: Wie man Codex-Ausgaben tatsächlich vertrauen kann

Alle oben genannten Oberflächen produzieren Ausgaben. Die Verifikation bestimmt, wie viel von dieser Ausgabe du tatsächlich ausliefern kannst.

Generierung ist gelöst. Verifikation ist der Engpass.

Fünf parallele Cloud-PRs sind fünf Chancen, einen Bug auszuliefern. Ohne eine Verifikationsschicht ist dein Durchsatz durch die Geschwindigkeit begrenzt, mit der du PRs lesen kannst.

Das Kernproblem ist Sykophantentum. Das Modell, das den Code geschrieben hat, ist voreingenommen und hält ihn für korrekt. Bittest du es, seine eigene Arbeit zu überprüfen, bekommst du meistens ein Daumen hoch.

Zwei strukturelle Lösungen:

auto_review (in-Codex) ist der integrierte Review-Sub-Agent von Codex. Frischer Kontext, keine Investition in die vorherige Ausgabe, viel wahrscheinlicher, echte Probleme zu erkennen.
Cross-Provider-Verifikation (Goldstandard) bedeutet, Codex schreibt und Claude Code reviewt. Cross-Provider erfasst blinde Flecken, die für eine Modellfamilie spezifisch sind. Dies ist die minimal lebensfähige Verifikationsgewohnheit für Produktionscode.

Computer Use für verhaltensorientierte Verifikation schließt die Lücke zwischen „Tests bestehen“ und „das Ding funktioniert tatsächlich“. Lass Codex den Dev-Server öffnen, den relevanten Flow durchklicken, einen Screenshot des Ergebnisses machen und es mit deinem PRD vergleichen.

Die minimal lebensfähige Gewohnheit bei jedem PR: Führe eine automatisierte Überprüfung mit einem anderen Modell durch, bevor du den Diff selbst öffnest. Lies zuerst die Zusammenfassung der Überprüfung. Öffne den Diff nur, wenn die Überprüfung sauber ist; lies dann nach Geschmack, nicht nach Korrektheit. Bei UI-Änderungen schau dir den Screenshot an.

Rezepte: Kampferprobte Muster

Verifikationsgewohnheiten etabliert, hier sind die End-to-End-Vorlagen für die Aufgaben, die Entwickler am häufigsten mit Codex ausführen.

Feature implementieren: Verwende die new-feature Skill. Lies das PRD und AGENTS.md. Plane zuerst, warte auf Genehmigung. Tests für den Happy Path und einen Fehlerfall. Wenn etwas unklar ist, frage nach, bevor du Code generierst.
Bug beheben: Verwende zuerst die investigate Skill. Nur diagnostizieren. Gib Reproduktionsschritte, Root-Cause-Hypothese und einen Validierungsplan aus. Nicht beheben, bis bestätigt.
Refaktorieren: Liste alle Stellen mit grep auf. Gib den Migrationsplan aus. Warte auf Genehmigung. Alle vorhandenen Tests müssen unverändert bestehen. Wenn ein Test aktualisiert werden muss, ist der Test falsch; stoppe und melde. Ein PR.
Drittanbieter-Integration: Kapsle in /lib/integrations/[name].ts. Füge Umgebungsvariablen zu .env.example hinzu. Keine UI in diesem PR. Als Entwurf öffnen für manuelle Tests gegen den externen Dienst.
Test-Backfill: Gib den Testplan aus, der Happy-, Edge- und Fehlerfälle abdeckt. Warte auf Genehmigung. Alle Tests müssen gegen den vorhandenen Produktionscode bestehen. Produktionscode nicht ändern.
Abhängigkeits-Upgrade: Lies die Release Notes zwischen den Versionen. Liste Breaking Changes auf. Warte auf Genehmigung. Aktualisiere und wende Code-Änderungen an. Führe Tests aus, bis sie sauber sind.
Goal-Mode-Initiative: Begrenze mit maximalen PRs, maximalen Codezeilen pro PR, CI-Gate zwischen PRs und klaren Stoppbedingungen. Pausiere bei architektonischen Entscheidungen, die nicht in AGENTS.md stehen. Pausiere bei jeder Breaking-API-Änderung.

Häufige Fehler

Diese Muster decken die häufigen Erfolge ab. Der Abschnitt unten deckt die häufigen Verluste ab; die zehn Fehler, die die meisten schlechten Codex-Erfahrungen erklären.

Vage Aufgaben. Benenne konkrete Ergebnisse, Dateien und Einschränkungen. Wenn du nicht spezifisch sein kannst, ist die Aufgabe nicht bereit für ein Briefing.

Kein AGENTS.md. Schreibe eins. Selbst ein schlechtes ist besser als keins.

Plan überspringen. „Erstelle zuerst einen Plan“ bei allem, was nicht trivial ist.

Multitasking-Prompts. Eine Aufgabe pro Prompt. Verwende Sub-Agents oder Cloud-Tasks für parallele Arbeit.

Mit danger-full-access starten. workspace-write und on-request sind die richtigen Standardeinstellungen für alles außer getesteten Automatisierungen.

Zu viele MCPs und Plugins. Halte die Liste schlank. Deaktiviere, was du nicht aktiv nutzt.

Selbst-Review. Verwende auto_review oder ein völlig anderes Tool. Das Modell, das den Code geschrieben hat, ist ihm gegenüber voreingenommen.

Compile-Erfolg als Korrektheit vertrauen. Füge verhaltensorientierte Verifikation hinzu. Verwende Computer Use für UI-Änderungen.

Zu viel Parallelisierung. Parallelisiere nur unabhängige Arbeiten. Gemeinsam genutzte Dateien müssen serialisiert werden.

Unbegrenzte Goals. Max PRs, maximale Codezeilen, maximale Zeit, klare Stoppbedingungen. Goal Mode ist am nützlichsten mit der Leine, die du einem Junior-Engineer geben würdest.

Kurzreferenz-Spickzettel

CLI-Befehle:

Wichtige Dateipfade:

Globale Konfiguration: ~/.codex/config.toml
Globales AGENTS.md: ~/.codex/AGENTS.md
Projekt-AGENTS.md: <repo-root>/AGENTS.md
Override-Datei: AGENTS.override.md
Memories: ~/.codex/memories/
Skills (persönlich): $HOME/.agents/skills/
Skills (Team): .agents/skills/ im Repository
Sub-Agents: .codex/agents/<name>.md

Die vierteilige Prompt-Struktur:

Erzähle: das Ergebnis, nicht die Methode
Zeige: Beispieleingaben und erwartete Ausgaben
Beschreibe: die zu verwendenden APIs, Bibliotheken und Muster
Erinnere: Konventionen aus AGENTS.md

Fazit

Nach 12 Monaten Nutzung von Claude war der Wendepunkt nicht ein schlechter Tag. Es war die Anhäufung von Rate Limits, Workflow-Reibung und einer Desktop-App-Erfahrung, die ständig im Weg stand.

Diese Frustration war es, die den Wechsel zu Codex vorangetrieben hat.

In den letzten 90 Tagen hat das tiefe Eintauchen in das OpenAI-Ökosystem eines klar gemacht: Codex fühlt sich als Arbeitsumgebung für ernsthafte Entwicklerworkflows vollständiger an.
Das agentische Modell ist stärker, die umgebenden Oberflächen sind breiter, und das System ist leichter zu vertrauen, sobald AGENTS.md, Skills, Cloud und Verifikationsschleifen eingerichtet sind.
Das bedeutet nicht, dass Claude Code keinen Wert hat. Es bedeutet, dass die Abwägungen keinen Sinn mehr ergaben.

Wenn Claude Code für deinen Workflow noch funktioniert, verwende es weiter. Aber wenn du Rate Limits, brüchige Sitzungen und Tools, die sich anfühlen, als würden sie gegen deinen Prozess kämpfen, leid bist, ist Codex jetzt gut genug, um einen ernsthaften Wechsel zu rechtfertigen.

Dieser Artikel wurde geschrieben, um diesen Wechsel einfacher zu machen.

Hoffe, es hat dir gefallen und du legst los ❤️

Haftungsausschluss

Dieser Artikel wurde vom Autor basierend auf seinen Notizen, Recherchen und persönlichen Erfahrungen verfasst und von einem KI-Modell (Sonnet 4.6) bearbeitet.

Das Thumbnail-Bild wurde von Pinterest übernommen und mit KI bearbeitet.