Das Problem: Eine Software-Idee zu haben ist eine Sache – zwischen “Ich will eine App” und funktionierender Software liegen jedoch hunderte von Entscheidungen, Tasks und Abhängigkeiten. KI-Tools helfen beim Coden, doch wie lassen sich komplexe Anforderungen so strukturieren, dass KI sie effektiv umsetzen kann?

Die Lösung: Agile Methoden + KI-Unterstützung. Statt chaotisch zu entwickeln, werden Anforderungen systematisch in Epics → Stories → Tasks zerlegt. KI-Tools übernehmen dann nicht nur das Coding, sondern helfen auch beim Strukturieren, Planen und Validieren.

Das Ergebnis: Ein strukturierter Entwicklungsprozess, in dem KI als “virtuelles Team” fungiert – mit klaren Rollen, Verantwortlichkeiten und Qualitätschecks. Wie das in der Praxis funktioniert, zeigt dieser Artikel.

---

Vom Feature zur Struktur

Ausgangspunkt ist eine komplexe, meist noch wenig strukturierte Anforderung. Zum Beispiel:

„Eine Produktivitäts-App für iOS, mit Aufgabenlisten, Priorisierung und Filterfunktionen.“

Problem: Diese Beschreibung ist viel zu vage für KI-Tools. Was ist “Priorisierung”? Welche Filter? Wie sieht die Benutzeroberfläche aus?

Lösung: KI-gestützte Requirement-Analyse. Die KI (ChatGPT, Claude, Gemini) erhält die grobe Idee und stellt systematisch Nachfragen:

KI-Prompt: "Hilf mir dabei, diese App-Idee zu strukturieren: 
[Idee hier einfügen]. Stelle gezielte Fragen zu:
- Zielgruppe und Use Cases
- Kernfunktionen vs. Nice-to-have
- Technische Constraints
- MVP-Abgrenzung"

Ergebnis: Aus vagen Ideen entstehen strukturierte Anforderungen mit klaren Prioritäten.

Das Resultat ist eine Versionierung des Projekts in Ausbaustufen (z. B. MVP, Version 2) und eine Gliederung in funktionale Bereiche, sogenannte Epics. Jeder Epic wiederum wird in einzelne Stories aufgeteilt. Diese Stories beschreiben unabhängig umsetzbare Funktionsblöcke – etwa „Aufgaben anlegen“, „Aufgaben filtern“ oder „Dark Mode aktivieren“.

Prompt-Template für Story-Breakdown

Eine Copy-Paste-Vorlage für den sofortigen Einstieg:

Ich arbeite an [PROJEKT-BESCHREIBUNG]. 
Hilf mir, folgendes Feature zu zerlegen: [FEATURE-NAME].

Erstelle für mich:

**1. Eine User Story im Format:**

"Als [Rolle] möchte ich [Funktion], damit [Nutzen]"

**2. 5-7 klare Akzeptanzkriterien im Format:**

- ✅ [Messbares Kriterium]

**3. 3-5 konkrete technische Tasks zur Umsetzung:**

- [ ] [Spezifische Aufgabe mit Dateiname/Komponente]

**4. Eine Definition of Done:**

- Code ist geschrieben und getestet
- [Weitere projekt-spezifische Kriterien]

**5. Potenzielle Risiken oder Abhängigkeiten**

Tipp: Die Platzhalter „[PROJEKT-BESCHREIBUNG]“ und „[FEATURE-NAME]“ anpassen – schon entstehen strukturierte Stories.

---

Strukturierte Ausarbeitung durch die KI

Ausgehend von den Stories erstellt die KI nun das eigentliche Arbeitsgerüst: Jede Story wird mit Ziel, Rahmenbedingungen und Akzeptanzkriterien versehen und in Markdown-Dateien dokumentiert. Ein typischer Aufbau einer Story-Datei könnte wie folgt aussehen:

# Story 1.1 – Aufgaben anlegen

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

User Story: "Als Nutzer möchte ich eine neue Aufgabe erstellen können, 
damit ich meine To-dos digital verwalten kann."

