Von Geschichten zu Systemen: Use-Case 2.0 für agiles und KI-getriebenes Entwickeln meistern

Einführung

In der sich rasch entwickelnden Landschaft der Softwareentwicklung ist der Widerspruch zwischen Agilität und Struktur seit langem eine zentrale Herausforderung. Jahrzehntelang haben Teams zwischen umfangreichen Dokumentationen, die Vollständigkeit gewährleisten, aber die Geschwindigkeit hemmen, und leichtgewichtigen Nutzerstories, die Geschwindigkeit fördern, aber oft Kontext opfern, hin- und hergewogen. Je komplexer die Systeme werden und je größer die Nachfrage nach schneller Lieferung ist, reicht keines der beiden Extremen allein aus.

Eintreten von Use-Case 2.0: eine moderne Weiterentwicklung der Anforderungsanalyse, die diese Lücke schließt. Geboren aus den Grundprinzipien traditioneller Use-Cases, aber neu gedacht im Licht agiler Methoden wie Scrum und Kanban, bietet Use-Case 2.0 einen leichtgewichtigen, aber skalierbaren Ansatz zur Erfassung von Nutzerbedürfnissen. Es verbindet die Einfachheit von Nutzerstories mit der umfassenden Struktur von Use-Cases und liefert Teams eine klare Wegleitung von hochwertigen Zielen bis hin zur detaillierten Umsetzung.

Diese Fallstudie untersucht, wie Use-Case 2.0 die Anforderungserhebung, das Design und die Entwicklung verändert. Indem wir ihre Kernprinzipien, praktische Anwendung und Synergie mit neu entstehenden KI-gestützten Entwicklungstools analysieren, zeigen wir, wie diese Methode es Teams ermöglicht, das richtige System effizient zu bauen, wodurch Wertlieferung bei jedem Schritt gewährleistet wird.

---

Die Entwicklung der Anforderungsanalyse

Fast dreißig Jahre lang haben Use-Cases als Eckpfeiler der Anforderungsanalyse gedient und Teams dabei unterstützt, zu verstehen, wie Nutzer mit Systemen interagieren, um ihre Ziele zu erreichen. Sie haben viele moderne Techniken inspiriert, darunter Nutzerstories. Doch in den letzten Jahren ist etwas Erstaunliches geschehen – die Inspiration fließt nun in die andere Richtung.

Use-Case 2.0 ist die neue Generation der use-case-getriebenen Entwicklung – leicht, agil und schlank – inspiriert von Nutzerstories und agilen Methoden wie Scrum und Kanban. Sie stellt eine bedeutende Weiterentwicklung der traditionellen Use-Case-Praktiken dar und verbindet die Einfachheit und Fokussierung von Nutzerstories mit der umfassenden Struktur und Skalierbarkeit, die Use-Cases stets geboten haben.

„Use-Case 2.0 vereint alle beliebten Werte der Vergangenheit – nicht nur die Unterstützung von Anforderungen, sondern auch Architektur, Design, Test und Benutzererfahrung – und ist entscheidend für die Geschäftsmodellierung und Software-Wiederverwendung.“

Was macht Use-Case 2.0 anders?

Die traditionelle Use-Case-Methode bestand darin, detaillierte Use-Case-Dokumente zu erstellen, die das Systemverhalten erfassen, einschließlich kurzer Beschreibungen, Voraussetzungen, Nachbedingungen und Interaktionen zwischen Akteuren. Obwohl dies effektiv war, wurde dieser Ansatz oft zu dokumentationsintensiv und hatte Schwierigkeiten, sich an die schnelle Iteration agiler Entwicklung anzupassen.

Use-Case 2.0 baut auf dieser Grundlage auf und führt mehrere Innovationen ein:

• Agile Ausrichtung: Nahtlose Integration mit agilen Methoden, die es Entwicklerteams erleichtert, mit Stakeholdern zusammenzuarbeiten, Anforderungen zu zerlegen und schnell zu iterieren

• Integration von Nutzerstories: Einbindung von Nutzerstories als leichtgewichtige Methode zur Erfassung von Nutzerbedürfnissen und Aufbau gemeinsamen Verständnisses

• Use-Case-Slices: Aufteilung komplexer Use-Cases in kleinere, handhabbare Einheiten, die unabhängig implementiert und getestet werden können

• Visuelle Modelle: Fokus auf Flussdiagramme, Aktivitätsdiagramme und Sequenzdiagramme zur umfassenden Systemverständnis

• Iterative Entwicklung: Testen jedes Komponenten, sobald es erstellt ist, was eine frühzeitige Problemerkennung ermöglicht

