Agentische Softwareentwicklung: Entwickler:innen gestalten die ganze Lösung

Ein Plädoyer für Verantwortung: Wer technisches Wissen mit Domänenverständnis verbindet, entscheidet, was gebaut wird

„Dafür fehlt die Zeit.” Alle Entwickler:innen kennen diesen Satz. Mit agentischer Softwareentwicklung verliert er an Gewicht: Agenten schreiben und testen Code. Knapp ist jetzt nicht mehr der Code. Knapp ist, was du mitbringst: das Wissen, was gebaut werden soll, warum, und ob es hält. Der Raum, der dadurch entsteht, gehört denen, die ihn nehmen – auf dem Wissen, das du längst hast.

Hinweis: Dieses Video und dieser Podcast wurden mithilfe von KI erstellt auf Grundlage der ursprünglichen Inhalten sowie den technischen Erkenntnissen des Autors des Blogartikels.

 

 

Mit einem Prototyp nehmen Entwickler:innen die Abstimmung in die Hand

Das Wichtigste an der Entwicklungsarbeit ist nicht der Code, der entsteht. KI-Experte Paul Dubs sagt: „Das eigentliche Ergebnis, das Wertvolle, ist das gedankliche Modell.“ Gemeint ist das Verständnis dafür, welches Problem wir lösen, wie die Lösung funktioniert und warum wir diesen Weg wählen. Der Code entsteht aus diesem Verständnis. Delegieren wir die Umsetzung an Agenten, bleibt unsere zentrale Arbeit, dieses Verständnis zu entwickeln.

Bei einem Softwareprojekt sitzen häufig mehrere Menschen am Tisch: Entwickler, Testerin, Product Owner und vielleicht die Kundin. Sie besprechen User Stories und einigen sich darauf, was gebaut werden soll. Dabei entsteht im Kopfe jedes Beteiligten ein eigenes gedankliches Modell. Was die Testerin unter einer vollständigen Prüfung versteht, kann sich erheblich von dem unterscheiden, was der Entwickler darüber denkt. Die vermeintliche Einigkeit verdeckt Unterschiede, die das Team erst im weiteren Verlauf bemerkt – und dann kann es frustrierend und teuer werden.

Solche Missverständnisse begleiten die Softwareentwicklung seit Jahrzehnten. Agenten machen möglich, was bisher am Aufwand scheiterte: Entwickler:innen lassen frühzeitig und zu geringen Kosten einen lauffähigen Prototyp umsetzen – so schnell, dass sie ihn in die nächste Besprechung mitbringen können.

Damit bekommen die unterschiedlichen gedanklichen Modelle einen gemeinsamen Bezugspunkt. Was zuvor jeder für sich im Kopf hatte, lässt sich am Verhalten der Anwendung besprechen und verändern. Das Team passt den Prototyp an, stellt eine zweite Variante daneben und prüft erneut, so oft es nötig ist. Entwickler:innen müssen nicht mehr warten, bis die Anforderung bei ihnen ankommt. Sie treiben die Abstimmung voran.

Das Prinzip gilt auch für technische Entscheidungen, über die Teams gern lange streiten. Soll die Anwendung Daten erst auf Anfrage zusammenführen oder laufend vorverarbeiten? Das Team lässt Agenten beide Ansätze als erste Prototypen umsetzen. Es vergleicht Antwortzeiten und Betriebsaufwand und entscheidet, welche Variante zur Nutzung und zu den verfügbaren Ressourcen passt.

Früheres Feedback bewirkt mehr als schnellerer Code

Tempo beim Code bringt wenig – und ist beileibe nicht die grundlegende Veränderung, von der so viele sprechen. Die Geschwindigkeit beim Programmieren war nie unser eigentliches Problem. Eberhard Wolff, Head of Architecture bei SWAGLab, fragt zugespitzt: Bauen wir mit KI das Falsche künftig nur noch schneller?

