Agentic Software Development

Entwicklungsaufgaben kontrolliert an AI-Agenten delegieren

01 Intro

AI-Agenten können Entwicklungsaufgaben nicht nur unterstützen, sondern über mehrere Arbeitsschritte hinweg selbstständig bearbeiten. Sie analysieren Codebasen, planen Änderungen, bearbeiten Dateien, führen Werkzeuge aus, testen Ergebnisse und reagieren auf Fehler. Damit entstehen neue Möglichkeiten – aber auch neue Anforderungen an Kontrolle, Sicherheit und Qualitätssicherung.

Der Kurs vermittelt die technischen und methodischen Grundlagen für agentische Softwareentwicklung. Die Teilnehmer lernen, Entwicklungsaufgaben für Agenten zu strukturieren, Werkzeuge und Kontext bereitzustellen, Autonomie gezielt zu begrenzen und Ergebnisse durch Tests, Quality Gates und technische Kontrollmechanismen abzusichern. Der Schwerpunkt liegt auf produktneutralen Prinzipien, die sich auf unterschiedliche Coding Agents und Entwicklungsumgebungen übertragen lassen.

Kurs-ID

AI-004

Dauer

3 Tage

Format

Präsenz · Live Online · Inhouse

Vorkenntnisse

Praktische Erfahrung in der Softwareentwicklung, Git und automatisierten Tests

02 Trainingsprogramm

Inhalte

Vom AI-Assistenten zum Entwicklungsagenten

Chat, Coding Assistant und Coding Agent unterscheiden
wahrnehmen, entscheiden und handeln
mehrstufige Aufgaben und Feedback aus der Umgebung
Tool-Nutzung als Grundlage agentischer Arbeit
unterschiedliche Autonomiegrade
geeignete Entwicklungsaufgaben für Agenten

Agentische Entwicklungsaufträge

Ziel, Ausgangszustand und gewünschtes Verhalten
Akzeptanzkriterien und Definition of Done
technische Randbedingungen und Nicht-Ziele
erlaubten Änderungsumfang festlegen
Aufgaben in kontrollierbare Schritte zerlegen
Plan, Zwischenziele und Abbruchbedingungen

Kontext und persistentes Projektwissen

Repository, Anforderungen und Dokumentation als Kontext
Architekturinformationen und Coding Conventions
relevante Informationen gezielt auswählen
Projektinstruktionen und Entwicklungsregeln
Build-, Test- und Werkzeugwissen bereitstellen
Instruktionen versionierbar und wartbar halten

Tools für Entwicklungsagenten

Dateisystem, Shell und Git
Compiler, Interpreter und Build-Systeme
Testframeworks, Browser, APIs und Datenbanken
Operationen und Seiteneffekte klar abgrenzen
strukturierte Parameter, Ergebnisse und Fehler
kleine, überprüfbare Tool-Oberflächen gestalten

Model Context Protocol

MCP als Tool- und Kontextschnittstelle
MCP Server, Tools und Resources
vorhandene MCP-Server einsetzen
eigene Entwicklungswerkzeuge anbinden
Toolsets nach Aufgaben strukturieren
Berechtigungen und Vertrauensgrenzen berücksichtigen

Berechtigungen und kontrollierte Autonomie

Lesen, Schreiben und Ausführen unterscheiden
Arbeitsbereich, Shell und Netzwerkzugriff begrenzen
Credentials und externe Systeme nur bei Bedarf freigeben
reversible und irreversible Aktionen unterscheiden
Autonomie nach Risiko festlegen
kritische Aktionen an den Menschen eskalieren

Human in the Loop und technische Guardrails

sinnvolle Kontroll- und Freigabepunkte
Plan und kritische Änderungen vor Ausführung prüfen
Unsicherheit eskalieren statt raten
Allow-/Deny-Regeln und Tool-Policies
Validierung, Wrapper und Gateways außerhalb des Modells
Kontrolle ohne unnötiges Mikromanagement

Isolation, Git und reversible Arbeit

Container und isolierte Arbeitsverzeichnisse
eingeschränkte Credentials und Netzwerkzugriffe
sauberer Git-Ausgangszustand
kleine Änderungen, Diffs und Commits als Checkpoints
Worktrees für parallele Arbeitsbereiche
Änderungen zurücksetzen und Arbeitsbereiche aufräumen

Tests und Quality Gates

Anforderungen in ausführbare Tests überführen
Akzeptanz-, Regressions-, Grenz- und Fehlerfälle
Tests als Feedback für den Agenten
Build, Linting, Typprüfung und statische Analyse
Security Scans und Architekturregeln
verbindliche Kriterien vor Abschluss einer Aufgabe

Fehlerkorrektur und Recovery

Build-, Test- und Tool-Fehler als Feedback
Ursache analysieren und Lösungsversuch begrenzen
wiederholte Fehler und Endlosschleifen erkennen
teilweise ausgeführte Aufgaben und inkonsistente Zustände
Retry, Rollback und idempotente Wiederholung
kontrollierter Abbruch und Eskalation

Zustand und lange laufende Aufgaben