Im Kern führt Use-Case 2.0 ein entscheidendes neues Konzept ein: den Use-Case-Slice. Ein Slice ist ein sorgfältig ausgewählter Teil eines Use-Cases, der unabhängig bearbeitet werden kann – er durchschneidet nicht nur Anforderungen, sondern auch Design, Implementierung, Testfälle und Testergebnisse.

Abbildung 1: Visuelle Darstellung der Use-Case-2.0-Struktur, die die Beziehung zwischen Akteuren, Use-Cases und Slices zeigt.

---

Die Sechs Prinzipien von Use-Case 2.0

Ivar Jacobson, Ian Spence und Kurt Bittner identifizierten sechs grundlegende Prinzipien, die die Grundlage für den erfolgreichen Einsatz von Use-Cases bilden:

1. Halte es einfach, indem du Geschichten erzählst

Geschichten erzählen ist die einfachste und effektivste Art, zu kommunizieren, was ein System tun soll. Use-Cases erfassen die Ziele des Systems, während Geschichten beschreiben, wie diese Ziele erreicht werden und wie Probleme entlang des Weges bewältigt werden. Dadurch können Anforderungen leicht erfasst, geteilt und verstanden werden.

2. Verstehe das große Ganze

Unabhängig davon, ob Ihr System groß oder klein ist, ist das Verständnis des Gesamtbildes unerlässlich. Ohne diese Übersicht können Teams keine richtigen Entscheidungen bezüglich Umfang, Kosten oder Wert treffen. Ein Use-Case-Diagramm bietet eine einfache Möglichkeit, eine Übersicht über die Anforderungen eines Systems darzustellen – es zeigt alle Möglichkeiten, wie das System genutzt werden kann, wer die Interaktion startet, und alle anderen beteiligten Parteien.

Abbildung 2: Ein Beispiel für ein Use-Case-Diagramm, das Akteure und ihre Interaktionen mit dem System veranschaulicht.

3. Konzentriere dich auf Wert

Wert entsteht erst, wenn ein System tatsächlich genutzt wird. Anstatt sich auf lange Listen von Funktionen oder Features zu konzentrieren, legen Use-Cases den Fokus darauf, wie das System genutzt wird, um spezifische Ziele für bestimmte Benutzer zu erreichen. Der Hauptablauf beschreibt die einfachste Art, das Ziel zu erreichen, während alternative Abläufe Optionen und Fehlerbehandlung hinzufügen. Teams können den Hauptablauf zuerst bereitstellen und später Alternativen hinzufügen – dies ist bewusst additiv gestaltet.

4. Baue das System in Scheiben

Die meisten Systeme erfordern umfangreiche Arbeit, bevor sie nutzbar sind. Es ist ein Fehler, versuchen zu wollen, ein solches System auf einen Schlag zu bauen. Stattdessen sollten Systeme in Scheiben aufgebaut werden, wobei jede Scheibe klaren Nutzen für die Benutzer liefert.

Das Rezept ist einfach:

1. Identifiziere die nützlichste Funktion, die das System erfüllen muss

2. Teile es in dünnere, handhabbare Scheiben

3. Definiere Testfälle, die die Akzeptanz dieser Scheiben repräsentieren

4. Wähle die zentralste Scheibe, die das gesamte Konzept durchzieht

5. Schätze es gemeinsam als Team ein und fange an zu bauen

5. Liefere das System in Schritten

Software-Systeme entwickeln sich über mehrere Generationen und Releases hinweg. Jeder Schritt sollte eine nachweisbare oder nutzbare Version des Systems liefern. Use-Case 2.0 unterstützt dies, indem Use-Cases in Arbeitsaufgaben aufgeteilt werden, die zu Schritten zusammengestellt und schließlich zu Releases zusammengefügt werden können.

6. Passe dich an die Bedürfnisse des Teams an

In der Softwareentwicklung gibt es keine allgemein gültige Lösung. Unterschiedliche Teams und Situationen erfordern unterschiedliche Stile und unterschiedliche Detailgrade. Use-Case 2.0 kann so leicht sein, wie gewünscht – kleine, kooperative Teams können leichtgewichtige Use-Case-Geschichten auf einfachen Indexkarten verwenden, während große, verteilte Teams detailliertere Dokumente nutzen können.

---

Die Anatomie von Use-Case 2.0: Scheiben, Szenarien und Aufgaben

Drei zentrale Konzepte definieren, wie Use-Case 2.0 in der Praxis funktioniert:

Use-Case-Scheibensind kleinere, besser handhabbare Komponenten eines Use-Cases. Anstatt einen gesamten Use-Case in einem Dokument zu definieren, teilt Use-Case 2.0 ihn in Scheiben auf, die einfacher zu entwerfen, zu entwickeln und zu testen sind. Jede Scheibe stellt eine spezifische Funktionalität dar, die das System erfüllen muss, um eine bestimmte Benutzer-Aufgabe oder ein Ziel zu unterstützen.

