Schulung OpenAI Codex – KI-gestützte Softwareentwicklung mit Codex, Coding-Agenten und APIs

Beschreibung/Inhalt
Unverbindliches Angebot
anfordern

# Einführung in OpenAI Codex und KI-gestützte Softwareentwicklung

* Was ist Codex? Architektur und Funktionsweise
* Codex als agentisches Werkzeug für die Softwareentwicklung
* Unterschiede zwischen klassischen KI-Coding-Assistenten und autonomen Coding-Agenten
* Überblick über die Codex-Plattform
* Codex CLI
* Codex IDE Extension
* Codex Desktop App
* Codex Cloud
* Codex SDK und APIs
* KI-Modelle für Codex
* GPT-Modelle für Programmierung und agentische Aufgaben
* Modellauswahl und Reasoning-Einstellungen
* Leistungsfähigkeit, Geschwindigkeit und Kosten
* AI-Assisted Coding, Vibe Coding und Agentic Coding
* Spec-Driven Development
* Vergleich mit GitHub Copilot, Claude Code, Cursor und Windsurf
* Möglichkeiten und Grenzen KI-generierten Codes

# Codex installieren, konfigurieren und kennenlernen

* Installation und Einrichtung von Codex
* Authentifizierung mit ChatGPT-Konto oder API-Schlüssel
* Codex in unterschiedlichen Entwicklungsumgebungen
* Terminal und Kommandozeile
* Visual Studio Code
* JetBrains-IDEs und weitere unterstützte Editoren
* Codex Desktop App für Windows und macOS
* Integration bestehender Git-Repositories
* Konfiguration von Modellen und Reasoning-Einstellungen
* Benutzer- und projektspezifische Einstellungen
* Konfiguration über `config.toml`
* Berechtigungen und Sicherheitsmechanismen
* Lokale und cloudbasierte Ausführung im Vergleich

# KI-gestützte Programmierung mit Codex

* Bestehende Quelltexte analysieren und erklären
* Code aus natürlichsprachlichen Anforderungen generieren
* Neue Funktionen und Komponenten implementieren
* Bestehende Anwendungen erweitern
* Code zwischen Programmiersprachen übersetzen
* Datenmodelle und Datenbankzugriffe erstellen
* REST-APIs implementieren
* Kommentare und technische Dokumentation generieren
* Code über mehrere Dateien hinweg verändern
* Komplexe Codebasen analysieren und modernisieren
* KI-generierte Änderungen überprüfen und übernehmen

# Codex CLI – Agentische Softwareentwicklung im Terminal

* Architektur und Funktionsweise der Codex CLI
* Interaktive Arbeit mit Codex
* Projekte und Repositories analysieren
* Kontext und Dateien bereitstellen
* Entwicklungsaufgaben über natürlichsprachliche Anweisungen ausführen
* Agentische Ausführung von Entwicklungsaufgaben
* Anforderungen analysieren
* Implementierung planen
* Dateien erstellen und verändern
* Terminalbefehle ausführen
* Tests starten und Ergebnisse überprüfen
* Genehmigungsmodi und Sandbox-Konfiguration
* Sitzungen fortsetzen und verwalten
* Nicht interaktive Ausführung mit `codex exec`
* Strukturierte Ausgaben und Automatisierung über Skripte

# Codex IDE Extension – KI-Agenten direkt in der Entwicklungsumgebung

* Installation und Konfiguration der IDE-Erweiterung
* Codex in Visual Studio Code und kompatiblen Entwicklungsumgebungen
* Bestehenden Quellcode als Kontext verwenden
* Dateien und Codebereiche referenzieren
* Komplexe Änderungen über mehrere Dateien hinweg durchführen
* Zusammenarbeit zwischen Entwickler und Coding-Agent
* Lokale Entwicklungsaufgaben an Codex delegieren
* Cloud-Aufgaben aus der IDE heraus starten
* Änderungen vergleichen und überprüfen
* Integration mit Git und Entwicklungswerkzeugen
* Unterschiede zwischen IDE Extension und Codex CLI

# Codex Desktop App – Mehrere Coding-Agenten verwalten

