Vom Agilen Manifest zur Software Craftsmanship
Kurz gesagt:
- Agile Prozesse ohne technische Praktiken erzeugen Feature-Fabriken mit wachsenden technischen Schulden.
- Extreme Programming und Software Craftsmanship liefern das technische Fundament, das Frameworks wie Scrum bewusst offenlassen.
- Agentic AI verstärkt beides: Gute Praktiken skalieren Qualität, fehlende skalieren Schulden.
Warum Agilität ohne technische Exzellenz scheitert
Ticketschätzungen, endlose Planungsrunden für Story Points, ständige Zeiterfassung – die agile Transformation ist in der Tech-Welt längst Normalität. Doch ein Blick hinter die Kulissen vieler Entwicklungsabteilungen zeigt eine paradoxe Realität: Trotz maximaler Prozess-Agilität fühlen sich viele Teams wie in einer modernen Feature-Fabrik. Die Codebasis versinkt mit jedem Sprint tiefer im Morast technischer Schulden, weil für echtes Refactoring, Design Thinking oder Clean Code im Backlog schlicht kein Ticket vorgesehen ist.
Und als wäre das nicht genug, wird das Ganze heute oft noch mit dem neuesten KI-Assistenten beschleunigt. Er generiert im Rekordtempo Code, für den am Ende erst recht niemand die Verantwortung oder Zeit zur Pflege hat.

Wie konnte es dazu kommen? Um die Gegenwart der Softwareentwicklung zu verstehen und vor allem zu verbessern, müssen wir an den Ursprung zurückgehen: zum Agilen Manifest von 2001, den Wurzeln des Extreme Programming (XP) und der darauf aufbauenden Bewegung der Software Craftsmanship.
Warum das Agile Manifest entstand
Der Status quo Ende der 1990er-Jahre
Um die Jahrtausendwende steckte die IT-Branche in einer tiefen Krise. Softwareprojekte wurden vorrangig nach dem klassischen Wasserfallmodell strukturiert. Das hatte durchaus seine historischen Berechtigungen und Vorteile: Bei klar definierten, stabilen Anforderungen und Projekten, bei denen nachträgliche Änderungen teuer oder physikalisch unmöglich sind (wie im Embedded- oder Infrastrukturbereich), sorgte das Modell für saubere Planungssicherheit und vertragliche Klarheit.
Das bedeutete im Alltag jedoch auch:
- Monatelange Spezifikationsphasen:
Dicke Lasten- und Pflichtenhefte wurden geschrieben, bevor auch nur eine einzige Zeile Code getippt wurde. - Bürokratischer Dokumentationswahn:
Jede Abweichung vom Plan erforderte langwierige Change-Request-Prozesse. - Unflexible Entwicklungszyklen:
Erst nach vielen Monaten (oder Jahren) sah der Kunde das finale Produkt, oft nur um festzustellen, dass sich die Marktanforderungen längst geändert hatten oder die Spezifikation am tatsächlichen Bedarf vorbeigelaufen war.
Das Resultat waren bei dynamischen Softwareprojekten verfehlte Budgets, frustrierte Entwickler und am Ende oft komplett veraltete Produkte.
Die Geburtsstunde in Snowbird (2001)
Im Februar 2001 trafen sich Vordenker der Softwareentwicklung im Skigebiet Snowbird in Utah. Unter ihnen befanden sich Schöpfer verschiedener leichtgewichtiger Methoden: Kent Beck, Ward Cunningham und Ron Jeffries (XP), Ken Schwaber und Jeff Sutherland (Scrum), Martin Fowler, Dave Thomas, Andy Hunt und andere.

