Codex-Prompting: Agentisches Codieren mit OpenAI meistern

title: "Codex-Prompting: Agentisches Codieren mit OpenAI meistern" slug: "codex-prompting-guide" date: "2026-03-19" lang: "de" source: "https://developers.openai.com/cookbook/examples/gpt-5/codex_prompting_guide/" category: "KI-Modelle" keywords:

• Codex
• Prompting-Leitfaden
• agentisches Codieren
• OpenAI API
• GPT-5
• KI-Entwicklung
• Codegenerierung
• Modelloptimierung
• Tool-Nutzung
• KI-Leistung
• Entwicklerwerkzeuge
• Migrationsstrategien meta_description: "Entfesseln Sie die Spitzenleistung der Codex-Modelle von OpenAI für agentisches Codieren. Dieser Leitfaden behandelt fortgeschrittene Prompting-Strategien, Tool-Integration und Best Practices für die Migration, um Codex zu meistern." image: "/images/articles/codex-prompting-guide.png" image_alt: "Visuelle Darstellung des OpenAI Codex-Modells bei der Interaktion mit Code, die agentisches Codieren und fortgeschrittene Prompting-Strategien für Entwickler illustriert." quality_score: 94 content_score: 93 seo_score: 95 companies:
• OpenAI schema_type: "NewsArticle" reading_time: 7 faq:
• question: "Was unterscheidet das Codex-Modell von OpenAI, insbesondere gpt-5.3-codex, von anderen großen Sprachmodellen für Codierungsaufgaben?" answer: 'Die Codex-Modelle von OpenAI, insbesondere gpt-5.3-codex, sind auf "agentisches Codieren" spezialisiert, was bedeutet, dass sie sich darin auszeichnen, Code-Aufgaben eigenständig zu verstehen, zu planen, zu implementieren und von Anfang bis Ende zu überprüfen. Im Gegensatz zu Allzweck-LLMs ist Codex fein auf Codegenerierung, Debugging und Refactoring abgestimmt und fungiert als proaktiver "erfahrener Ingenieur". Zu den Hauptunterscheidungsmerkmalen gehören verbesserte Token-Effizienz, überlegene Intelligenz für komplexe, langlaufende Aufgaben, erstklassige Kompaktierungsunterstützung zur Verwaltung erweiterter Kontextfenster und verbesserte Leistung in Umgebungen wie PowerShell und Windows. Es ist für maximale Anpassbarkeit über API konzipiert und bietet eine robuste Grundlage für den Aufbau fortschrittlicher Codierungsagenten.'
• question: "Was sind die neuesten Verbesserungen des Codex-Modells und wie profitieren Entwickler davon?" answer: 'Jüngste Fortschritte bei den Codex-Modellen steigern deren Nutzen für Entwickler erheblich. Sie sind jetzt schneller und Token-effizienter, was bedeutet, dass sie Aufgaben mit weniger "Denk"-Tokens erledigen können, wodurch Intelligenz und Geschwindigkeit in Einklang gebracht werden – ein "mittlerer" Argumentationsaufwand ist oft ideal für interaktives Codieren. Die Modelle zeichnen sich durch höhere Intelligenz und langfristige Autonomie aus und sind in der Lage, komplexe Aufgaben über Stunden hinweg zu bewältigen, wobei für die anspruchsvollsten Szenarien "hohe" oder "sehr hohe" Argumentationsaufwände zur Verfügung stehen. Entscheidend ist, dass sie eine erstklassige Kompaktierungsunterstützung bieten, die Kontextlimitprobleme während mehrstündiger Überlegungen verhindert und längere kontinuierliche Gespräche ermöglicht. Darüber hinaus schneidet Codex jetzt in PowerShell- und Windows-Umgebungen viel besser ab, was seine Anwendbarkeit erweitert.'
• question: "Wie lautet der empfohlene Prozess für die Migration eines bestehenden Codierungsagenten oder -frameworks, um Codex effektiv zu nutzen?" answer: 'Die Migration zu Codex umfasst zwei primäre Schritte: die Aktualisierung Ihres Prompts und die Verfeinerung Ihrer Tools. Für Prompts wird empfohlen, mit dem Standard-Codex-Max-Prompt von OpenAI als Basis zu beginnen und dann strategisch spezifische Anweisungen in Bezug auf Autonomie, Persistenz, Codebasis-Exploration, Tool-Nutzung und Frontend-Qualität hinzuzufügen. Wichtig ist, alle Anweisungen an das Modell zu entfernen, die es dazu auffordern, Pläne oder Präambeln im Voraus zu generieren, da dies die autonome Ausführung unterbrechen kann. Bei den Tools ist ein wichtiger Leistungshebel, diese gemäß den Best Practices von Codex zu aktualisieren, einschließlich der Nutzung der apply_patch-Implementierung. Der Open-Source-Agent codex-cli von OpenAI auf GitHub dient als ausgezeichnete Referenzimplementierung für diese Migration.'
• question: "Was sind die Kernprinzipien für effektives Prompting für Codex?" answer: 'Effektives Prompting für Codex konzentriert sich auf die Festlegung klarer Erwartungen an Autonomie und Tool-Nutzung. Das Modell sollte angewiesen werden, als "autonomer erfahrener Ingenieur" zu agieren, proaktiv Kontext zu sammeln, zu planen, zu implementieren, zu testen und zu verfeinern, ohne auf ständige Prompts zu warten. Betonen Sie Persistenz, bis eine Aufgabe vollständig von Anfang bis Ende erledigt ist, mit einer starken "Tendenz zur Handlung", um mit vernünftigen Annahmen zu implementieren, anstatt für Klärungen anzuhalten, es sei denn, es ist wirklich blockiert. Es ist wichtig, Prompts für Vorausschaupläne oder Statusaktualisierungen während der Ausführung zu vermeiden, da dies die Arbeit vorzeitig beenden kann. Priorisieren Sie außerdem die Tool-Nutzung gegenüber rohen Shell-Befehlen, insbesondere für Operationen wie das Lesen von Dateien (read_file gegenüber cat).'
• question: "Wie priorisiert Codex Codierungsqualität, Korrektheit und die Einhaltung bestehender Konventionen während der Implementierung?" answer: 'Codex ist so konzipiert, dass es als "gewissenhafter Ingenieur" agiert und Korrektheit, Klarheit und Zuverlässigkeit über Geschwindigkeit oder Abkürzungen priorisiert. Es wird ausdrücklich angewiesen, sich an bestehende Konventionen der Codebasis zu halten, einschließlich Muster, Hilfsfunktionen, Benennung und Formatierung, und nur mit begründeten Rechtfertigungen davon abzuweichen. Das Modell gewährleistet Vollständigkeit, deckt alle relevanten Oberflächen für konsistentes Verhalten ab und implementiert verhaltenssichere Standardeinstellungen, wobei die UX erhalten bleibt und Tests für beabsichtigte Änderungen hinzugefügt werden. Eine strikte Fehlerbehandlung ist von größter Bedeutung, wobei weitreichende try/catch-Blöcke oder stille Fehler vermieden werden. Es befürwortet auch effiziente, kohärente Bearbeitungen, indem ausreichend Kontext gelesen wird, bevor logische Änderungen zusammengefasst werden, und die Typsicherheit aufrechterhalten wird, indem vorhandene Hilfsfunktionen wiederverwendet werden, um unnötige Casts zu vermeiden.'
• question: "Können Sie den Ansatz von Codex zur Datei-Exploration, zum Lesen und zur Parallelisierung von Aufgaben näher erläutern?" answer: 'Codex verwendet einen hochoptimierten Workflow für die Datei-Exploration und Aufgabenparallelisierung. Das Kernprinzip ist "Zuerst denken" und alle notwendigen Dateien/Ressourcen vor jedem Tool-Aufruf zu entscheiden. Anschließend ist es entscheidend, "alles zu stapeln", was bedeutet, dass, wenn mehrere Dateien benötigt werden, diese in einem einzigen Vorgang zusammen gelesen werden sollten. Der primäre Mechanismus zur Parallelisierung von Tool-Aufrufen ist multi_tool_use.parallel. Dieser Ansatz maximiert die Effizienz, indem sequentielle Aufrufe vermieden werden, es sei denn, sie sind logisch absolut unvermeidbar (d.h. wenn das Ergebnis eines Aufrufs den nächsten bestimmt). Der empfohlene Workflow ist: (a) alle benötigten Lesevorgänge planen, (b) einen parallelen Stapel ausführen, (c) die Ergebnisse analysieren und (d) wiederholen, wenn neue, unvorhersehbare Lesevorgänge auftreten, wobei immer maximale Parallelität Priorität hat.'