* Einführung in die Codex Desktop App
* Projekte und Arbeitsbereiche verwalten
* Entwicklungsaufgaben an Agenten delegieren
* Mehrere Agenten parallel ausführen
* Isolierte Arbeitsbereiche mit Git Worktrees
* Unterschiedliche Implementierungsansätze parallel bearbeiten
* Agentenaktivitäten und Arbeitsergebnisse überwachen
* Änderungen vergleichen und zusammenführen
* Lokale und cloudbasierte Aufgaben koordinieren
* Automations für wiederkehrende Entwicklungsaufgaben
* Skills zur Erweiterung der Agentenfähigkeiten
* Sicherheits- und Berechtigungseinstellungen

# Kontextverwaltung und Prompt Engineering mit Codex

* Effektive Prompts für Programmieraufgaben
* Kontextinformationen und Projektanforderungen bereitstellen
* Bestehende Codebasen als Kontext verwenden
* Architektur- und Qualitätsvorgaben berücksichtigen
* Anforderungen in strukturierte Implementierungspläne überführen
* Planungs- und Implementierungsphasen unterscheiden
* Kontextfenster und Tokenverbrauch optimieren
* Längere Entwicklungsprozesse über mehrere Sitzungen hinweg durchführen
* Wiederverwendbare Anweisungen erstellen
* Best Practices für zuverlässige KI-generierte Software

# Codex anpassen: AGENTS.md, Skills und Konfiguration

* Anpassungsmöglichkeiten von Codex
* Projektanweisungen mit `AGENTS.md`
* Globale und projektspezifische Anweisungen
* Coding Guidelines und Architekturvorgaben
* Unterschiedliche Regeln für Teilprojekte
* Vorgaben für Builds, Tests und Code Reviews
* Codex Skills
* Aufbau und Funktionsweise von Skills
* Skilldefinitionen mit `SKILL.md`
* Wiederverwendbare Entwicklungsabläufe
* Eigene Skills entwickeln
* Skills für Testautomatisierung und Code Reviews
* Konfiguration über `config.toml`
* Berechtigungen und Tool-Zugriffe konfigurieren
* Wiederverwendbare Codex-Konfigurationen im Team bereitstellen

# Refactoring, Debugging und Testing mit Codex

* Bestehende Anwendungen analysieren
* Code Smells und technische Schulden erkennen
* Refactoring einzelner Funktionen und ganzer Module
* Legacy-Anwendungen modernisieren
* Fehler anhand von Stack Traces und Logdateien analysieren
* Fehlerursachen systematisch ermitteln
* Fehlerkorrekturen mit Codex implementieren
* Unit Tests und Integrationstests generieren
* Testgetriebene Entwicklung (TDD) mit Codex
* Fehlgeschlagene Tests automatisch analysieren
* Code Reviews durchführen
* Sicherheitslücken und Performanceprobleme identifizieren
* Qualität KI-generierten Codes überprüfen

# Codex Cloud – Entwicklungsaufgaben in der Cloud ausführen

* Architektur und Funktionsweise von Codex Cloud
* Unterschiede zwischen lokaler und cloudbasierter Ausführung
* Git-Repositories mit Codex Cloud verbinden
* Cloud-Entwicklungsumgebungen einrichten
* Abhängigkeiten und Entwicklungswerkzeuge konfigurieren
* Isolierte Arbeitsumgebungen für Coding-Agenten
* Entwicklungsaufgaben an Codex Cloud delegieren
* Mehrere Aufgaben parallel ausführen
* Komplexe Änderungen autonom implementieren
* Tests und Buildprozesse in der Cloud ausführen
* Änderungen und Arbeitsergebnisse überprüfen
* Pull Requests vorbereiten und erstellen
* Aufgaben zwischen Cloud und lokaler Entwicklungsumgebung übertragen
* Sicherheits- und Netzwerkzugriffseinstellungen

# Model Context Protocol (MCP) mit Codex

* Einführung in das Model Context Protocol
* Architektur von MCP
* MCP Hosts
* MCP Clients
* MCP Server
* Codex als MCP-Host einsetzen
* MCP-Server konfigurieren und anbinden
* MCP Tools, Resources und Prompts
* Externe Datenquellen und Werkzeuge integrieren
* GitHub und GitLab
* Relationale Datenbanken
* REST-APIs
* Jira und andere Issue-Tracking-Systeme
* Browserautomatisierung
* Eigene MCP-Server entwickeln
* Codex als MCP-Server für andere Anwendungen bereitstellen
* Authentifizierung und Autorisierung
* Sicherheitsaspekte bei MCP-Integrationen

# Codex SDK – Coding-Agenten programmatisch steuern