Sie suchten nach einem gemeinsamen Nenner für eine bessere Art und Weise, Software zu entwickeln. Das Ergebnis dieses Treffens war das Agile Manifest (Manifesto for Agile Software Development).
Kernaussage: Agilität war nie als reines Management-Framework gedacht. Es war eine fundamentale Haltung (Mindset), die Entwicklern und Teams die Handlungsfähigkeit zurückgeben sollte.
Die Anatomie des Agilen Manifests
Das Agile Manifest basiert auf vier zentralen Wertepaaren und wird durch zwölf Prinzipien ergänzt. Die Formulierung ist bewusst gewählt. Die Werte auf der rechten Seite haben durchaus ihren Platz, aber die Werte auf der linken Seite werden höher geschätzt.
Die 4 Grundwerte
Individuen und Interaktionen mehr als Prozesse und Werkzeuge
Funktionierende Software mehr als umfassende Dokumentation
Zusammenarbeit mit dem Kunden mehr als Vertragsverhandlung
Reagieren auf Veränderung mehr als das Befolgen eines Plans
- Individuen und Interaktionen mehr als Prozesse und Werkzeuge:
Ein funktionierendes Team, das offen kommuniziert, erreicht mehr als ein starr an Werkzeuge gebundenes Team. - Funktionierende Software mehr als umfassende Dokumentation:
Dokumentation ist wichtig, bringt dem Endnutzer aber keinen Mehrwert, wenn das Produkt nicht läuft. - Zusammenarbeit mit dem Kunden mehr als Vertragsverhandlung:
Ein partnerschaftliches Verhältnis ermöglicht kontinuierliches Feedback statt juristischer Grabenkämpfe. - Reagieren auf Veränderung mehr als das Befolgen eines Plans:
Der Markt verändert sich, deshalb müssen Pläne flexibel angepasst werden können.
Gängige Mythen ausräumen
Das Agile Manifest wird in Unternehmen bis heute regelmäßig gekapert und als bequemer Vorwand missbraucht, um entweder Mikromanagement zu verschleiern oder handwerkliche Schludrigkeit zu rechtfertigen.
Schauen wir uns die drei hartnäckigsten Mythen und ihre tatsächliche Entstellung im Firmenalltag an:
„Agil bedeutet: Wir machen keine Pläne mehr und improvisieren.“
Die Realität: Das Gegenteil ist der Fall. Agilität verlangt ständige, schmerzhafte Neuausrichtung. Wer nicht plant, betreibt kein agiles Vorgehen, sondern blindes Chaos. Pläne sind Hypothesen, die im nächsten Sprint validiert und verworfen werden, statt stur an einem veralteten Pflichtenheft festzuhalten.
„Agil heißt: Dokumentation kostet nur Zeit, wir coden einfach drauf los.“
Die Realität: Der Satz „funktionierende Software mehr als umfassende Dokumentation“ wird oft als Freifahrtschein für undokumentierten Spaghetti-Code genutzt. Gemeint war jedoch: Dokumentation muss dem Wert dienen und schlank bleiben, nicht komplett fehlen. Softwarearchitektur und Entscheidungen müssen transparent festgehalten werden.
„Agil bedeutet maximale Freiheit ohne lästige Regeln und Architektur.“
Die Realität: Das genaue Gegenteil ist wahr: Echte Agilität erfordert eine extrem hohe Disziplin, saubere Teamkommunikation und knallharte technische Leitplanken. Ohne automatisierte Tests, CI/CD und fundierte Software Craftsmanship bricht jedes „agile“ Projekt früher oder später unter seiner eigenen Last zusammen.
Extreme Programming (XP) als technischer Motor
Ein wesentlicher Faktor wird in der Debatte um Agilität oft übersehen: Der Großteil der Gründungsmitglieder in Snowbird waren Praktiker und Softwareentwickler, keine reinen Manager. Insbesondere die Bewegung des Extreme Programming (XP) prägte die Ursprünge der Agilität maßgeblich.
Wenn der Prozess stimmt, aber der Code nicht
Man kann Scrum-Board, Daily Stand-ups und Retrospektiven einführen. Doch wenn die darunterliegende Codebasis mangelhaft, ungetestet und unflexibel ist, entsteht eine gefährliche Illusion.
Wenn der Kunde um eine Änderung bittet und das Entwicklerteam antwortet: „Das können wir nicht ändern, sonst bricht das halbe System zusammen“, dann ist das Team nicht agil, völlig egal, wie viele Post-its an der Wand kleben. Technische Schulden blockieren die agile Anpassungsfähigkeit.