# Codex-Prompting: Agentisches Codieren mit OpenAI meistern

Die Codex-Modelle von OpenAI stehen an der Spitze der KI-gesteuerten Softwareentwicklung und verschieben die Grenzen von Intelligenz und Effizienz beim agentischen Codieren. Für Entwickler, die maximale Leistung aus diesen fortschrittlichen Systemen herausholen möchten, ist ein tiefes Verständnis effektiver Prompting- und Integrationsstrategien unerlässlich. Dieser Leitfaden, zugeschnitten auf Benutzer, die direkt über die API interagieren, vertieft die Nuancen der Optimierung von Codex, insbesondere des Modells `gpt-5.3-codex`, um sein volles Potenzial zu erschließen.

Während ein dediziertes [Codex SDK](https://developers.openai.com/codex/sdk/) viele Integrationen vereinfacht, konzentriert sich dieser Artikel auf den direkten API-Ansatz, der eine beispiellose Anpassbarkeit für komplexe agentische Workflows bietet. Indem Sie diesen Richtlinien folgen, können Sie Ihre Interaktion mit Codex von der grundlegenden Codegenerierung in eine hochentwickelte, autonome Entwicklungspartnerschaft verwandeln.

## Jüngste Innovationen zur Leistungssteigerung der Codex-Modelle

Die Landschaft der KI-Codierung entwickelt sich rasant weiter, und Codex hat erhebliche Verbesserungen erfahren, die darauf abzielen, seine Leistung und Benutzerfreundlichkeit zu steigern. Diese Verbesserungen betreffen kritische Aspekte wie Geschwindigkeit, Intelligenz und Kontextmanagement und machen es zu einem noch beeindruckenderen Werkzeug für Entwickler.

Hier ist eine Übersicht der wichtigsten Fortschritte:

*   **Schneller und Token-effizienter:** Codex arbeitet jetzt mit größerer Effizienz und verbraucht weniger "Denk-Tokens", um Aufgaben zu erledigen. Für interaktive Codierungsszenarien sorgt ein "mittlerer" Argumentationsaufwand für ein optimales Gleichgewicht zwischen Intelligenz und Geschwindigkeit, wodurch Ihre Entwicklungszyklen reibungsloser und kostengünstiger werden.
*   **Höhere Intelligenz und langfristige Autonomie:** Codex ist nicht nur intelligent; es ist für eine nachhaltige, komplexe Problemlösung konzipiert. Es kann autonom über längere Zeiträume – sogar Stunden – arbeiten, um Ihre anspruchsvollsten Aufgaben zu bewältigen. Für Projekte mit hohem Einsatz oder außergewöhnlich schwierige Projekte stehen "hohe" oder "sehr hohe" Argumentationsaufwände zur Verfügung, um seine Fähigkeiten weiter auszuschöpfen.
*   **Erstklassige Kompaktierungsunterstützung:** Um eine häufige Herausforderung bei langen KI-Interaktionen zu bewältigen, bietet Codex jetzt eine robuste Kompaktierungsunterstützung. Diese Innovation ermöglicht mehrstündige Überlegungen ohne das Erreichen von Kontextlimits, was kontinuierliche Benutzergespräche über Sitzungen hinweg erleichtert, ohne dass häufige Neustarts erforderlich sind.
*   **Verbesserte PowerShell- und Windows-Kompatibilität:** Im Hinblick auf die vielfältigen Entwicklungsumgebungen hat Codex seine Leistung und Integration in PowerShell- und Windows-Ökosystemen erheblich verbessert, wodurch seine Anwendbarkeit für eine breitere Palette von Entwicklern erweitert wird.

Diese Verbesserungen zusammen positionieren Codex als führende Wahl für anspruchsvolles agentisches Codieren, das in der Lage ist, komplexe Aufgaben mit bemerkenswerter Unabhängigkeit und Präzision zu bewältigen.

## Nahtlose Migration und Einstieg mit Codex

Für Entwickler, die bereits einen Codierungsagenten verwenden, kann der Übergang zu Codex ein relativ reibungsloser Prozess sein, insbesondere wenn Ihr aktuelles Setup mit GPT-5-Serienmodellen abgestimmt ist. Wenn Sie jedoch von einem Drittanbietermodell oder einem GPT-5-Serienmodell migrieren, das nicht speziell für agentisches Codieren optimiert ist, könnten umfangreichere Änderungen erforderlich sein.

OpenAI empfiehlt dringend, den vollständig quelloffenen `codex-cli`-Agenten, verfügbar auf [GitHub](https://github.com/openai/codex), als beste Referenzimplementierung zu verwenden. Das Klonen dieses Repositorys ermöglicht es Ihnen, Codex selbst (oder jeden Codierungsagenten) zu verwenden, um seine interne Funktionsweise zu verstehen und Ihr eigenes Framework anzupassen. Für diejenigen, die daran interessiert sind, wie andere fortschrittliche Modelle integriert werden, können Ressourcen wie der Artikel [openai-gpt-5-2-codex](/de/openai-gpt-5-2-codex) wertvollen Kontext bieten.

Wichtige Schritte zur effektiven Migration Ihres Frameworks zu einem Codex-kompatiblen Setup umfassen:

1.  **Aktualisieren Sie Ihren Prompt:** Der Prompt ist die primäre Schnittstelle zur Anweisung von Codex. Beginnen Sie idealerweise mit dem Standard-**Codex-Max-Prompt** von OpenAI als Grundlage. Von dort aus fügen Sie strategisch taktische Anweisungen hinzu.
    *   Konzentrieren Sie sich auf Snippets, die Autonomie, Persistenz, Codebasis-Exploration, effektive Tool-Nutzung und Frontend-Qualität abdecken.
    *   Entfernen Sie entscheidend **alle Prompts für Vorausschaupläne, Präambeln oder Statusaktualisierungen** während des Rollouts. Solche Anweisungen können dazu führen, dass das Modell vorzeitig stoppt, bevor die Aufgabe abgeschlossen ist.
2.  **Aktualisieren Sie Ihre Tools:** Dies ist ein wichtiger Hebel zur Maximierung der Leistung von Codex. Stellen Sie sicher, dass Ihre Tools, einschließlich Implementierungen wie `apply_patch`, den in diesem Leitfaden beschriebenen Best Practices entsprechen.

Indem Sie diese Schritte sorgfältig befolgen, können Sie sicherstellen, dass Ihre bestehenden Workflows nahtlos in Codex integriert werden und dessen fortschrittliche Funktionen für Ihre Entwicklungsanforderungen nutzen.

## Prompts für Spitzenleistung von Codex optimieren

Der Prompt ist das Gehirn Ihrer Interaktion mit Codex. Der von OpenAI empfohlene **Codex-Max-Prompt** bildet die Grundlage für optimale Ergebnisse, insbesondere in Bezug auf Antwortkorrektheit, Vollständigkeit, Qualität, effiziente Tool-Nutzung und eine starke Tendenz zur Handlung. Dieser Prompt, ursprünglich abgeleitet vom [GPT-5.1-Codex-Max-Prompt](https://github.com/openai/codex/blob/main/codex-rs/core/gpt-5.1-codex-max_prompt.md), wurde rigoros für die agentische Ausführung optimiert.

Für Bewertungszwecke kann eine erhöhte Autonomie oder das Prompting für einen "nicht-interaktiven" Modus vorteilhaft sein, obwohl die reale Nutzung oft von der Möglichkeit zur Klärung profitiert. Die Kernphilosophie dieses Prompts besteht darin, Codex als **autonomen erfahrenen Ingenieur** zu behandeln.

Hier sind die Leitprinzipien, die in dem empfohlenen Prompt verankert sind:

| Prinzip                   | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| :------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Autonomie & Persistenz** | Agieren Sie als unabhängiger Ingenieur. Sammeln Sie proaktiv Kontext, planen Sie, implementieren Sie, testen Sie und verfeinern Sie, ohne auf explizite Prompts bei jedem Schritt zu warten. Bleiben Sie hartnäckig, bis die Aufgabe vollständig erledigt ist, und begleiten Sie Änderungen bis zur Überprüfung und Erklärung, es sei denn, Sie werden explizit pausiert.                                                                                                                                                                                                                                                                                                                                                                                                     |
| **Tendenz zur Handlung**  | Nehmen Sie standardmäßig Implementierungen mit vernünftigen Annahmen vor. Beenden Sie eine Runde nicht mit Klärungen, es sei denn, Sie sind wirklich blockiert. Jeder Rollout sollte mit einer konkreten Bearbeitung oder einem klaren Blocker mit einer gezielten Frage abgeschlossen werden.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| **Tool-Präferenz**        | Bevorzugen Sie immer dedizierte Tools (z.B. `read_file`, `git`, `rg`, `apply_patch`) gegenüber rohen Shell-Befehlen (`cmd` oder `run_terminal_cmd`), wenn ein Tool für die Aktion existiert. Parallelisieren Sie Tool-Aufrufe mit `multi_tool_use.parallel` für Effizienz.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| **Code-Implementierung**  | Optimieren Sie für Korrektheit, Klarheit und Zuverlässigkeit. Vermeiden Sie Abkürzungen, spekulative Änderungen oder unordentliche Hacks. Halten Sie sich an bestehende Codebasis-Konventionen. Sorgen Sie für Vollständigkeit, strikte Fehlerbehandlung und Typsicherheit. Fassen Sie logische Bearbeitungen zusammen.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| **Explorations-Workflow** | Bevor Sie einen Tool-Aufruf tätigen, **denken Sie zuerst nach**, um *alle* notwendigen Dateien/Ressourcen für den aktuellen Schritt zu bestimmen. **Stapeln Sie alles**, indem Sie mehrere Dateien gleichzeitig lesen. Verwenden Sie `multi_tool_use.parallel` für gleichzeitige Operationen. Führen Sie sequentielle Aufrufe nur durch, wenn der nächste Schritt wirklich vom vorherigen Ergebnis abhängt.                                                                                                                                                                                                                                                                                                                                                                |
| **Planungsdisziplin**     | Überspringen Sie die Planung bei einfachen Aufgaben. Wenn ein Plan erstellt wird, aktualisieren Sie ihn nach jeder Unteraufgabe. Beenden Sie eine Interaktion niemals *nur* mit einem Plan; das Ergebnis ist funktionierender Code. Gleichen Sie alle geplanten Punkte als Erledigt, Blockiert oder Abgebrochen ab, bevor Sie abschließen. |

Durch die Verinnerlichung dieser Prompt-Prinzipien können Entwickler Codex anleiten, mit beispielloser Effizienz und Präzision zu arbeiten und komplexe Codierungsaufgaben zu rationalisieren.

## Fortgeschrittene agentische Prinzipien: Autonomie, Persistenz und Codequalität

Zentral für die Effektivität von Codex ist seine Fähigkeit zur agentischen Ausführung – das Agieren als unabhängiger, proaktiver Entwickler. Dies beinhaltet mehr als nur das Verständnis von Anweisungen; es erfordert eine tief verwurzelte Reihe von Prinzipien, die sein Verhalten in einer Entwicklungsumgebung steuern.

### Autonomie und Persistenz

Codex wird angewiesen, als "autonomer erfahrener Ingenieur" zu fungieren. Sobald es eine Anweisung erhält, sammelt es proaktiv Kontext, entwickelt einen Plan, implementiert Änderungen, testet und verfeinert die Lösung, ohne ständig neue Prompts zu benötigen. Das bedeutet:

*   **End-to-End-Aufgabenbearbeitung:** Codex bleibt hartnäckig, bis eine Aufgabe vollständig abgeschlossen ist, von der ersten Analyse über die Implementierung, Verifizierung bis hin zu einer klaren Erklärung der Ergebnisse. Es stoppt nicht bei Teilkorrekturen oder Analysen.
*   **Tendenz zur Handlung:** Das Modell implementiert standardmäßig Lösungen auf der Grundlage vernünftiger Annahmen. Es beendet eine Runde nicht mit Klärungen, es sei denn, es ist wirklich blockiert, wodurch kontinuierlicher Fortschritt gewährleistet ist.
*   **Effizienter Fortschritt:** Um ineffiziente Schleifen zu vermeiden, wenn Codex feststellt, dass es wiederholt Dateien neu liest oder bearbeitet, ohne klaren Fortschritt zu erzielen, wird es angewiesen, die Situation zusammenzufassen und nach klärenden Fragen zu fragen.

### Standards für die Code-Implementierung

Die Qualität des generierten Codes ist von größter Bedeutung. Codex hält sich an strenge Richtlinien, um sicherzustellen, dass seine Ausgabe nicht nur funktional, sondern auch robust, wartbar und im Einklang mit Best Practices ist:

*   **Gewissenhaftes Engineering:** Codex priorisiert Korrektheit, Klarheit und Zuverlässigkeit und vermeidet riskante Abkürzungen oder spekulative Änderungen. Es konzentriert sich auf die Behebung von Grundursachen statt von Symptomen.
*   **Codebasis-Konformität:** Es folgt strikt bestehenden Mustern, Hilfsfunktionen, Namenskonventionen und Formatierungen innerhalb der Codebasis. Jede Abweichung erfordert eine explizite Rechtfertigung.
*   **Vollständigkeit:** Codex untersucht und deckt alle relevanten Oberflächen ab, um konsistentes Verhalten in der gesamten Anwendung sicherzustellen.
*   **Verhaltenssichere Standardeinstellungen:** Es bewahrt die beabsichtigte Benutzererfahrung und das Verhalten, kennzeichnet oder steuert beabsichtigte Änderungen und fügt idealerweise Tests hinzu, wenn sich das Verhalten ändert.
*   **Strikte Fehlerbehandlung:** Das Modell vermeidet weitreichende `try/catch`-Blöcke oder stille Fehler und propagiert oder meldet Fehler explizit. Es wird bei ungültiger Eingabe nicht frühzeitig zurückkehren, ohne ordnungsgemäße Protokollierung oder Benachrichtigung.
*   **Effiziente Bearbeitungen:** Anstatt Mikro-Bearbeitungen liest Codex ausreichend Kontext, bevor es eine Datei ändert, und fasst logische Bearbeitungen zusammen, wodurch "Thrashing" mit vielen kleinen, unzusammenhängenden Patches vermieden wird.
*   **Typsicherheit:** Es wird erwartet, dass alle Änderungen Build- und Typüberprüfungen bestehen. Es vermeidet unnötige Typumwandlungen (z.B. `as any`) und bevorzugt korrekte Typen und Guard-Klauseln, wobei vorhandene Hilfsfunktionen für die Typzusicherung wiederverwendet werden.
*   **Wiederverwendung und DRY-Prinzip:** Bevor neue Hilfsfunktionen oder Logik eingeführt werden, wird Codex angewiesen, nach bestehenden Lösungen zu suchen, um die Wiederverwendung zu fördern und Duplikationen zu vermeiden (`Don't Repeat Yourself`).

Diese Prinzipien stellen sicher, dass Codex qualitativ hochwertigen, produktionsreifen Code generiert, der professionellen Entwicklungsstandards entspricht. Für weitere Einblicke in agentische Workflows könnten Sie Artikel über [github-agentic-workflows](/de/github-agentic-workflows) besonders relevant finden.

## Strategische Tool-Nutzung, Parallelisierung und Bearbeitungseinschränkungen

Die Leistungsfähigkeit von Codex als agentisches Modell wird erheblich verstärkt durch seine Fähigkeit, intelligent mit einer Reihe von Tools zu interagieren und diese zu nutzen. Sein Prompt betont eine klare Hierarchie: **Bevorzugen Sie dedizierte Tools gegenüber rohen Shell-Befehlen.** Zum Beispiel wird `read_file` gegenüber `cat` bevorzugt, `git` gegenüber `cmd` für die Versionskontrolle und `rg` für die Suche gegenüber `grep`.

### Effektive Tool-Nutzung und Parallelisierung

Ein kritischer Aspekt der Optimierung von Codex ist sein Ansatz zur Parallelisierung von Aufgaben, insbesondere während der Datei-Exploration:

1.  **Zuerst denken:** Bevor ein Tool-Aufruf ausgeführt wird, wird Codex angewiesen, *alle* Dateien und Ressourcen zu bestimmen, die es für den aktuellen Schritt benötigen wird.
2.  **Alles stapeln:** Wenn mehrere Dateien benötigt werden, auch aus unterschiedlichen Speicherorten, sollten sie in einem einzigen, gebündelten Vorgang zusammen gelesen werden.
3.  **`multi_tool_use.parallel` verwenden:** Diese spezifische Funktion ist der vorgesehene Mechanismus zur Parallelisierung von Tool-Aufrufen. Es ist entscheidend, die Parallelisierung nicht durch Skripting oder andere Mittel zu versuchen.
4.  **Sequentielle Aufrufe als letztes Mittel:** Nur wenn das Ergebnis eines vorhergehenden Aufrufs absolut notwendig ist, um den nächsten Schritt zu bestimmen, sollten sequentielle Aufrufe durchgeführt werden.
5.  **Workflow:** Der empfohlene Workflow ist: (a) alle notwendigen Lesevorgänge planen, (b) einen parallelen Stapel ausführen, (c) die Ergebnisse analysieren und (d) wiederholen, wenn neue, unvorhersehbare Lesevorgänge auftreten. Dieser iterative Prozess stellt sicher, dass immer maximale Parallelität beibehalten wird.

### Bearbeitungseinschränkungen und Git-Hygiene

Codex arbeitet in einem potenziell "verschmutzten Git-Arbeitsbereich", und sein Bearbeitungsverhalten unterliegt strengen Regeln, um die Integrität der Codebasis zu wahren und bestehende Benutzeränderungen zu respektieren:

*   **Nicht-destruktive Operationen:** Codex **NIEMALS** bestehende Änderungen des Benutzers zurück, es sei denn, dies wird explizit angefordert. Wenn es nicht verwandte Änderungen in Dateien gibt, die es berührt, wird es angewiesen, diese zu verstehen und damit zu arbeiten, anstatt sie zurückzusetzen. Destruktive Befehle wie `git reset --hard` oder `git checkout --` sind strengstens verboten, es sei denn, sie wurden vom Benutzer speziell genehmigt.
*   **Commit-Disziplin:** Es wird keine Commits ändern, es sei denn, dies wird explizit angefordert. Wenn unerwartete Änderungen auftreten, muss es sofort anhalten und Benutzeranweisungen einholen.
*   **ASCII-Standard:** Beim Bearbeiten oder Erstellen von Dateien verwendet Codex standardmäßig ASCII. Nicht-ASCII- oder Unicode-Zeichen werden nur mit klarer Begründung eingeführt, wenn die Datei diese bereits verwendet.
*   **Prägnante Kommentare:** Code-Kommentare werden nur hinzugefügt, wenn der Code nicht selbsterklärend ist, wobei der Fokus auf komplexen Blöcken und nicht auf trivialen Zuweisungen liegt.
*   **`apply_patch`-Verwendung:** `apply_patch` wird für Einzeldateibearbeitungen bevorzugt. Andere Optionen werden jedoch geprüft, wenn es nicht geeignet ist. Es wird explizit nicht für automatisch generierte Änderungen (z.B. `package.json`, Linting) oder wenn Skripting für Suchen und Ersetzen effizienter ist, verwendet.

Diese Einschränkungen stellen sicher, dass Codex reibungslos in bestehende Entwicklungsworkflows integriert wird und Versionskontrollpraktiken sowie Entwicklerbeiträge respektiert. Dieser akribische Ansatz bei der Tool-Nutzung und Git-Interaktion trägt erheblich zu seiner Zuverlässigkeit als agentischer Codierungspartner bei. Für einen tieferen Einblick in Best Practices für Prompt Engineering, die allgemein anwendbar sind, sollten Sie unseren Artikel über [best-practices-for-prompt-engineering-with-the-openai-api](/de/best-practices-for-prompt-engineering-with-the-openai-api) in Betracht ziehen.