In seinem Vortrag „Humans and AI in the Feedback Loop of Software Development“ unterscheidet Wolff zwei Kreisläufe. Im inneren Kreislauf schreiben Entwickler Code, erstellen Builds und führen Tests aus. Im äußeren veröffentlichen sie Features, holen Rückmeldungen von Nutzern ein und planen die nächsten Schritte. KI beschleunigt vor allem den inneren. „Mehr Tempo durch KI bedeutet nicht zwangsläufig besseres Feedback“, sagt Wolff.

Der Hebel liegt im äußeren Kreislauf, bei Kommunikation, Abstimmung und Feinjustierung. Wolff nennt typische Hindernisse: Projekte ohne klare Geschäftsstrategie, nicht verfügbare Stakeholder und übermäßige Planung. Dazu kommen unklare Zuständigkeiten und Hierarchien, die offenen Austausch erschweren. Viele davon haben eine gemeinsame Wurzel. Die Beteiligten sprechen über etwas Abstraktes, und jeder hört darin seine eigene Erwartung. Ein Prototyp nimmt dem Gespräch die Abstraktion. Wer ihn durchspielt, muss sich festlegen: Wer entscheidet in diesem Schritt? Was geschieht, wenn der Auftraggeber noch Rücksprache halten will?

Für Wolff entsteht gute Software aus technischem Wissen, Domänenverständnis und Zusammenarbeit. Wer das gemeinsame gedankliche Modell herstellt, denkt voraus, hört zu, zeigt Ergebnisse und gestaltet daraus eine Lösung. Solche Entwickler:innen sind jetzt gefragt: Sie verantworten, was gebaut wird, und nicht nur, wie.

Wer delegiert, braucht das gedankliche Modell der ganzen Lösung

Der Prototyp zeigt: Auftraggeber wollen vor der Freigabe Rücksprache halten. Die Anwendung braucht einen neuen Zwischenstatus. Damit stehen Entscheidungen an, die weit über die Oberfläche hinausgehen, im Datenmodell, bei den Rechten, in den Tests. Du schneidest daraus die Aufträge für die Agenten zu und beurteilst, ob die Ergebnisse zusammenpassen. Das gelingt nur mit einem gedanklichen Modell der gesamten Lösung, das mit jeder Rückmeldung der Nutzer mitwächst.

Einen Auftrag zuzuschneiden heißt, die Aufgabe im Zusammenhang der ganzen Lösung selbst zu durchdenken. Das kennst du vom Delegieren an Junioren: „Bevor ich das erkläre, mache ich es schnell selbst.“ Doch erst die Erklärung zwingt dich zu klären, welches Ergebnis du brauchst, was der andere wissen muss und welche Entscheidungen er selbst trifft. Bei einem Agenten gilt dasselbe. Ein Agent liefert in Minuten, was du beschrieben hast. Wo deine Beschreibung Lücken hatte, zeigt dir das Ergebnis.

Was der Agent liefert, ist dein Ergebnis. „Der Code, den ihr mit Hilfe von KI erzeugt, ist euer Code“, sagt Paul Dubs. Das ist mehr als eine Pflicht: Wer für den Code einsteht, bestimmt auch, wie er aussieht. Dubs fordert deshalb Belege, dass die Agenten ihren Auftrag erfüllt haben, etwa ausgeführte Tests. Ein grüner Test sagt aber nichts über die Fälle, die er nicht prüft, und nicht, ob die Beiträge im Zusammenspiel funktionieren. Du beurteilst, welche Ergebnisse du übernimmst und wo die Agenten nacharbeiten, und entscheidest damit, was in diesem System Bestand hat.

Dein Framework wird zur Infrastruktur deiner Agenten

Wenn Agenten den nächsten Endpunkt, die nächste Validierung und den nächsten Test schreiben, musst du dich fragen: Worauf baut diese Lösung, und was hält sie in einem Jahr noch änderbar? Dein technisches Wissen bekommt dabei ein größeres Feld. Dein Framework, etwa Java mit Spring Boot, wird zur Infrastruktur, auf der deine Agenten arbeiten.

