Zum Hauptinhalt springen
Arbeiten mit Agenten: Wie KI-Rollentrennung Struktur und Skalierbarkeit in agile Projekte bringt
#KI #Agenten #Agil #Workflow #Rollentrennung

Arbeiten mit Agenten: Wie KI-Rollentrennung Struktur und Skalierbarkeit in agile Projekte bringt

Warum spezialisierte KI-Agents agile Workflows produktiver und kontrollierbarer machen

Der Einsatz von KI in der Softwareentwicklung beschränkt sich längst nicht mehr auf einzelne Code-Snippets oder spontane Unterstützung im Editor. Moderne Tools ermöglichen es, KI-Systeme in spezialisierte Rollen aufzuteilen – sogenannte Agents, die in einem strukturierten, arbeitsteiligen Prozess eingesetzt werden. Damit lässt sich ein agiler Workflow nachbilden, bei dem Künstliche Intelligenz nicht nur mitarbeitet, sondern sich wie ein echtes Teammitglied verhält.

Was sind KI-Agents in diesem Kontext?

Ein Agent ist eine spezialisierte KI-Instanz mit einem definierten Aufgabengebiet. Er arbeitet im Rahmen eines festen Kontexts und folgt klaren Regeln – ähnlich wie ein Mitglied eines realen Softwareteams. Jede Rolle bringt dabei ihren eigenen Fokus und ihre eigene Sichtweise mit. Beispiele für typische Agentenrollen:

  • PM-Agent (Product Manager): Unterstützt bei der Ausarbeitung von Stories, Feature-Beschreibungen und Roadmaps.
  • Dev-Agent (Entwickler): Setzt Aufgaben aus einer Story technisch um, erzeugt Code oder Module.
  • Review-Agent (Tester oder QA): Prüft die Umsetzung, testet Funktionen, erkennt Schwächen und schlägt Verbesserungen vor.
  • Scrum-Master-Agent: Optional, aber hilfreich zur Verwaltung von Status, Fortschritt und Zyklen im Entwicklungsprozess.

Diese Agents laufen nicht parallel, sondern nacheinander – jeweils phasenweise, entlang eines klassischen agilen Entwicklungszyklus: Planen → Umsetzen → Testen → Abschließen.

Integration in einen agilen Workflow

Der typische Ablauf in einem Agenten-gesteuerten Projekt orientiert sich stark an agilen Methoden. Die Zusammenarbeit zwischen Mensch und KI erfolgt in klar abgegrenzten Schritten:

1. Anforderung / Planung

  • Der Mensch beschreibt eine grobe Produkt- oder Feature-Idee.
  • Der PM-Agent erstellt daraus strukturierte Stories mit Akzeptanzkriterien.
  • Optional hilft ein Architekt-Agent bei der Aufstellung der technischen Struktur.
  • Ergebnis: markdown-basierte Dateien wie stories.md.

2. Genehmigung & Priorisierung

  • Der Mensch prüft die Vorschläge, setzt einzelne Stories auf status: approved.
  • Bei Bedarf werden Stories gruppiert, Epics gebildet, Prioritäten gesetzt.

3. Umsetzung

  • Der Dev-Agent wird gestartet, z. B. über Cursor oder Claude CLI.
  • Er liest die zugehörige tasks.md-Datei und arbeitet die Subtasks ab.
  • Ergebnis: konkrete Komponenten, Module oder Services im jeweiligen Stack.
  • Die Story wird anschließend auf review gesetzt.

4. Testing & Review

  • Der Review-Agent übernimmt die Prüfung anhand der definierten Akzeptanzkriterien.
  • Er vergleicht Anforderungen mit dem gelieferten Code, testet Logik und Struktur.
  • Sind alle Punkte erfüllt, wird der Status auf done gesetzt.
  • Ansonsten erfolgt Rückmeldung zur Nachbesserung.

5. Iteration

  • Der Zyklus beginnt erneut mit der nächsten Story oder Epic.

Praktische Umsetzung mit Tools wie Cursor oder Claude CLI

In Cursor (einer KI-integrierten Entwicklungsumgebung) können Agenten über sogenannte Rule-Dateien aktiviert werden. Ein einfacher Eingabebefehl wie DEV lädt die passende Agenten-Konfiguration (dev.rule). Anschließend wird z. B. die Datei story-1-1-tasks.md aus dem Verzeichnis tasks/ eingelesen und verarbeitet.

In Claude CLI oder Tools wie ChatGPT geschieht das über gezielte Anweisungen im Prompt. Beispiel:

Sie sind der Entwickler-Agent. Ihre Aufgabe ist es, die folgenden Aufgaben aus story-1-1-tasks.md umzusetzen. Halten Sie sich exakt an die Aufgabenstruktur. Verwenden Sie Astro + Svelte.

Wichtig: Jeder Agent sollte in einem eigenen Chat oder Prozess laufen, um Kontextkonflikte zu vermeiden. So kann parallel mit mehreren Rollen gearbeitet werden:

  • Chat 1: Dev-Agent arbeitet an einer Story
  • Chat 2: Review-Agent prüft den Fortschritt
  • Chat 3: PM-Agent plant die nächsten Stories

Warum sich die Trennung in Agents bewährt

Die gezielte Rollentrennung zwischen den KI-Agenten bringt eine ganze Reihe an Vorteilen mit sich – sowohl technisch als auch organisatorisch:

1. Reduzierter Kontextbedarf

  • Jeder Agent verarbeitet nur den für ihn relevanten Input. Das spart Tokens, vermeidet abgeschnittene Kontexte und erhöht die Zuverlässigkeit der Antworten.

2. Klare Zuständigkeiten

  • Wie in echten Teams denken die Agenten nur in ihrem Bereich. Dadurch gibt es keine Zielkonflikte – der Entwickler-Agent muss keine Produktentscheidungen treffen, der Review-Agent schreibt keinen neuen Code.

