KI-Lösungen · Fortgeschrittene
Coding Agents im Team bauen & orchestrieren
Aufbauschulung für erfahrene Entwickler: Vom Agenten-Anwender zum Agenten-Entwickler. Eigene Agenten entwerfen, parallele Multi-Agent-Workflows orchestrieren und eigene MCP-Server bauen – konsequent hands-on.
Auf einen Blick
Fortgeschrittene
Niveau
6–12 Personen
Teilnehmer
Deutsch / Englisch
Sprache
Inklusive
Zertifikat
Zielgruppe
Softwareentwickler mit Grundkenntnissen in Coding Agents – aus der Einstiegsschulung oder mindestens vier Wochen Eigenerfahrung
Format
4 Stunden, Inhouse – vor Ort oder remote. Kompakte Theorie-Impulse, Schwerpunkt auf eigenständigen Übungen.
Voraussetzungen
Solide Kenntnisse in Python und/oder TypeScript, Erfahrung mit Git und REST-APIs, aktiv genutzter Coding Agent
Wertversprechen
Vom Agenten-Anwender zum Agenten-Entwickler – eigene, maßgeschneiderte Workflows produktionsreif machen.
In der Praxis setzen wir üblicherweise Anthropic-Modelle ein, weil sie in Enterprise-Umgebungen aktuell das verbreitetste Coding-Agent-Ökosystem bilden. Die Inhalte sind jedoch modell-agnostisch: Wir sehen eine deutliche Konvergenz der Fähigkeiten zwischen Anthropic, Google und OpenAI – die hier vermittelten Konzepte (Agenten-Design, Orchestrator-Worker, MCP, Projektkontext) gelten gleichermaßen für Claude Code, ChatGPT Codex CLI, Gemini CLI und weitere Anbieter.
Ausgangslage
Vom Anwender zum Werkzeugbauer
Wer Coding Agents einige Wochen aktiv nutzt, stößt schnell an die Grenzen der vorgefertigten Arbeitsweisen. Die nächste Produktivitätsstufe entsteht nicht durch schnelleres Tippen, sondern durch eigene Agenten, parallele Workflows und eine saubere Integration in die bestehende Tool-Landschaft.
Vordefinierte Agenten reichen irgendwann nicht mehr
Out-of-the-Box-Agenten sind ein guter Einstieg – aber jedes Team hat eigene Prozesse, Konventionen und Qualitätsansprüche. Wiederkehrende Aufgaben verdienen maßgeschneiderte Agenten, die genau diese Kontexte abbilden.
Produktivität skaliert über Parallelität
Der größte Hebel liegt nicht in einem schnelleren Einzel-Agenten, sondern im Orchestrator-Worker-Pattern: Ein Agent plant und verteilt, mehrere Worker arbeiten parallel – und der Entwickler bleibt Dirigent statt Spieler.
Kontext ist der entscheidende Hebel
Projektspezifische Konventionen, Architekturleitlinien und Domänenwissen gehören in versionierten Kontext (z. B. CLAUDE.md, AGENTS.md, GEMINI.md) – nicht in Einmal-Prompts. Hierarchische Konfiguration macht Agenten reproduzierbar und teamweit konsistent.
Integration statt Insel
Agenten werden erst dann wirklich produktiv, wenn sie interne Tools, APIs und Datenquellen erreichen. Das Model Context Protocol (MCP) hat sich als offener Standard etabliert – eigene MCP-Server öffnen die eigene Tool-Landschaft für beliebige Agenten.
Agenda
Schulungsablauf
Vier Blöcke, konsequent hands-on: Theorie nur dort, wo sie die folgende Übung direkt vorbereitet.
Agenten-Design & Projektkontext
Was macht einen guten Agenten aus – Rolle, Systemkontext, Toolset. Projektwissen dauerhaft in versioniertem Kontext verankern (CLAUDE.md, AGENTS.md & Co.). Hierarchische Konfiguration: global, Repo, lokal. Abgrenzung vordefinierter vs. eigener Agenten.
Eigene Agenten entwickeln
Von der Spezifikation (Zweck, Systemkontext, Tools) bis zur Implementierung in Python oder TypeScript. Agenten in eine bestehende Codebasis einbinden und iterativ testen. Übung: eigener Review- oder Deploy-Agent nach Wahl.
Parallele Multi-Agent-Workflows
Orchestrator-Worker-Pattern in der Praxis: Aufgaben aufteilen, mehrere Agenten-Instanzen parallel starten, Ergebnisse zusammenführen, Konflikte auflösen. Übung: paralleles Feature-Development mit zwei Worker-Agenten.
MCP-Server bauen & deployen
Model Context Protocol im Detail: Tools, Resources, Prompts. Eigenen MCP-Server in Python implementieren, lokal testen und im Coding Agent einbinden. Produktionsreife: Logging, Fehlerbehandlung, Sicherheitsgrenzen und Deployment.
Eigene Agenten entwerfen und implementieren
Rolle, Systemkontext und Toolset bewusst gestalten – und als lauffähigen Agenten in Python oder TypeScript umsetzen
Projektkontext dauerhaft verankern
Konventionen, Architekturleitlinien und Domänenwissen in versioniertem Kontext ablegen – reproduzierbar, teamweit konsistent, modellunabhängig
Orchestrator-Worker-Pattern anwenden
Parallele Multi-Agent-Workflows koordinieren: Aufgaben aufteilen, Instanzen starten, Ergebnisse zusammenführen, Konflikte auflösen
MCP-Server selbst bauen und einbinden
Interne Tools, APIs und Datenquellen über das Model Context Protocol für beliebige Agenten nutzbar machen – inklusive Deployment
Produktionsreife Agenten-Workflows
Logging, Fehlerbehandlung und Sicherheitsgrenzen einbauen – damit Agenten nicht nur im Experiment, sondern auch im Projektalltag zuverlässig laufen
Lernziele
Was Teilnehmende mitnehmen
Die Schulung ist konsequent hands-on: Teilnehmende verlassen sie mit eigenen Agenten, parallelen Workflows und einem selbst gebauten MCP-Server – alles übertragbar auf den realen Projektkontext.
Einsatzszenarien
Besonders sinnvoll für Teams, die …
Wiederkehrende Aufgaben automatisieren
… Code-Reviews, Deployments, Release Notes, Testdaten-Setups – mit maßgeschneiderten Agenten statt Copy-Paste-Prompts
Parallele Feature-Arbeit orchestrieren
… mehrere Worker-Agenten gleichzeitig an getrennten Branches arbeiten lassen – koordiniert durch einen Orchestrator
Interne Tools & APIs anbinden
… eigene Datenquellen, Ticketsysteme oder Deploy-Pipelines über MCP für Agenten zugänglich machen
Abgrenzung
Was die Schulung bewusst nicht abdeckt
Die Schulung ist ein praxisorientiertes Aufbauformat – kein Deep Dive in LLM-Architekturen, kein Modelltraining und kein Fine-Tuning. Ebenfalls nicht abgedeckt sind Einsteigerinhalte (effektives Prompting, Grundlagen des Coding Agents) – diese werden in der Einstiegsschulung Agentenbasiertes Coding vermittelt.
Voraussetzungen
Was Teilnehmende mitbringen
Coding Agent aktiv genutzt
Einstiegsschulung abgeschlossen oder mindestens vier Wochen eigene Erfahrung mit einem Coding Agent.
Modell-Zugang mit Kontingent
Abonnement oder API-Zugang bei Anthropic, Google oder OpenAI mit ausreichendem Kontingent für parallele Agenten-Workflows.
Python und/oder TypeScript
Solide Entwickler-Kenntnisse in mindestens einer der beiden Sprachen sowie Erfahrung mit Git und REST-APIs.
Lauffähige Dev-Umgebung
Eigener Laptop mit installierter Node.js- und Python-Umgebung sowie stabiler Internetverbindung.
FAQ
Häufige Fragen
Welche technischen Anforderungen gelten?
Eigener Laptop mit aktuellem Betriebssystem (Windows 10+, macOS 12+, Linux) und stabiler Internetverbindung. Kursspezifische Software (z. B. Node.js oder Python) wird im Vorfeld kommuniziert; beim Setup unterstützen wir vorab, damit der Kurstag vollständig für Inhalte bleibt.
Welche Modell-Lizenz oder welcher Zugang wird benötigt?
Je nach Kurs unterschiedlich – eine aktive Lizenz oder ein API-Zugang beim gewählten Anbieter (Anthropic, Google oder OpenAI). Wir beraten bei der Auswahl des passenden Plans. Zugänge müssen vor Kursbeginn eingerichtet sein.
Was gibt es nach dem Kurs als Nachbereitungsmaterial?
Alle Teilnehmenden erhalten Schulungsunterlagen als PDF, kuratierte Ressourcenlisten sowie Musterlösungen zu den Übungsaufgaben. Zusätzlich steht ein Q&A-Kanal für Rückfragen nach dem Kurs zur Verfügung.
Kurssprache und Barrierefreiheit?
Standardmäßig auf Deutsch, auf Wunsch auch auf Englisch. Unterlagen in der jeweiligen Sprache. Besondere Anforderungen zur Barrierefreiheit bitte bei der Buchung angeben – wir richten den Kurs entsprechend ein.
Wie sieht das Teilnahmezertifikat aus?
Nach erfolgreichem Abschluss erhält jede / jeder Teilnehmende ein digitales Teilnahmezertifikat mit Kursinhalt, Datum und Durchführenden. Geeignet als interner Qualifikationsnachweis oder für das LinkedIn-Profil.
Unverbindlich
Schulung anfragen
Buchen Sie die Fortgeschrittenen-Schulung für erfahrene Entwickler – Inhouse, praxisnah und sofort anwendbar.