Agenten kennen Spring Boot im Allgemeinen. Deine Fachdomäne und dein spezifisches System kennen sie nicht: was eine Freigabe in deinem Unternehmen bedeutet, welche Regeln gelten und was eine Änderung im Betrieb auslöst. Dafür bringst du beides mit, technisches Wissen und Domänenverständnis. Zusammen machen sie aus dem Framework die Leitplanken für genau dieses System. Du bestimmst, welche Bausteine die Agenten nutzen, welche Schnittstellen feststehen und welche Abhängigkeiten sie einführen dürfen, und gibst das als Kontext mit. Was im Team bisher selbstverständlich war, steht jetzt explizit da, prüfbar und für jeden Auftrag gültig. Das ist Infrastrukturwissen. Wer technisch und fachlich urteilen kann, verantwortet die Lösung als Ganzes.

Beides zusammen lässt dich sehen, was ein Agent übersieht. Ein typischer Fall: Er prüft eine Freigaberegel nur im Angular-Frontend, und sie lässt sich über einen direkten API-Aufruf umgehen. Fachlich weißt du, dass die Regel immer gelten muss. Technisch erkennst du, dass sie im Frontend allein nicht hält, weil du verstehst, wie Browser, API und Backend zusammenarbeiten. Die Prüfung gehört auch in den Spring-Boot-Dienst. Die Tiefe bleibt, nur ihr Zweck wechselt: Du setzt sie ein, um zu beurteilen, nicht um jede Zeile zu schreiben.

Der größte Hebel liegt eine Ebene über dem einzelnen Ergebnis. Bei der Freigaberegel korrigierst du nicht bloß den Code. Du hältst die Regel im Kontext fest und sicherst sie mit einem Test. Danach gilt sie für jeden Auftrag und jeden Agenten. Das ist Gestaltungsmacht: einmal richtig entschieden, wirkt es überall.

Ein klarer Rahmen hält die Anwendung änderbar. Ein Agent arbeitet mit dem Kontext, den er bekommt, und was darin fehlt, erfindet er neu. Steht die Prüfregel der Freigabe an drei Stellen, muss jede Änderung an allen dreien erfolgen, und eine wird leicht vergessen. Mit klaren Vorgaben bleibt sie an einer. Hier arbeitet dein Gespür für Strukturen, die später wehtun: Du erkennst, wo sich Doppelungen bilden, und entscheidest, wann die Struktur Vorrang vor der nächsten Ergänzung hat.

Das Framework sagt, was möglich ist. Welche Möglichkeit in deinem Kontext die richtige ist, regeln Prinzipien. Der Softwarearchitekt Eoin Woods empfiehlt, Agenten Architekturprinzipien mitzugeben. Bei der Verbindung zweier Systeme zum Beispiel prüfen sie zuerst offene Nachrichtenprotokolle, dann unternehmensweit verwendete Protokolle und erst danach eine individuelle Verbindung. Das Prinzip schreibt kein Protokoll vor, nur die Reihenfolge der Abwägung. Solche Prinzipien zu formulieren ist Entwurfsarbeit: Du legst fest, was in deinem Kontext zählt, bevor die erste Entscheidung fällt, und prüfst, ob die Vorschläge der Agenten dieser Logik folgen.

Bleibe informiert

Unser Newsletter informiert dich regelmäßig über die Module, Trainer:innen, Specials und alles andere Wissenswerte zum Thema Software Architecture.

[mc4wp-simple-turnstile]

Jetzt bist du dran: Die Lösung gehört dir

Agentische Softwareentwicklung verändert, wie aus einem Ziel eine Anwendung wird. Damit verändert sich deine Rolle als Engineer: von der Umsetzung gegebener Anforderungen zur Verantwortung und Gestaltungshoheit für die ganze Lösung.

Die Rolle lässt sich lernen. Drei Fähigkeiten tragen sie: das gemeinsame Modell herstellen, Aufträge so zuschneiden, dass sie tragen, und Kontext und Prinzipien so schreiben, dass Agenten ihnen folgen. Alle drei übt man am besten an echten Aufgaben und mit Rückmeldung zu den eigenen Entscheidungen. Genau dafür gibt es bei uns die entwickler.de Akademie, dazu Camps und Workshops im Rahmen unserer Konferenzen, zweitägige Bootcamps und Inhouse-Schulungen für ganze Teams.