* Einführung in das Codex SDK
* Architektur und Funktionsweise
* Unterschiede zwischen Codex CLI und Codex SDK
* Integration des Codex SDK in eigene Anwendungen
* SDK installieren und konfigurieren
* Authentifizierung und Modellkonfiguration
* Codex-Agenten programmatisch starten
* Threads und Sessions verwalten
* Entwicklungsaufgaben an Agenten übergeben
* Bestehende Agentensitzungen fortsetzen
* Strukturierte Ergebnisse verarbeiten
* Fortschritt und Ausführungsstatus überwachen
* Fehlerbehandlung und Abbruchbedingungen
* Agenten in eigene Entwicklungswerkzeuge integrieren
* Automatisierte Entwicklungsprozesse mit dem SDK implementieren

# Codex App Server – Eigene Clients und IDE-Integrationen entwickeln

* Architektur des Codex App Servers
* Unterschiede zwischen Codex SDK und App Server
* JSON-RPC als Kommunikationsprotokoll
* Bidirektionale Kommunikation zwischen Client und Codex
* Codex App Server starten und konfigurieren
* Sitzungen und Konversationsverläufe verwalten
* Agentenaktionen programmatisch steuern
* Ereignisse und Statusmeldungen verarbeiten
* Streaming von Agentenaktivitäten
* Berechtigungsanfragen und Freigaben implementieren
* Modelle und Konfigurationen abrufen
* Eigene Benutzeroberflächen für Codex entwickeln
* Codex in bestehende IDEs und Entwicklerwerkzeuge integrieren
* Fehlerbehandlung und Verbindungsverwaltung

# OpenAI Agents API – Cloudbasierte KI-Agenten mit Codex entwickeln

* Überblick über die OpenAI Agents API
* Unterschiede zwischen Codex SDK, App Server und Agents API
* Verwaltete Agentenlaufzeit auf Basis des Codex Harness
* Authentifizierung und API-Zugriff
* Agentensitzungen erstellen und verwalten
* Aufgaben programmatisch starten und ausführen
* Zustandsverwaltung und Kontextkomprimierung
* Agenten mit Werkzeugen und MCP-Servern verbinden
* Ausführungsumgebungen und Sandboxes konfigurieren
* Code und Dateien durch Agenten bearbeiten lassen
* Subagents und Multi-Agent-Orchestrierung
* Strukturierte Ergebnisse und Artefakte verarbeiten
* Lang laufende Aufgaben und Fehlerbehandlung
* Agentenaktivitäten protokollieren und überwachen
* Integration in eigene Anwendungen und Unternehmensprozesse

# OpenAI API – Eigene KI-Anwendungen mit Codex-Technologien entwickeln

* Unterschiede zwischen Codex und der allgemeinen OpenAI API
* Überblick über die OpenAI API
* Responses API
* Modelle für Programmierung und komplexe Denkaufgaben
* Textgenerierung und strukturierte Ausgaben
* Function Calling und Tool Use
* Streaming von KI-Antworten
* Werkzeuge für Codeausführung und Dateiverarbeitung
* Integration von MCP-Servern
* OpenAI Agents SDK
* Eigene KI-Agenten mit Tools und Workflows implementieren
* Unterschiede zwischen allgemeinen KI-Agenten und spezialisierten Coding-Agenten
* Geeignete API für unterschiedliche Anwendungsfälle auswählen

# DevOps mit Codex: Git, GitHub und CI/CD

* Git-Repositories mit Codex analysieren
* Änderungen und Commits erstellen
* Branches verwalten
* Pull Requests vorbereiten und überprüfen
* Automatisierte Code Reviews
* Codex in GitHub Actions integrieren
* Codex CLI in CI/CD-Pipelines ausführen
* Build- und Testfehler automatisch analysieren
* Fehlerkorrekturen durch Coding-Agenten implementieren
* Issue-basierte Softwareentwicklung
* Release-Vorbereitung mit Codex automatisieren
* Sicherheitsprüfungen und Qualitätskontrollen integrieren
* Human-in-the-Loop und Freigabeprozesse

Optional: GitLab, Azure DevOps oder andere DevOps-Lösungen als Alternative zu GitHub

# Multi-Agent-Systeme und autonome Softwareentwicklung mit Codex