erledigte und offene Schritte nachvollziehen
Zwischenergebnisse und Entscheidungen sichern
Git und externe Statusinformationen als persistenter Zustand
Checkpoints und Fortschrittsprotokolle
Kontextverlust und Wiederanlauf
Abschlussbedingungen eindeutig erkennen

Subagents und Multi-Agent-Workflows

spezialisierte Agenten für Analyse, Implementierung, Test und Review
Kontexte und Verantwortlichkeiten trennen
Ergebnisse an einen koordinierenden Agenten zurückgeben
unabhängige Aufgaben parallelisieren
gemeinsame Ressourcen und konkurrierende Änderungen
zusätzliche Komplexität gegen den Nutzen abwägen

Implementierung und Review trennen

Agent als Entwickler und Agent als Reviewer
unabhängigen Review-Kontext herstellen
Anforderungen und Tests erneut prüfen
Architektur- und Security-Verstöße suchen
Änderungen anhand von Diff und Evidenz beurteilen
Grenzen von AI-gegen-AI-Kontrolle

Untrusted Input, Secrets und Prompt Injection

Quellcode, Kommentare, Dokumentation und Webseiten als Eingaben
direkte und indirekte Prompt Injection
Daten nicht automatisch als Instruktionen behandeln
Secrets, API Keys, Konfigurationen und Produktionsdaten
Secret Stores und Zugriff nach tatsächlichem Bedarf
Prompt-Regeln nicht mit einer Sicherheitsgrenze verwechseln

Externe Systeme und Trust Boundaries

Datenbanken, Issue Tracker und Git-Plattformen
CI/CD, Cloud-Dienste und Produktivsysteme
Lese- und Schreibzugriffe nach Risiko klassifizieren
Trust Boundaries zwischen Agent, Tools und Zielsystemen
Schreibzugriffe besonders absichern
Verantwortlichkeiten der Komponenten festlegen

Observability, Audit und Ressourcen

Tool-Aufrufe, Dateiänderungen und Ergebnisse protokollieren
Agentenläufe für spätere Analyse nachvollziehbar halten
Fehler und Eskalationen erfassen
Modellwahl, Tokenverbrauch und Kontextgröße
Tool-Aufrufe, Parallelität und Laufzeit begrenzen
Zeit- und Kostenlimits definieren

Agentische Entwicklung und CI/CD

agentische Entwicklung von deterministischer Pipeline trennen
Agent erzeugt Änderung, Pipeline verifiziert
reproduzierbare Builds und automatisierte Tests
Quality Gates bleiben verbindlich
Review- und Freigabeprozesse integrieren
AI-Code erhält keinen Sonderstatus

Agentische Entwicklungsarchitektur entwerfen

Agent, Modell und Kontext
Tool Layer und Policy Layer
Entwicklungsumgebung und Quality Layer
externe Systeme und Trust Boundaries
Verifikations- und Eskalationsmechanismen
Autonomie, Risiko und Kontrolle zusammenführen

Praxis: kontrollierten Agentenworkflow entwickeln

Entwicklungsaufgabe und Risiken bestimmen
Kontext, Toolset und Berechtigungen festlegen
Tests und Quality Gates als Verifikation einrichten
Git oder Worktrees zur Isolation einsetzen
Fehler- und Prompt-Injection-Szenarien untersuchen
vollständigen Workflow ausführen und auswerten

03 Durchführung

Rahmen und Organisation

Dauer

3 Tage

Durchführung

Präsenz oder Live Online, vorzugsweise als Inhouse-Schulung

Schwerpunkt

Inhouse-Schulungen für Unternehmen und Teams

Sprache

Deutsch, englische Fachbegriffe und Dokumentation

Unterlagen

Kursunterlagen, Beispiele und Übungsaufgaben

Technik

Eigener Rechner mit Entwicklungsumgebung, Git und Zugang zu einem Coding Agent

Inhouse-Schulungen

Vorhandene Coding Agents, Repositories, CI/CD-Systeme, MCP-Server, Entwicklungswerkzeuge und unternehmensinterne Sicherheitsanforderungen können in die Übungen einbezogen werden.

04 Zielgruppe

Für wen ist der Kurs gedacht?

Der Kurs richtet sich an erfahrene Softwareentwickler, Softwarearchitekten, DevOps Engineers, Quality Engineers und technische Consultants, die Coding Agents nicht nur als persönliche Entwicklungshelfer einsetzen, sondern agentische Entwicklungsprozesse systematisch gestalten und kontrollieren möchten.

Er eignet sich insbesondere für Teams, die Entwicklungsaufgaben zunehmend an AI-Agenten delegieren und dafür belastbare technische Grenzen, Qualitätsmechanismen und Arbeitsabläufe etablieren wollen.

Voraussetzungen

Praktische Erfahrung in der Softwareentwicklung, Git und automatisierten Tests wird vorausgesetzt. Grundkenntnisse im Umgang mit generativer KI und AI-gestützter Softwareentwicklung sind hilfreich. Der Kurs setzt jedoch kein bestimmtes Coding-Agent-Produkt voraus.

05 Lernziele

Was Sie nach dem Kurs können

Nach dem Kurs können die Teilnehmer:

AI-Assistenten und AI-Agenten voneinander abgrenzen
geeignete Entwicklungsaufgaben für Agenten identifizieren
agentische Aufgaben mit klaren Zielen und Grenzen formulieren
komplexe Aufgaben in kontrollierbare Arbeitsschritte zerlegen
Kontext und persistentes Projektwissen bereitstellen
geeignete Tools für Agenten auswählen und gestalten
MCP als Tool-Schnittstelle einsetzen
Berechtigungen nach dem Least-Privilege-Prinzip definieren
Autonomie abhängig vom Risiko begrenzen
technische Guardrails und Kontrollpunkte entwickeln
Agenten durch Isolation und Sandboxing begrenzen
Git und Worktrees als Kontrollmechanismen einsetzen
Tests als ausführbare Spezifikation und Feedback verwenden
verbindliche Quality Gates etablieren
Subagents und Multi-Agent-Workflows einordnen
Prompt-Injection- und Tool-Risiken berücksichtigen
längere Agentenläufe beobachtbar und wiederaufnehmbar gestalten
Fehler-, Recovery- und Eskalationsstrategien definieren
einen produktneutralen agentischen Entwicklungsworkflow entwerfen und absichern

06 FAQ

Häufige Fragen

Was unterscheidet diesen Kurs von AI-assisted Software Development?

AI-assisted Software Development betrachtet den gesamten Entwicklungsprozess mit AI-Unterstützung. Der Entwickler führt dabei weiterhin den Prozess und verwendet KI für Analyse, Implementierung, Tests, Refactoring, Debugging und andere Aufgaben.

Dieser Kurs konzentriert sich dagegen auf Entwicklungsprozesse, in denen AI-Agenten mehrstufige Aufgaben selbstständig bearbeiten. Im Mittelpunkt stehen deshalb Tool-Nutzung, Berechtigungen, kontrollierte Autonomie, Guardrails, Isolation, Quality Gates, Zustandsmanagement und Orchestrierung.

Ist der Kurs auf Claude Code oder GitHub Copilot ausgerichtet?

Nein. Der Kurs behandelt produktneutrale Konzepte und Architekturen für agentische Softwareentwicklung. Konkrete Werkzeuge können für Übungen verwendet werden, sind aber nicht Gegenstand einer Produktschulung.

Werden Coding Agents praktisch eingesetzt?

Ja. Die Konzepte werden anhand praktischer Entwicklungsaufgaben erarbeitet. Entscheidend ist dabei nicht, möglichst viel Autonomie zu erreichen, sondern einen geeigneten und kontrollierbaren Autonomiegrad festzulegen.

Wird MCP behandelt?

Ja. MCP wird als eine Möglichkeit behandelt, Agenten strukturierte Werkzeuge und zusätzliche Informationsquellen bereitzustellen. Der Schwerpunkt liegt auf Tool-Grenzen, Berechtigungen und der Einordnung in die Gesamtarchitektur.

Werden Multi-Agent-Systeme behandelt?

Ja. Subagents und Multi-Agent-Workflows werden behandelt. Dabei wird auch untersucht, wann mehrere Agenten tatsächlich Vorteile bringen und wann sie lediglich zusätzliche Koordinationsprobleme erzeugen.

Geht es auch um Sicherheit?

Ja. Sicherheit ist ein wesentlicher Bestandteil agentischer Softwareentwicklung. Berechtigungen, Isolation, Secrets, externe Systeme, Prompt Injection und technisch erzwungene Guardrails werden deshalb ausführlich behandelt.

Warum reichen Prompt-Regeln für die Absicherung eines Agenten nicht aus?

Weil der Agent selbst Teil des zu kontrollierenden Systems ist. Kritische Grenzen sollten deshalb möglichst außerhalb des Modells durch Berechtigungen, Tool-Schnittstellen, Policies, Isolation und andere technische Mechanismen erzwungen werden.

Welche Rolle spielen Tests?

Eine zentrale. Tests können Anforderungen ausführbar machen und liefern einem Agenten objektives Feedback über seine Änderungen. Sie ersetzen jedoch weder die Prüfung der Testqualität noch weitere Quality Gates und Reviews.

Brauche ich AI-assisted Software Development vor diesem Kurs?

Nicht zwingend. Erfahrung mit AI-gestützter Softwareentwicklung ist hilfreich. Teilnehmer mit praktischer Entwicklungserfahrung und grundlegendem Verständnis generativer KI können direkt einsteigen.

Warum dauert der Kurs drei Tage?

Der Kurs verzichtet bewusst auf die breite Behandlung von Codegenerierung, Refactoring, Debugging und Dokumentation. Die drei Tage konzentrieren sich stattdessen auf Agentenarchitektur, Tools, Berechtigungen, Verifikation, Security und praktische agentische Workflows.

Kann der Kurs an unsere Entwicklungsumgebung angepasst werden?

Ja. Bei Inhouse-Schulungen können vorhandene Coding Agents, Repositories, CI/CD-Systeme, MCP-Server, Entwicklungswerkzeuge und unternehmensinterne Sicherheitsanforderungen in die Übungen einbezogen werden.

Schulung anfragen