Wer die ganze Lösung verantwortet, entscheidet auch mit, was gebaut wird.

 

Take-aways

Take-away #1: Der wertvollste Beitrag von Entwickler ist nicht der Code, sondern das gedankliche Modell dahinter. Wer versteht, welches Problem gelöst werden soll, warum und wie die Lösung funktioniert, kann die Umsetzung an Agenten delegieren und trotzdem die Verantwortung behalten.

Tipp: Formuliere vor dem nächsten Agentenauftrag das eigentliche Problem, das gewünschte Ergebnis und die wichtigsten fachlichen Regeln. Prüfe anschließend nicht nur den Code, sondern auch, ob die Lösung zu diesem Modell passt.

Take-away #2: Agenten machen frühe, lauffähige Prototypen so einfach, dass Entwickler die Abstimmung aktiv vorantreiben können. Statt abstrakt über Anforderungen zu diskutieren, können Teams gemeinsam ausprobieren, vergleichen und Missverständnisse früh erkennen.

Tipp: Lass für eine offene Anforderung einen einfachen Prototyp erstellen und bring ihn ins nächste Gespräch mit Product Owner, Test und Fachbereich. Klärt anhand des tatsächlichen Verhaltens, was funktioniert und was noch fehlt.

Take-away #3: Zehnmal schnellerer Code bringt wenig, wenn das Team weiterhin Wochen braucht, um herauszufinden, was Kunden wirklich benötigen. Der größere Produktivitätsgewinn entsteht durch kürzere Feedbackwege und ein gemeinsames Verständnis zwischen Fachlichkeit und Technik.

Tipp: Untersuche, wie lange es von einer ersten Idee bis zum Feedback echter Nutzer dauert. Suche nach unnötigen Abstimmungsschleifen und nutze frühe Prototypen, um Entscheidungen schneller herbeizuführen.

Take-away #4: Gute Delegation an Coding Agents erfordert den Blick auf die gesamte Lösung. Eine kleine Änderung an der Oberfläche kann Auswirkungen auf Datenmodell, Berechtigungen, Schnittstellen und Tests haben. Die Verantwortung für das Zusammenspiel bleibt bei den Entwickler.

Tipp: Prüfe vor jedem größeren Agentenauftrag, welche Systemteile betroffen sind. Fordere ausgeführte Tests als Nachweis an und kontrolliere auch, was diese Tests nicht abdecken.

Take-away #5: Technisches Wissen und Domänenverständnis werden zur Grundlage für wirksame Agenten. Frameworks, Architekturprinzipien und explizite Regeln geben ihnen Orientierung. So lassen sich gute Entscheidungen nicht nur einmal treffen, sondern für weitere Aufgaben wiederverwenden.

Tipp: Wähle eine wichtige fachliche Regel oder ein Architekturprinzip aus deinem Projekt. Halte fest, was gelten muss, welche Bausteine verwendet werden dürfen und wie sich die Einhaltung testen lässt. Gib diese Vorgaben deinen Agenten als verbindlichen Kontext mit.

Sebastian Meyen

Autor:in

Sebastian Meyen begleitet die IT-Industrie bereits seit mehr als zwei Jahrzehnten; als Redakteur, als Beobachter, als Zuhörer. Er verantwortet bei Software & Support Media den Bereich Content und leitet die Teams, die redaktionell für Magazine und Konferenzen auf der Plattform entwickler.de bzw. devm.io verantwortlich sind .


Foundation Camp Flexible

In diesem intensiven Training erwirbst du die Fähigkeiten, um klare Anforderungen in robuste Softwarestrukturen umzusetzen.

iSAQB®-Zertifizierung:

Lass dich direkt nach dem Workshop unabhängig zum CPSA-F zertifizieren.

Nächster Termin

11. Jan. bis 05. Feb. 2027, online

Foundation Camp

In diesem intensiven Training erwirbst du die Fähigkeiten, um klare Anforderungen in robuste Softwarestrukturen umzusetzen.

iSAQB®-Zertifizierung:

Lass dich direkt nach dem Workshop unabhängig zum CPSA-F zertifizieren.

Nächster Termin

23. bis 26. Nov. 2026