Vier zentrale XP-Praktiken im Überblick
Extreme Programming liefert die konkreten Werkzeuge und Praktiken, um den Code genau so anpassungsfähig zu halten wie die Geschäftsprozesse. XP umfasst mehr als die folgenden vier Praktiken, etwa Simple Design, kleine Releases oder das Planning Game. Diese vier sind jedoch für die technische Qualität besonders zentral.
1. Test-Driven Development (TDD)
Bei TDD wird der Test vor dem eigentlichen Produktionscode geschrieben (Red -> Green -> Refactor).
- Vorteil: Es entsteht eine lückenlose automatisierte Testsuite.
- Effekt: Entwickler haben ein Sicherheitsnetz. Sie können den Code jederzeit verändern, ohne befürchten zu müssen, ungewollt bestehende Funktionen zu zerstören.
2. Refactoring & Clean Code
Refactoring ist das kontinuierliche Restrukturieren von bestehendem Code, ohne dessen äußeres Verhalten zu verändern.
- Prinzip: Boy Scout Rule – Hinterlasse den Code immer ein Stück sauberer, als Sie ihn vorgefunden haben.
- Effekt: Technische Schulden werden gar nicht erst angehäuft.
3. Pair Programming & Collective Code Ownership
Zwei Entwickler arbeiten gemeinsam an einem Arbeitsplatz (im Remote-Setup per Bildschirmfreigabe).
- Vorteil: Sofortiges Vier-Augen-Prinzip, direkter Wissenstransfer und Vermeidung von Wissens-Silos.
- Effekt: Der Code gehört dem gesamten Team, nicht einzelnen Personen.
4. Continuous Integration (CI)
Code wird mehrmals täglich in den Hauptzweig integriert und automatisch getestet.
- Vorteil: Integration von Änderungen ist kein angstbesetztes Großevent am Ende des Sprints, sondern Routine.
Die Evolution: Das Software Craftsmanship Manifest