Szenarienstellen die verschiedenen Wege dar, die Benutzer innerhalb einer Scheibe nehmen könnten, um Aufgaben zu erledigen:

• Normaler Pfad: Die erwartete oder Standardfolge von Operationen (der „glückliche Pfad“)

• Alternative Pfade: Variationen oder verschiedene Wege, um dasselbe Ziel zu erreichen

• Ausnahmepfade: Fehler oder ungewöhnliche Situationen, die auftreten können

Aufgabensind die spezifischen Aktionen, die Benutzer innerhalb einer Szenario ausführen müssen, um ein Ziel zu erreichen. Sie stellen die einzelnen Schritte dar, aus denen eine Szenario besteht.

Zum Beispiel in einem Use-Case-Slice „Produkte durchsuchen“ einer E-Commerce-Plattform:

• Normalpfad: Benutzer sucht, sieht Ergebnisse an, wählt Produkt aus, fügt es in den Warenkorb hinzu und geht zur Kasse

• Alternativer Pfad: Benutzer wählt eine andere Zahlungsmethode (PayPal statt Kreditkarte)

• Ausnahmepfad: Zahlung wird abgelehnt, weil nicht ausreichend Mittel vorhanden sind oder die Rechnungsadresse falsch ist

 

Abbildung 3: Detaillierte Aufschlüsselung eines Use-Case-Slices, der Normalpfad, alternativer Pfad und Ausnahmepfad zeigt.

---

Use-Cases im Vergleich zu User-Stories: Warum beide wichtig sind

Genau hier bietet Use-Case 2.0 eine überzeugende Lösung für eine häufige Agile-Herausforderung.

Eine User-Story ist ein eigenständiges Element – sie hat keine eingebaute Beziehung zu anderen Stories. Ein Product-Backlog mit 200 User-Stories wird ohne zusätzliche Gruppierungsmechanismen wie Epics oder Themen schwer zu navigieren. Stories können ihren Kontext verlieren, und Teams verfassen Akzeptanztests oft zu spät.

Ein Use-Case ist anders. Er gruppiert alle verwandten Stories unter einem Ziel, mit:

• Ein klares Ziel (der Use-Case selbst)

• Ein schrittweiser Ablauf (der Grundablauf)

• Definierte Variationen (alternative Abläufe)

• Akzeptanzkriterien (Testfälle)

Wenn Sie einen Use-Case betrachten, sehen Sie das vollständige Bild davon, wie ein Benutzer ein bestimmtes Ziel erreicht, nicht nur ein einzelnes Fragment.

Abbildung 4: Vergleichsdiagramm, das die Unterschiede und die ergänzende Natur von User-Stories und Use-Cases hervorhebt.

---

Use-Case 2.0 in der agilen Praxis: Praxisbeispiele

Use-Case 2.0 bietet Struktur für agile Teams, die mit häufigen Herausforderungen konfrontiert sind:

E-Commerce-Plattform: Use-Cases für ein Online-Einkaufssystem umfassen Produkte durchsuchen, Produkte suchen, in Warenkorb hinzufügen, zur Kasse gehen und Bezahlen. Das frühe Use-Case-Diagramm zeigt fehlende Abläufe auf – wie beispielsweise „Gast-Kasse“ –, die vor der Sprint-Zusage hinzugefügt werden können, um Abbrüche im Warenkorb in der Produktion zu verhindern.

Mobile-Banking-App: Die Dokumentation alternativer Abläufe wie „ungültige Anmeldeinformationen → mehrfaktoriger Fallback“ erfasst Sicherheitslücken frühzeitig, vermeidet kostspielige Patches nach der Markteinführung und stärkt das Vertrauen der Benutzer.

Dienst für Fahrgemeinschaften: Use-Case-Slices treiben die Entwicklung des Minimum Viable Products (MVP) voran – beginnen Sie mit Anfrage, Annahme und Bezahlung; fügen Sie später Bewertungen und Beschwerden hinzu. Dies ermöglicht eine schnelle Wertlieferung mit klarer Priorisierung.

Plattform für Gesundheitsterminen: Die Überprüfung der Use-Case-Flüsse durch Stakeholder bringt Anforderungen im Bereich „Nichterscheinen“ ans Licht. Eine automatisierte Umräumung kann hinzugefügt werden und könnte verpasste Termine potenziell reduzieren.

Abbildung 5: Beispiel für ein agiles Team, das Use-Case-Slices nutzt, um Sprints zu planen.

---