3. Modularität und Wiederverwendbarkeit

  • Einmal definierte Agenten (z. B. über Regeldateien) können projektübergreifend genutzt werden. Stories, Tasks und Rollen bleiben systematisch voneinander getrennt.

4. Skalierbarkeit

  • Mehrere Stories können parallel bearbeitet werden – durch separate Agenteninstanzen. Das beschleunigt die Umsetzung, besonders in Kombination mit menschlichem Projektmanagement.

5. Fehlerlokalisierung

  • Fehlverhalten lässt sich auf einen konkreten Agenten zurückführen. Wenn die Umsetzung fehlschlägt, ist klar, ob es an der Story, der Logik oder dem Review lag.

6. Entlastung der Steuerung

  • Der Mensch muss nicht alle Aufgaben in einem überladenen Prompt-Chat verwalten. Jede Rolle hat ihren Kanal, jede Antwort ihren Kontext.

7. Integration in reale Teamstrukturen

  • Diese Arbeitsweise ist anschlussfähig – auch in hybriden Teams mit menschlichen Entwicklern. Die Rollenverteilung entspricht agilen Methoden wie Scrum oder Kanban.

8. Kontextspezifische Regeln

  • Jeder Agent hat seine eigenen Vorgaben – z. B. Stilrichtlinien für den Code, Architekturprinzipien oder Sicherheitsanforderungen. Das erhöht Konsistenz und Qualität.

9. Zuverlässigere Antworten

  • Durch Fokus auf die eigene Aufgabe „halluziniert“ die KI seltener. Rollenverwechslungen oder widersprüchliche Antworten werden vermieden.

10. Automatisierbare Routinen

  • Wiederkehrende Abläufe wie Testing, Refactoring oder Dokumentation können automatisiert über eigene Agentenrollen abgedeckt werden.

Praktische Umsetzung: So arbeiten Agents im Projektalltag

Die Trennung in Agenten zeigt ihre Stärken erst im konkreten Einsatz. Ein typischer Arbeitszyklus mit einem Feature könnte wie folgt ablaufen:

Beispiel: Feature „Aufgaben anlegen“

In der Datei stories.md wird eine neue Story notiert:

## Story 1.1 – Aufgaben anlegen

Status: approved
Ziel: Nutzer können neue Aufgaben mit Titel und Beschreibung anlegen.

Dazu wird die Datei tasks/story-1-1-tasks.md erstellt:

- [ ] Komponente `TaskForm.svelte` erstellen
- [ ] Titel ist Pflichtfeld
- [ ] Abspeichern in localStorage

Dev-Agent starten (z. B. in Cursor):

In der IDE wird DEV eingegeben → Cursor lädt die Datei dev.rule. Anschließend der Befehl:

Bearbeite tasks/story-1-1-tasks.md

Der Agent beginnt mit dem ersten Task:

Ich beginne mit dem Aufbau der Svelte-Komponente TaskForm.svelte…

Output & Integration:

Die KI erzeugt den Code und schlägt ggf. weitere Dateien oder Strukturierung vor.

Beispiel-Code:

<script>
  let title = '';
  function submit() {
    if (!title) return;
    localStorage.setItem('tasks', JSON.stringify([{ title }]));
  }
</script>

Nach Abschluss wechselt der Mensch (oder automatisiert) den Status:

Status: review

Review-Agent übernehmen lassen:

Start des Review-Chats oder Agents mit:

Sie sind der Review-Agent. Prüfen Sie, ob TaskForm.svelte die Akzeptanzkriterien aus story-1-1 erfüllt.

Die KI prüft: Ist title ein Pflichtfeld? Wird in localStorage gespeichert? Ist die UI funktionsfähig?

Bei Erfolg → Status auf done. Bei Fehlern → Review-Agent gibt Korrekturvorschläge aus, z. B.:

Es fehlt eine visuelle Fehlermeldung, wenn das Titel-Feld leer ist.

Beobachtungen aus der Praxis

  • Getrennte Chats oder Tabs sparen Nerven. Dev, Review und PM laufen am besten isoliert. Sonst überschreiben sich Kontexte.
  • Tasks dürfen nicht zu allgemein sein. Formulierungen wie „Implementiere die gesamte UI“ überfordern die Agenten. Besser: maximal 5–7 präzise Subtasks.
  • Stabilität durch Klarheit. Die meisten Fehler traten auf, wenn Story und Tasks nicht sauber synchronisiert waren (z. B. Akzeptanzkriterien fehlen oder widersprüchlich sind).
  • Iterationen funktionieren. Ein Review-Agent kann direkt Refactoring-Vorschläge liefern und diese durch den Dev-Agent umsetzen lassen. Der Mensch muss das nur koordinieren.
  • Rollenkonflikte vermeiden. Wenn ein Agent zu viele Aufgaben übernimmt, wird die Ausgabe unzuverlässig. Das strikte Halten an Rollen ist keine Einschränkung, sondern ein Vorteil.

Ein letzter Gedanke

Ein KI-Agent ist kein Alleskönner, sondern ein verlässlicher Spezialist – wenn er klar geführt wird. Die Praxis zeigt: Mit der richtigen Struktur, sauber getrennten Rollen und präzise vorbereiteten Aufgaben lässt sich ein produktionsnaher Entwicklungsprozess realisieren.

Das System verlangt Disziplin, liefert dafür aber reproduzierbare Ergebnisse, nachvollziehbare Fortschritte und eine Skalierbarkeit, die mit reiner Einzelarbeit nicht zu erreichen ist.

Die Agenten liefern. Aber nur, wenn man sie lässt – in ihrer jeweiligen Rolle.