Akzeptanzkriterien:
- ✅ Eingabefelder für Titel (Pflicht) und Beschreibung (optional)
- ✅ Speicherung in localStorage nach Absenden
- ✅ Formular wird nach erfolgreichem Absenden geleert
- ✅ Neue Aufgabe erscheint sofort in der Liste
- ✅ Fehlermeldung bei leerem Titel

Definition of Done:
- Code ist geschrieben und getestet
- UI funktioniert auf Mobile + Desktop
- localStorage-Integration funktioniert

Warum so detailliert? KI-Tools brauchen präzise Vorgaben. Je klarer die Akzeptanzkriterien, desto besser der generierte Code.

Je nach Setup erfolgt die weitere Zerlegung in untergeordnete Aufgaben (tasks.md), die anschließend durch KI-Agenten abgearbeitet werden können.

Workflow-Visualisierung

So sieht der typische Ablauf von Epic zu Tasks aus:

graph TD
    A[Epic: Aufgabenverwaltung] --> B[Story 1.1: Aufgaben erstellen]
    A --> C[Story 1.2: Als erledigt markieren]
    A --> D[Story 1.3: Aufgaben löschen]
    B --> E[Task: TaskForm.svelte]
    B --> F[Task: Validierung]
    B --> G[Task: localStorage]
    C --> H[Task: Checkbox UI]
    C --> I[Task: Status speichern]
    D --> J[Task: Lösch-Button]
    D --> K[Task: Bestätigung]

Konkrete Tools für diesen Workflow:

Für Requirement-Analyse & Story-Erstellung:

• ChatGPT/Claude: Strukturierte Dialoge für Anforderungsanalyse
• Notion/Obsidian: Dokumentation von Stories und Tasks
• Linear/Jira: Professionelles Issue-Tracking (für Teams)

Für Code-Implementation:

• Cursor: IDE mit KI-Integration für Story-basierte Entwicklung
• GitHub Copilot: Code-Generierung basierend auf Kommentaren/Stories
• Replit: Browser-basierte Entwicklung mit KI-Support

Tool-Vergleich im Überblick

Tool	Best For	Preismodell	Integration	Empfehlung
Cursor	Story-based Development, Code-Generierung	~$20/Monat	VS Code Fork, standalone	⭐⭐⭐⭐⭐ Für Entwicklung
Claude CLI	Automated Tasks, Batch-Processing	Pay-per-use	Terminal, Scripts	⭐⭐⭐⭐ Für Automation
GitHub Copilot	Code Completion, inline Suggestions	$10/Monat	VS Code, JetBrains	⭐⭐⭐⭐ Für Daily Coding
ChatGPT Plus	Requirement Analysis, Planning	$20/Monat	Web, API	⭐⭐⭐⭐⭐ Für Planung
Replit	Prototyping, Quick Tests	Free/Pro	Browser-based	⭐⭐⭐ Für MVPs
Linear	Issue Tracking, Team Collaboration	Free/Team	Web, API	⭐⭐⭐⭐ Für Teams

---

Emulierte Teamarbeit mit klaren Rollen

Die darauf aufbauende Arbeitsweise ahmt agile Teamarbeit nach: Der Mensch formuliert Anforderungen, gibt Feedback und prüft Ergebnisse. Die KI übernimmt die Umsetzung, das Testing und – bei richtiger Konfiguration – auch Refactoring und Review. Diese Arbeitsteilung orientiert sich an etablierten Rollen im Entwicklungsprozess:

• Produktverantwortung: Anforderungen formulieren, Stories freigeben
• Entwicklung: Tasks abarbeiten, Story-Inhalte umsetzen
• Review: Ergebnisse prüfen und Feedback liefern

Jede Story durchläuft klar definierte Zustände: draft → approved → in progress → review → done. Diese Statusänderungen steuern den Fortschritt und die Verantwortungsübergabe zwischen Mensch und Maschine.

---

Testing, Review und Feedback-Loops

Nach Abschluss einer Story übernimmt ein Review-Agent oder Testprozess die Validierung. Dieser orientiert sich an den definierten Akzeptanzkriterien der Story und prüft, ob alle Anforderungen technisch korrekt und im vorgegebenen Rahmen umgesetzt wurden. Im Fall von Abweichungen kann die KI Verbesserungsvorschläge machen oder automatisierte Korrekturen vorschlagen.