Das Problem des „Agilen Theaters“
Schon wenige Jahre nach dem Manifest wurde Agilität von vielen Organisationen vereinnahmt und zu einer starren Management-Doktrin erhoben. Statt echter Flexibilität wurden kommerzielle Frameworks übergestülpt, deren Fokus fast ausschließlich auf der reinen Prozessebene lag.
Das Ergebnis war das sogenannte „Agile Theater“ oder die „Feature-Fabrik“: Teams lieferten in hohem Tempo Tickets ab, während die Codebasis unter wachsender technischer Schuld litt. Entwickler wurden zu reinen Abarbeitern von Feature-Listen degradiert.
Dieses Muster ist gut dokumentiert: Bereits 2009 beschrieb Martin Fowler, einer der Unterzeichner des Manifests, es als „Flaccid Scrum“. Teams übernehmen die Scrum-Praktiken, vernachlässigen aber die interne Qualität ihrer Software, bis die Produktivität einbricht. 2018 riet Ron Jeffries, ebenfalls Mitunterzeichner, Entwicklern sogar, sich von benannten „Agile“-Methoden zu lösen und stattdessen technische Praktiken wie die des Extreme Programming zu pflegen („Developers Should Abandon Agile“).
Scrum selbst ist dabei nicht der Schuldige. Fowler betont, dass Scrum technische Praktiken bewusst offenlässt, ohne sie für unwichtig zu erklären, und dass am Ende nicht Methoden, sondern Teams erfolgreich sind oder scheitern. Entscheidend ist, die fehlenden technischen Praktiken bewusst zu ergänzen. Genau dafür eignen sich XP und Craftsmanship.
Die Antwort: Das Software Craftsmanship Manifest (2009)
Als Reaktion auf diese Fehlentwicklung wurde im Jahr 2009 das Software Craftsmanship Manifest veröffentlicht. Es versteht sich nicht als Ersatz, sondern als notwendige Ergänzung und Evolution des Agilen Manifests, die den handwerklichen Anspruch wieder in den Vordergrund stellt.
| Agiles Manifest (2001) | Software Craftsmanship Manifest (2009) |
|---|---|
| Funktionierende Software | Nicht nur funktionierende Software, sondern auch gut geschriebene Software |
| Reagieren auf Veränderung | Nicht nur auf Veränderung reagieren, sondern stetig Wert hinzufügen |
| Individuen und Interaktionen | Nicht nur Individuen und Interaktionen, sondern eine Gemeinschaft von Fachleuten |
| Zusammenarbeit mit dem Kunden | Nicht nur Zusammenarbeit mit dem Kunden, sondern produktive Partnerschaften |
Der Handwerksgedanke in der IT
Software Craftsmanship hebt hervor, dass Softwareentwicklung ein anspruchsvolles Handwerk ist. Es erfordert:
- Kontinuierliches Lernen:
Meisterung von Werkzeugen, Mustern und Architekturen. - Stolz auf die eigene Arbeit:
Verantwortung für die Langlebigkeit und Qualität des geschaffenen Codes zu übernehmen. - Mentoring:
Das Weitergeben von Wissen an Junioren innerhalb einer professionellen Gemeinschaft.
Praxistipps für Entwicklerteams
Agilität ist kein Zustand, den man durch den Kauf eines Jira-Abos oder das Zertifizieren von Scrum Mastern erreicht. Echte Agilität ruht auf drei Säulen:
- Agiles Mindset (Werte & Zusammenarbeit)
- XP-Praktiken (Technisches Fundament)
- Craftsmanship (Anspruch, Haltung & Qualität)
Konkrete Handlungsempfehlungen für den Alltag
- Automatisierte Tests & CI/CD als nicht verhandelbar definieren
Bauen Sie von Tag 1 an eine solide Testsuite auf. Ohne automatisierte Tests gibt es keine echte Flexibilität und keine angstfreien Deployments. - Refactoring fest im Sprint einplanen (Boy Scout Rule)
Behandeln Sie Refactoring nicht als separates Großprojekt, für das man beim Management „Budget beantragen“ muss, sondern als natürlichen Bestandteil jeder User Story. - XP-Praktiken leben
Etablieren Sie regelmäßiges Pair- oder Mob-Programming (dabei arbeitet das ganze Team gemeinsam an einer Aufgabe an einem Rechner). Nutzen Sie Code Reviews nicht als Kontrollinstanz, sondern als Ort des gemeinsamen Lernens. - Qualität verbindlich und messbar machen
Verankern Sie Tests, grüne Pipelines und Refactoring in der Definition of Done. Betrachten Sie neben der Velocity auch Kennzahlen wie Lead Time, Deployment-Frequenz und Change-Failure-Rate (DORA-Metriken). Bauen Sie saubere, wartbare und zukunftssichere Systeme, statt nur Haken an Tickets zu machen.
Das Zeitalter von Agentic AI: Warum Agilität & Craftsmanship wichtiger sind denn je
Mit dem rasanten Aufstieg von Agentic AI, autonomen KI-Agenten und fortschrittlichen Coding-Assistenten, die eigenständig Aufgaben analysieren, Code schreiben und Pull Requests erstellen, fragen sich viele: Sind das Agile Manifest, Extreme Programming und Software Craftsmanship im KI-Zeitalter überhaupt noch relevant?
Die kurze Antwort: Sie sind relevanter als jemals zuvor.
Agentic AI verändert nicht die Notwendigkeit von Softwarequalität, sondern skaliert die Geschwindigkeit, mit der Code entsteht, im Guten wie im Schlechten.
Die neue Gefahr: Technische Schulden durch automatisierte Überproduktion
Ein KI-Agent kann innerhalb weniger Minuten hunderte Zeilen Code generieren. Doch ohne klare Architektur und strenge Qualitätsregeln entsteht fragiler, unwartbarer Code in Rekordzeit. Wer KI-Agenten auf eine ungetestete, monolithische Codebasis loslässt, erzeugt keine agile Wertschöpfung, sondern unkontrollierbares Chaos.