Die Verbindung mit KI: Use-Case 2.0 trifft auf KI-unterstützte Entwicklung

Use-Case 2.0 wurde ursprünglich 2011 entwickelt, lange bevor KI-Coding-Assistenten existierten. Doch seine Prinzipien erweisen sich als perfekte Passung für die KI-unterstützte Entwicklung.

KI-Coding-Assistenten arbeiten am besten mit klaren, strukturierten Spezifikationen. Ein Use-Case bietet:

• Ein klares Ziel, das die KI verstehen kann

• Eine schrittweise Abfolge, die die KI umsetzen kann

• Definierte Abweichungen, die die KI handhaben kann

• Akzeptanzkriterien, die die KI erfüllen muss

Die vier Phasen der KI-unterstützten Entwicklung passen naturgemäß zu den Prinzipien von Use-Case 2.0:

• Entstehung → „Das große Ganze verstehen“ – erstellen Sie Geschäftsanforderungen und erste Use-Case-Diagramme

• Ausarbeitung → „Auf Wert fokussieren“ – erstellen Sie Spezifikationen mit Grund- und Alternativabläufen

• Aufbau → „Das System in Scheiben aufbauen“ – mit KI kann die Arbeitseinheit die gesamte Use-Case-Spezifikation sein, nicht nur eine Scheibe

• Übergang → „Das System in Schritten liefern“ – die Benutzerakzeptanzprüfung bestätigt, dass Use-Cases die Bedürfnisse der Stakeholder erfüllen

Abbildung 6: Darstellung, wie KI-Assistenten in Use-Case-2.0-Workflows integriert werden.

---

Einstieg in Use-Case 2.0

Sie müssen die gesamte Use-Case-2.0-Praxis nicht sofort übernehmen. Beginnen Sie mit drei Dingen:

1. Zeichnen Sie ein Use-Case-Diagramm — Identifizieren Sie die Akteure und Use-Cases für Ihr System. Das dauert 30 Minuten und gibt Ihnen das große Ganze.

2. Schreiben Sie eine Use-Case-Erzählung — Wählen Sie den wichtigsten Use-Case aus. Schreiben Sie den Grundablauf als Aufzählung. Listen Sie die Alternativabläufe zunächst nur als Namen auf.

3. Implementieren Sie Ihren ersten Use-Case — Ob Sie manuelle Entwicklung oder KI-Unterstützung nutzen, lassen Sie den Use-Case Ihre Implementierung leiten.

Sie können Anwendungsfälle in einer einfachen Tabellenkalkulation oder auf Post-it-Notizen verfolgen. Keine speziellen Werkzeuge sind erforderlich, um mit Use-Case 2.0 zu beginnen.

---

Fazit

Use-Case 2.0 ist keine Alternative zu Nutzergeschichten – es ist eine Ergänzung. Anwendungsfälle geben Ihnen das große Ganze und die Struktur. Testfälle liefern Ihnen eine klare Definition des Abschlusses. Bei manueller Entwicklung liefern Slices die passend dimensionierten Arbeitspakete.

Der entscheidende Erkenntnis ist, dass Anwendungsfälle die Techniken der Nutzergeschichten enthalten, gleichzeitig aber erheblich mehr für größere Systeme, größere Teams und komplexere Entwicklungen bieten. Sie sind so leichtgewichtig wie Nutzergeschichten, können sich aber nahtlos und strukturiert skalieren, um so viel Detail aufzunehmen, wie erforderlich ist. Vor allem treiben und verbinden sie viele andere Aspekte der Softwareentwicklung.

In einer Ära, in der KI die Art und Weise verändert, wie wir Software entwickeln, bietet Use-Case 2.0 die strukturierte, nutzerzentrierte Grundlage, die sicherstellt, dass wir das richtige System bauen – nicht nur ein System, das funktioniert. Durch die Annahme dieser entwickelten Methodik können Teams mehr Klarheit, Effizienz und Wertlieferung in ihren Agile-Reisen erreichen.

---

Quellen

1. Use-Case 2.0: Die agile Evolution der Anforderungsingenieurwesen: Umfassender Überblick über die Prinzipien und Praktiken von Use-Case 2.0.

2. Integration von Anwendungsfällen mit agilen Methoden: Leitfaden zur Kombination von Anwendungsfällen mit Scrum und Kanban.

3. Die Kraft von Use-Case-Slices: Detaillierte Erklärung der Slicing-Techniken in Use-Case 2.0.

4. KI-unterstützte Entwicklung und strukturierte Anforderungen: Untersuchung, wie KI-Tools von strukturierten Anwendungsfällen profitieren.

5. Visuelle Modellierung in agilen Projekten: Best Practices für die Verwendung von Diagrammen in agilen Umgebungen.