* Grundlagen der Multi-Agent-Entwicklung
* Aufgabenzerlegung und Delegation
* Spezialisierte Agenten für unterschiedliche Entwicklungsaufgaben
* Architektur und Planung
* Implementierung
* Testing
* Code Review
* Dokumentation
* Parallele Bearbeitung von Entwicklungsaufgaben
* Koordination mehrerer Agenten
* Kontext- und Zustandsverwaltung
* Isolierte Entwicklungsumgebungen
* Git Worktrees für parallele Änderungen
* Ergebnisse zusammenführen und Konflikte behandeln
* Automatisierte Qualitätskontrollen
* Grenzen und Risiken autonomer Softwareentwicklung

# Sicherheit, Datenschutz und Kostenkontrolle

* Datenschutz beim Einsatz von Codex
* Verarbeitung vertraulicher Quelltexte
* Schutz von API-Schlüsseln und Zugangsdaten
* Sicherheitsrisiken durch Prompt Injection
* Risiken automatisierter Terminalbefehle
* Sandbox- und Berechtigungskonzepte
* Absicherung von MCP-Servern und externen Tools
* Sicherheitsmechanismen für cloudbasierte Agenten
* Freigabeprozesse für kritische Aktionen
* Qualitätssicherung bei KI-generiertem Code
* Modellkosten und Tokenverbrauch optimieren
* API-Kosten und Nutzungsgrenzen überwachen
* Codex im Unternehmen sicher einsetzen

# Praktische Übungen mit Codex und den APIs

* Ein bestehendes Softwareprojekt mit Codex analysieren
* Eine neue Funktion mit Codex CLI implementieren
* Eine komplexe Entwicklungsaufgabe mit der Codex Desktop App durchführen
* Mehrere Coding-Agenten parallel einsetzen
* Bestehenden Code refaktorieren
* Einen Fehler einschließlich Unit Tests automatisch beheben
* Eigene Projektanweisungen mit `AGENTS.md` definieren
* Einen eigenen Codex Skill entwickeln
* Einen MCP-Server anbinden
* Eine Entwicklungsaufgabe mit Codex Cloud ausführen
* Codex über das SDK programmatisch starten
* Eine eigene Anwendung über den Codex App Server anbinden
* Einen Cloud-Agenten über die OpenAI Agents API implementieren
* Einen automatisierten Code-Review-Prozess erstellen
* Codex in eine CI/CD-Pipeline integrieren

# Vergleich und Ausblick

* Codex im Vergleich mit Claude Code, Cursor, Windsurf und GitHub Copilot
* Codex CLI im Vergleich mit anderen terminalbasierten Coding-Agenten
* Codex SDK und Agents API im Vergleich mit den APIs anderer KI-Coding-Werkzeuge
* Unterschiede zwischen Codex und allgemeinen KI-Agentenplattformen
* Offene Standards für KI-Agenten: MCP, A2A, ACP und AG-UI
* Möglichkeiten und Grenzen von Vibe Coding und Agentic Coding
* Entwicklungstrends bei autonomen Coding-Agenten
* Auswirkungen KI-gestützter Softwareentwicklung auf Softwarearchitektur und Entwicklungsprozesse

Dauer
Nach Ihren Wünschen. Gerne geben wir Ihnen eine Empfehlung zur notwendigen Schulungsdauer, wenn Sie uns in der Anfrage Ihre Vorkenntnisse und Ziele nennen.
Termine
Auf Anfrage. Wir richten diese Schulung für individuell Ihr Unternehmen aus. Dies ist keine Gruppenschulung, bei der Sie mit anderen Unternehmen zusammen lernen und sich nach einer vorgegebenen Agenda richten müssen.
Ort
Online (per TEAMS oder ZOOM oder anderer Videosoftware nach Ihrem Wunsch)
oder
an Ihrem Firmensitz in Deutschland, Österreich und der Schweiz (andere Länder auf Anfrage)
Schulungsdidaktik
Nach Ihrer Wahl:
  • Klassische Schulung mit PC-Übungen
  • Reine Präsentation ohne PC-Übungen
  • oder
  • Interaktiver Workshop mit Beratungsanteil
Das ist im Preis enthalten
Sie erhalten von uns einen Festpreis inklusive:
  • Einem bestimmten, im Angebot benannten und per Expertenprofil ausgewiesenen Top-Experten
  • Vorgespräch mit dem Experten zur Abstimmung der Inhalte und der Didaktik
  • Bis zu 10 Teilnehmer, bei reinen Präsentationen: beliebige Teilnehmeranzahl
  • Teilnahmezertifikat für alle Teilnehmer