XP-Praktiken als deterministische Leitplanken für KI-Agenten
Autonome KI-Systeme sind nur so gut wie die Feedbackschleifen, die wir ihnen zur Verfügung stellen. Genau hier werden XP-Praktiken zum entscheidenden Beschleuniger:
- Test-Driven Development (TDD) als AI-Prompt & Verifizierer:
Ein KI-Agent benötigt ein klares Ziel. Wenn Entwickler den Test (Red) vorgeben oder der Agent zuerst den Test schreiben muss, dient die automatisierte Testsuite als unbestechliches Feedback-System. Erst wenn der Test grün ist (Green), war die KI erfolgreich. - Refactoring & Clean Code:
KI-Modelle neigen dazu, Code zu duplizieren oder unnötig komplexe Abstraktionen einzuführen. Erste Daten stützen das: Eine GitClear-Auswertung von 211 Millionen geänderten Codezeilen (2020–2024) zeigt im Zeitraum der wachsenden KI-Nutzung, dass der Anteil kopierter Zeilen von 8,3 % auf 12,3 % stieg, während der Anteil verschobenen (wiederverwendeten) Codes von 25 % auf unter 10 % sank. Der Anspruch an Clean Code und regelmäßiges Refactoring verhindert, dass die Codebasis durch KI-Generierung vermüllt. - Pair Programming 2.0 (Human-in-the-Loop):
Das klassische Pair Programming entwickelt sich weiter: Der Mensch wird vom rein Code-tippenden Entwickler zum Lead Architect und Code Reviewer, der den KI-Agenten steuert, dessen Vorschläge kritisch hinterfragt und konzeptionelle Entscheidungen trifft. - Continuous Integration (CI) als Halluzinations-Bremse:
Automatisierte Pipelines fangen fehlerhaften oder halluzinierten KI-Code sofort ab, bevor er Schäden im Hauptzweig anrichten kann.
Fazit für die KI-Ära: Agentic AI ersetzt nicht das Handwerk, sondern erhöht die Anforderungen an unser Qualitätsbewusstsein. Die Währung der Zukunft ist nicht die Fähigkeit, Syntax zu tippen, sondern die Kompetenz, Systeme zu strukturieren, präzise Tests zu definieren und sauberen Code von KI-Halluzinationen zu unterscheiden.
Quellen:
- Agiles Manifest (2001): Beck, Kent et al. – Manifesto for Agile Software Development, agilemanifesto.org
- Software Craftsmanship Manifest (2009): Manifesto for Software Craftsmanship, manifesto.softwarecraftsmanship.org
- Flaccid Scrum (2009): Fowler, Martin, martinfowler.com/bliki/FlaccidScrum.html
- Developers Should Abandon Agile (2018): Jeffries, Ron, ronjeffries.com
- AI Copilot Code Quality (2025): GitClear, gitclear.com
Weiterführende Literatur:
- Extreme Programming: Beck, Kent (1999) – Extreme Programming Explained: Embrace Change. Addison-Wesley.
- Software Craftsmanship & Clean Code: Martin, Robert C. (2008) – Clean Code: A Handbook of Agile Software Craftsmanship. Prentice Hall.
- Refactoring: Fowler, Martin (1999) – Refactoring: Improving the Design of Existing Code. Addison-Wesley.
- Agile Praktiken & XP: Shore, James; Warden, Shane (2007/2021) – The Art of Agile Development. O'Reilly Media.
Haben Sie Fragen zur Umsetzung von XP-Praktiken oder zur Etablierung einer Craftsmanship-Kultur in Ihrem Team? Dann nehmen Sie Kontakt mit mir auf oder werfen Sie einen Blick auf meine Leistungen!