Der gesamte Prozess bleibt kontrollierbar und nachvollziehbar. Die Entscheidung, ob eine Story abgeschlossen ist oder überarbeitet werden muss, liegt weiterhin beim Menschen – oder wird über ein abgestimmtes Regelwerk delegiert.

---

Beispiel eines vollständigen Durchlaufs

Ein einzelnes Feature – etwa die Aktivierung eines Dark Mode – lässt sich beispielhaft in folgenden Schritten umsetzen:

1. Beschreibung durch den Menschen
2. Story-Generierung durch die KI
3. Aufteilung in Tasks
4. Umsetzung der Tasks durch einen Entwicklungs-Agenten
5. Statusänderung zu „review“
6. Automatisierte Prüfung durch einen Review-Agenten
7. Abschluss mit Status „done“

Jeder Schritt erfolgt transparent und nachvollziehbar über strukturierte Dateien (Markdown), statusgesteuerte Agenten und ein dialogbasiertes Feedbacksystem.

---

Herausforderungen und praktische Lösungsansätze

Problem 1: Komplexe Abhängigkeiten

Challenge: KI versteht oft nicht, wie Stories voneinander abhängen. Lösung:

• Explizite Dependency-Maps in der Dokumentation
• “Prerequisite”-Felder in jeder Story
• Regelmäßige Architektur-Reviews mit der KI

Problem 2: Kontext-Verlust bei großen Projekten

Challenge: KI “vergisst” ältere Entscheidungen bei langen Projekten. Lösung:

• Modulare Story-Strukturen (max. 5-7 Stories pro Epic)
• “Context-Dokumente” mit Architektur-Entscheidungen
• Regelmäßige “Refresher”-Prompts für die KI

Problem 3: Steigende KI-Kosten

Challenge: Umfassende KI-Nutzung wird teuer. Lösung:

• Hybride Ansätze: KI für Struktur, Mensch für Entscheidungen
• Lokale Modelle für einfache Tasks (Ollama, etc.)
• Batch-Processing statt Einzel-Anfragen

Die Probleme sind bekannt und lösbar – durch systematisches Vorgehen.

---

Projektidee: To-do-App als Beispiel

Ziel: Aufgaben erstellen, anzeigen, als erledigt markieren, filtern und löschen. Ziel: ein MVP mit lokaler Speicherung und einfacher Benutzeroberfläche.

Technologie-Stack:

• Astro als Framework für Seitenstruktur und Build
• Svelte als UI-Komponenten-Framework
• localStorage für Persistenz im Browser
• CSS-Klassen direkt in Svelte (oder Tailwind optional)

Projektstruktur:

project-todo-app/
├── docs/
│   └── architecture.md
├── stories/
│   └── stories.md
├── tasks/
│   └── story-1-1-tasks.md
├── src/
│   ├── components/
│   │   ├── TaskForm.svelte
│   │   ├── TaskList.svelte
│   │   └── TaskItem.svelte
│   └── pages/
│       └── index.astro
└── README.md

Beispielinhalte:

stories/stories.md

# EPIC 1: Aufgabenverwaltung

## Story 1.1 – Aufgaben erstellen

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

- Neue Aufgaben können über ein Formular eingegeben werden
- Pflichtfeld: Titel
- Aufgaben werden im lokalen Speicher gespeichert
- Nach dem Anlegen erscheint die Aufgabe in der Liste

## Story 1.2 – Aufgaben als erledigt markieren

ID: 1.2  
Status: draft  
Ziel: Nutzer können Aufgaben als "erledigt" markieren  
Akzeptanzkriterien:

- Aufgabenliste zeigt Checkbox pro Eintrag
- Erledigte Aufgaben werden durchgestrichen angezeigt
- Zustand wird gespeichert

---

# EPIC 2: Aufgabenorganisation

## Story 2.1 – Aufgaben filtern

ID: 2.1  
Status: draft  
Ziel: Aufgaben können nach Status gefiltert werden (alle/offen/erledigt)  
Akzeptanzkriterien:

- Drei Filteroptionen vorhanden
- Standard: "alle"
- Auswahl aktualisiert die angezeigte Liste

## Story 2.2 – Aufgaben löschen

ID: 2.2  
Status: draft  
Ziel: Nutzer können Aufgaben dauerhaft löschen  
Akzeptanzkriterien:

- Löschoption sichtbar bei Hover oder Tap
- Löschaktion erfordert Bestätigung
- Aufgaben werden aus dem lokalen Speicher entfernt

tasks/story-1-1-tasks.md

# Tasks für Story 1.1 – Aufgaben erstellen

status: draft

## Subtasks:

- [ ] Komponente `TaskForm.svelte` erstellen mit Eingabefeldern (Titel, Beschreibung)
- [ ] Pflichtfeldvalidierung für Titel (mit `on:submit`)
- [ ] Svelte store oder lokale Variable zur Erfassung neuer Aufgabe
- [ ] Aufgabe wird bei Absenden gespeichert (→ localStorage)
- [ ] Aufgabenliste aktualisieren nach Speicherung
- [ ] Aufgabenanzeige in `TaskList.svelte` mit Einbindung von `TaskItem.svelte`

docs/architecture.md

## Architekturübersicht

- Framework: Astro
- Komponenten: Svelte (in `/src/components`)
- Zustand: lokale Zustandsvariablen in Svelte, Speicherung über `localStorage`

## Seitenstruktur

- `/index.astro`: Container-Seite, bindet Svelte-Komponenten ein

## Komponenten

- `TaskForm.svelte`: Eingabeformular für neue Aufgaben
- `TaskList.svelte`: Anzeige der Aufgabenliste
- `TaskItem.svelte`: Darstellung einzelner Aufgaben mit Status und Aktionen

## Datenfluss

- `TaskForm` → emit → `index.astro`
- Aufgaben werden in `localStorage` persistiert
- Bei Seitenstart: Laden aus Speicher und Anzeige in `TaskList`

## Konventionen

- Einfache Styles mit Klassen in `.svelte`-Dateien
- Keine externe State-Library
- Datenformate: JSON-Objekte pro Aufgabe

---

Weiteres Vorgehen mit KI-Agenten

1. Story 1.1 auf „approved“ setzen
2. Dev-Agent initialisieren (Claude CLI, Cursor o. ä.)
3. story-1-1-tasks.md einlesen lassen
4. KI setzt Aufgaben in Komponenten um (z. B. TaskForm.svelte)
5. Nach Fertigstellung Status auf review ändern
6. Review-Agent prüfen lassen → Abschluss mit done

---

Implementierung in der Praxis

Kurzfristig (erste Woche):

• Kleines Projekt als Testfeld wählen (z.B. die vorgestellte To-do-App)
• 3-5 User Stories mit klaren Akzeptanzkriterien formulieren
• ChatGPT/Claude zur Story-Verfeinerung einsetzen

Mittelfristig (erster Monat):

• Story-Template für wiederkehrende Projekte etablieren
• Cursor oder GitHub Copilot für Story-basierte Entwicklung evaluieren
• Erfahrungen und Learnings systematisch dokumentieren

Für Teams:

• “KI-Agile” Pilot in einem kleinen Team durchführen
• Integration in bestehende Scrum/Kanban-Prozesse
• Team-Mitglieder in KI-gestützten Workflows schulen

Advanced:

• Automatisierte Review-Prozesse mit KI implementieren
• Mehrere KI-Tools in einer Tool-Chain integrieren
• Metriken für KI-Effizienz in der Entwicklung definieren

Vom Hype zur strukturierten Praxis

Die Kombination aus agilen Methoden und KI-Unterstützung ermöglicht strukturiertes, effizientes Entwickeln. Die Kontrolle bleibt beim Menschen, während KI repetitive Aufgaben übernimmt. Das Ergebnis: Besserer Code, kürzere Entwicklungszyklen und mehr Kapazität für strategische Entscheidungen.

Der Erfolg liegt in der Balance: Klein anfangen, systematisch skalieren. Die Zukunft der Softwareentwicklung ist hybrid – die vorgestellten Methoden bieten einen praktikablen Einstieg.