Modul ADOC – Architekturdokumentation

Vermittelt die Grundlagen, um Architekturen klar zu dokumentieren und effektiv zu kommunizieren.

Kompetenz:

  • ✔ Methodisch: 20 Credits

Nächster Termin

10. bis 11. März 2027, Berlin

Modul AGILA – Agile Softwarearchitektur

Zeigt, wie agile Prinzipien mit der Arbeit als Softwarearchitekt:in kombiniert werden können.

Kompetenz:

  • ✔ Methodisch: 20 Credits
  • ✔ Kommunikativ: 10 Credits

Modul ARCEVAL - Architekturen bewerten & reflektieren

Vermittelt die systematische Bewertung von Softwarearchitekturen und deren Qualitätsmerkmalen.

Kompetenz:

  • ✔ Methodisch: 20 Credits

Modul CLOUDINFRA – Infra., Container + Cloud Native

Du lernst, wie du moderne Cloud-Infrastrukturen skalierbar entwirfst, implementierst und betreibst.

Kompetenz:

  • ✔ Technisch: 20 Credits
  • ✔ Methodisch: 10 Credits

Nächster Termin

10. bis 12. Mai 2027, Berlin

Modul DDD – Domain-driven Design

Zeigt, wie Softwaremodelle effektiv entwickelt werden können, um komplexe Domänen abzubilden.

Kompetenz:

  • ✔ Methodisch: 20 Credits
  • ✔ Kommunikativ: 10 Credits

Nächster Termin

25. bis 27. Nov. 2026

Modul DSL – Domänenspezifische Sprachen

Lerne, wie du sie konzipierst und entwickelst – von der Analyse der Fachdomäne bis zur Umsetzung in klaren, wartbaren DSLs.

Kompetenz:

  • ✔ Technisch: 10 Credits
  • ✔ Methodisch: 20 Credits

Modul FLEX – Flexible Architekturmodelle​

Behandelt Methoden und Strategien für skalierbare, modulare und anpassungsfähige Softwarearchitekturen.

Kompetenz:

  • ✔ Technisch:   20 Credits
  • ✔ Methodisch: 10 Credits

Nächster Termin

23. bis 25. Nov. 2026

Modul FUNAR – Funktionale Softwarearchitektur

Erklärt Prinzipien wie unveränderliche Daten, algebraische Abstraktionen und funktionale Modellierung.

Kompetenz:

  • ✔ Technisch:   20 Credits
  • ✔ Methodisch: 10 Credits

Modul IMPROVE – Evolution und Verbesserung von Architekturen

Zeigt, wie bestehende Softwarearchitekturen analysiert und gezielt optimiert werden können.

Kompetenz:

  • ✔ Technisch:  10 Credits
  • ✔ Methodisch: 20 Credits

Nächster Termin

23. bis 25. Nov. 2026

Modul SOFT – Soft Skills für Softwarearchitekt:innen

Vermittelt essenzielle Kompetenzen wie Kommunikation, Moderation und Konfliktmanagement.

Kompetenz:

  • ✔ Kommunikativ: 30 Credits

Nächster Termin

07. bis 09. Dez. 2026

Modul SWARC4AI – Softwarearchitektur KI-Systeme

Behandelt Grundlagen und Methoden zur Gestaltung moderner Softwarearchitekturen für KI-Systeme.

Kompetenz:

  • ✔ Technisch: 20 Credits
  • ✔ Methodisch: 10 Credits

Nächster Termin

14. bis 16. Dez. 2026, online

Modul WEBSEC – Web-Security

Zeigt, wie Sicherheitsanforderungen in Webanwendungen systematisch adressiert werden können

Kompetenz:

  • ✔ Methodisch: 20 Credits
  • ✔ Kommunikativ: 10 Credits

Modul AGENTA – Architektur für Agentic Software Engineering

In diesem intensiven Training erwirbst du die Fähigkeiten, mit Coding Agents zu entwickeln.

Kompetenz:

  • ✔Methodisch: 20 Credits
  • ✔Technisch: 10 Credits

Nächster Termin

14. bis 16. Dez. 2026, online

Alle News zum Software Architecture Camp!