Wie AI und DevOps die Art und Weise verändern, wie wir Produkte entwickeln

Gleichzeitig berichtete GitHub, dass seine AI-Tools Entwickler um 55 % schneller machen. Klingt großartig, oder?

Das Problem: In traditionellen Organisationen macht die eigentliche Softwareentwicklung nur 5–10 % der gesamten Forschungs- und Entwicklungszeit aus. Selbst wenn AI-Tools eure Entwickler doppelt so schnell machen, verbessert ihr die Gesamteffizienz eurer Organisation also nur um 2,5–5 %.

Das ist nicht die grundlegende Verbesserung, die wir suchen.

Ich habe über Jahre hinweg AI-gestützte Entwicklung in verschiedenen Organisationen eingeführt – von agilen Start-ups bis hin zu stark regulierten Unternehmen. Und ich kann euch sagen: Für eine spürbare Beschleunigung reicht es nicht, einfach AI-Coding-Assistenten zu eurer Toolchain hinzuzufügen. Ihr müsst euren gesamten Entwicklungsansatz neu denken.

Zunächst betrachten wir sechs grundlegende Bereiche, die ihr richtig aufstellen müsst, damit AI einen spürbaren Unterschied machen kann. Anschließend schauen wir uns praktische Wege zur Einführung AI-gestützter Entwicklung an – unabhängig davon, ob ihr mehrmals täglich Web-Apps ausliefert oder Medizinprodukte mit mehrjährigen Zertifizierungszyklen entwickelt.

Die sechs wesentlichen Bereiche, die ihr richtig aufstellen müsst

Bevor wir in die AI-gestützte Entwicklung einsteigen, sprechen wir über die Grundlagen. Ich habe zu viele Organisationen erlebt, die direkt mit AI-Tools starten, ohne dass ihre Grundlagen stimmen. Darauf müsst ihr zuerst achten.

1. Agile Praktiken – Jira-Automatisierung

Die meisten Organisationen nutzen Jira oder ähnliche Tools, und die meisten Entwickler empfinden manuelle Informationsaktualisierungen als lästig. Diese Tools eignen sich zwar hervorragend für Reporting und Management-Überblick, können aber zum Engpass für die Entwicklungsarbeit werden.

Moderne Softwareentwicklung braucht einen schlankeren Ansatz. Statt Jira-Tickets manuell zu aktualisieren, ermöglichen moderne Tools heute eine reibungslose Anbindung an Git, wobei Branch-Namen als zentraler Marker im Workflow dienen. Wenn ihr eine Änderung an der Anwendung vornehmt, erstellt ihr einfach einen Branch mit einem Namen wie HW-1234/feature-description. Die Automatisierung übernimmt die Informationen zum Jira-Ticket von dort.

Mit diesem Ansatz sorgt ihr für Nachverfolgbarkeit und reduziert gleichzeitig Reibung im Entwicklungsprozess.

2. CI/CD und die Automatisierung von Quality Gates

Continuous Integration und Continuous Deployment wirken vielleicht wie Grundlagen, aber ohne konsequente Automatisierung werdet ihr im Zeitalter AI-gestützter Entwicklung scheitern. Eure CI/CD-Pipeline dient als Leitplanke und stellt sicher, dass euer AI-generierter Code eure Qualitätsstandards erfüllt.

So könnte ein minimal funktionsfähiges CI/CD-Setup aussehen:

name: Continuous Integration

on: [push, pull_request]

jobs:

test: runs-on: ubuntu-latest timeout-minutes: 5 steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4 - run: npm ci - run: npm test - run: npm run lint

Einfach? Ja. Doch diese Grundlage ermöglicht euch, schrittweise anspruchsvollere Prüfungen hinzuzufügen, einschließlich AI-spezifischer Validierungen.

3. Qualität durch kontinuierliche Qualitätssicherung von Anfang an gewährleisten

Eure Tests sind nicht nur Werkzeuge zur Überprüfung. Sie dokumentieren eure Anforderungen fortlaufend. Bei der Arbeit mit AI-generiertem Code wird das noch wichtiger. Tests definieren die Grenzen akzeptablen Verhaltens und geben euren AI-Tools damit klare Ziele.

Bei meiner jüngsten Arbeit entdeckten wir einen Berechnungsfehler, den unser AI-generierter Code eingeführt hatte. Unsere umfassende Test-Suite, die ebenfalls mit AI geplant und umgesetzt wurde, erkannte das Problem. So konnten wir die Lösung schnell weiterentwickeln.

4. Cloud Native entwickeln und alle Änderungen ausliefern

Cloud Native bedeutet nicht nur, in der Cloud zu laufen, sondern auch moderne Deployment-Muster zu nutzen. Mit Services wie Vercel,Fly.io oder Heroku können wir heute jeden Feature-Branch automatisch deployen und so temporäre Umgebungen für Tests und Validierung erstellen.

Dieser Ansatz ist besonders wertvoll, wenn ihr mit AI-generiertem Code arbeitet. Er ermöglicht euch, Änderungen schnell isoliert zu überprüfen, ohne komplexe Umgebungen verwalten zu müssen.

5. Security-Tools für automatisierten Schutz

Moderne Security-Tools können eure Abhängigkeiten automatisch scannen, auf Schwachstellen prüfen und sogar Pull Requests auf Sicherheitsprobleme überprüfen. Schaut euch zum Beispiel GitHub Advanced Security oder GitLab Security an.

Bei AI-gestützter Entwicklung wird das noch wichtiger. Eure Security-Tools sind euer Sicherheitsnetz. Sie erkennen potenzielle Probleme in AI-generiertem Code, bevor dieser in Produktion geht.

6. Organisation nach Team Topologies

Conway's Law besagt, dass eure Softwarearchitektur eure Organisationsstruktur widerspiegelt.

Team Topologies, ein von Matthew Skelton und Manuel Pais entwickeltes Framework, hilft uns dabei, Teams so zu organisieren, dass sie moderne Entwicklungspraktiken unterstützen.

Seht euch Matthews Einführung in Team Topologies auf unserer DevOps Conference an: DevOps Topologies 10 years on: What have we learned about silos, collaboration, and flow?

Die wichtigsten Elemente sind:

Wertstromorientierte Teams, die bestimmte Teile des Kundennutzens verantworten
Platform Teams, die interne Services bereitstellen
Teams für komplexe Subsysteme, die spezialisierte Komponenten betreuen
Enabling Teams, die andere Teams bei der Weiterentwicklung ihrer Fähigkeiten unterstützen

Warum ist diese Struktur bei der Einführung von AI-Tools so wichtig? Sie hilft euch zu klären, wo und wie sich AI-Unterstützung am effektivsten einsetzen lässt.

Diese Grundlagen zu schaffen, bedeutet mehr als nur Best Practices umzusetzen. Es geht darum, ein Umfeld zu schaffen, in dem AI-Tools tatsächlich Mehrwert liefern können. Ohne diese Basis riskiert ihr, ein Kartenhaus zu bauen, das beeindruckend aussieht, aber unter realem Druck zusammenfällt. Mehr dazu erfahrt ihr in unserem Artikel „Transforming software development with AI and DevOps“

Wo AI wirklich hilft

Nachdem die Grundlagen stimmen, schauen wir uns an, wo AI wirklich etwas bewirken kann. Vergesst den Marketing-Hype – hier erfahrt ihr anhand meiner praktischen Erfahrungen, was tatsächlich funktioniert.

Code generieren und vervollständigen

Ich zeige euch ein konkretes Beispiel. Kürzlich musste ich eine Funktion zur Berechnung der Kalenderwoche implementieren. Statt mich selbst mit den Details der Datumsberechnung zu beschäftigen, habe ich AI den Algorithmus erstellen lassen.

So lief es ab:

function getWeekNumber(date = new Date()) { const startDate = new Date(date.getFullYear(), 0, 1); const days = Math.floor((date - startDate) / (1000 * 60 * 60 * 24)); const weekNumber = Math.ceil((days + startDate.getDay() + 1) / 7); return weekNumber;}

Der Code funktioniert in den meisten Fällen. Da die Kalenderwoche jedoch nicht direkt ab dem 1. Januar berechnet wird, funktioniert der Code eigentlich nicht. Das verdeutlicht einen wichtigen Punkt: AI eignet sich hervorragend, um erste Lösungen zu generieren, aber ihr braucht gründliche Tests und Validierung.

Die wahre Stärke liegt nicht darin, Entwickler zu ersetzen. Sie liegt darin, mühsame und repetitive Aufgaben zu übernehmen, damit ihr euch auf Geschäftslogik und Sonderfälle konzentrieren könnt.

APIs und Bibliotheken verstehen

Hier glänzt AI wirklich. Statt euch durch Dokumentationen oder Stack Overflow zu arbeiten, könnt ihr direkte Fragen zu APIs stellen und kontextbezogene Antworten erhalten.

Als ich beispielsweise mit einer neuen Bibliothek zur Datumsbearbeitung arbeitete, konnte ich, statt seitenlange Dokumentationen zu lesen, fragen:

Wie gehe ich in dieser Bibliothek mit ISO-Wochennummern um?
Was ist der Unterschied zwischen lokalen und UTC-Wochenberechnungen?
Zeig mir Beispiele für den Umgang mit Fällen an Jahresgrenzen

Die Antworten sind in der Regel praktischer und kontextbezogener als herkömmliche Dokumentation. Denkt jedoch daran, dass ihr aufgrund des Stichtags, bis zu dem das Wissen der AI reicht, alle Informationen zu aktuellen API-Änderungen überprüfen solltet.

Boilerplate-Code generieren

Neue Projekte zu starten oder Standardmuster hinzuzufügen, bedeutete früher, Code aus alten Projekten zu kopieren und einzufügen. Heute kann AI diesen Boilerplate-Code generieren – oft in einem saubereren Zustand als eure alten Referenzprojekte.

Interessant ist, dass AI oft besser strukturierten Boilerplate-Code erzeugt als von Menschen geschriebener Code. Das liegt daran, dass sie Best Practices aus Tausenden von Beispielen zusammenführt.

Stellt nur sicher, dass eure Anforderungen klar sind. Der Unterschied zwischen guten und mittelmäßigen Ergebnissen hängt oft davon ab, wie präzise ihr eure Bedürfnisse beschreibt.

Neue Technologien lernen

Ich erkläre das anhand eines praktischen Beispiels.

Ich musste mich in die Audioanalyse mit Python einarbeiten – ein Bereich, mit dem ich nicht vertraut war. Statt stundenlang Dokumentation zu lesen, konnte ich einen Dialog mit AI führen:

„Zeig mir eine einfache Pipeline für die Audioanalyse in Python“
„Erkläre, wie sich die FFT-Parameter auf die Analyse auswirken“
„Hilf mir, dies für die Echtzeitverarbeitung zu optimieren“

Entscheidend ist, AI als Lernbeschleuniger zu nutzen, nicht als Ersatz für Verständnis. Ihr müsst die Konzepte weiterhin verstehen, aber AI kann euch helfen, die Lernkurve schneller zu meistern.

Ein Wort der Vorsicht

So leistungsstark all diese Fähigkeiten auch sind, sie bringen wichtige Einschränkungen mit sich. Deshalb möchte ich diesen Abschnitt mit den vier wichtigsten Punkten abschließen:

AI-generierter Code muss gründlich getestet werden
Ihr müsst die Auswirkungen auf die Sicherheit prüfen
Sonderfälle erfordern oft menschliches Urteilsvermögen
Die neuesten Funktionen oder Best Practices sind möglicherweise nicht berücksichtigt

Berücksichtigt dies immer bei eurer AI-Implementierung

Nachdem wir betrachtet haben, wobei AI helfen kann, widmen wir uns nun den Punkten, auf die ihr achten müsst, wenn ihr AI in euren Entwicklungsprozess integriert. Bei der Umsetzung von AI-gestützter Entwicklung bin ich immer wieder auf diese Herausforderungen gestoßen und möchte euch helfen, dieselben Fallstricke zu vermeiden.

Prompt-Engineering-Kenntnisse sind unverzichtbar

Ihr müsst eine neue Fähigkeit lernen, mit der vor einigen Jahren niemand gerechnet hat: Prompt Engineering. Dabei geht es nicht nur darum, AI zu bitten, Code zu schreiben – sondern darum, Ergebnisse zu erzielen, die ihr tatsächlich in der Produktion einsetzen könnt.

Ich zeige euch, was ich meine.

Als ich diese Funktion zur Berechnung von Kalenderwochen brauchte, bekam ich mit der Anfrage „eine Funktion zur Berechnung von Kalenderwochen“ nur unbrauchbare Ergebnisse. Ich musste lernen, präzise zu sein:

„Ich brauche eine Funktion, die ISO-Datumsangaben verarbeitet, die ISO-Kalenderwochennummerierung verwendet und bei ungültigen Eingaben verständliche Fehler ausgibt.“

Klare Prompts schreiben zu können, wird genauso wichtig wie eure Programmierkenntnisse.

Sorgfalt bei rechtlichen Fragen und geistigem Eigentum

Ihr habt wahrscheinlich schon von der Klage gegen GitHub Copilot gehört: Im November 2022 wurde eine Sammelklage gegen Microsoft, GitHub und OpenAI eingereicht. Darin wird behauptet, dass GitHub Copilot die Urheberrechte von Open-Source-Entwicklern verletzt habe, indem Code ohne ordnungsgemäße Quellenangabe reproduziert wurde. Microsoft hat zugesagt, Nutzer gegen urheberrechtliche Ansprüche im Zusammenhang mit KI-generiertem Code zu verteidigen. Da sich der rechtliche Rahmen jedoch noch entwickelt, müsst ihr KI-generierten Code mit Bedacht einsetzen.

Der schwierige Punkt: Code, den KI generiert, erhält nicht automatisch urheberrechtlichen Schutz. Ihr müsst ihn ausreichend verändern, damit er zu eurem eigenen Werk wird. In der Praxis heißt das: Ihr könnt KI-Ausgaben nicht einfach per Copy-and-paste übernehmen. Ihr müsst sie verstehen, anpassen und korrekt in eure Codebase integrieren.

Sicherheit und Datenschutz

Das sollte euch beunruhigen: Alles, was ihr in ChatGPT einfügt, kann zu Trainingsdaten für zukünftige Versionen werden.

Teilt niemals:

API-Keys oder Secrets
Interne Architekturdetails
Proprietäre Algorithmen
Kundendaten
Sicherheitskritischen Code

Wenn ihr KI mit sensiblem Code einsetzen müsst, erstellt bereinigte Beispiele oder richtet private Instanzen ein. Ja, das bedeutet zusätzlichen Aufwand. Aber es ist besser, als eurem Security-Team erklären zu müssen, warum eure internen Algorithmen in den KI-Vervollständigungen anderer auftauchen.

Tests und Validierung

Erinnert ihr euch an den erwähnten Fehler bei den Kalenderwochen? Die KI lieferte mir Code, der perfekt aussah, aber je nach Jahr an bestimmten Wochentagen scheiterte. Deshalb braucht ihr solide Tests – KI liefert euch selbstbewusst falschen Code.

Unser Testansatz sieht so aus – und er funktioniert hervorragend:

Tests schreiben, bevor ihr Code generiert (ja, TDD funktioniert mit KI)
Grenzfälle ausdrücklich testen
Mit realen Daten validieren
CI/CD zur automatisierten Validierung nutzen
Das Verhalten in Produktion überwachen

Hier ein praxisnahes Beispiel aus unserem Projekt zur Kalenderwochenberechnung:

test('should return week 13 for 25th of March 2025', () => {expect(getWeekNumber(new Date('2025-03-25'))).toBe(13);});

Schreibt solche Tests, bevor ihr überhaupt KI nach Code fragt. Wenn die KI euch etwas liefert, das gut aussieht, aber Woche 12 statt 13 zurückgibt, erkennt ihr das sofort. Eure Tests werden zu eurem Sicherheitsnetz.

Implementierungsstrategie

So legt ihr los: Wählt für eure erste KI-Implementierung etwas Unkritisches aus. Vielleicht eine Utility-Funktion oder ein internes Tool. Richtet geeignete Tests ein, probiert einige Prompts aus und schaut, was funktioniert. Macht euer Team mit dem Prozess vertraut.

Versucht nicht, eure Entwickler durch KI zu ersetzen – darum geht es nicht. Ihr erweitert ihren Werkzeugkasten um ein leistungsstarkes Tool, aber sie müssen lernen, es sicher und effektiv einzusetzen.

Erfolg mit DevOps-Metriken messen

Sprechen wir über Metriken. Nicht über Vanity Metrics, die in Präsentationen gut aussehen, sondern über die, die euch wirklich zeigen, ob KI euren Entwicklungsprozess unterstützt.

Die vier wichtigsten Metriken

Wenn ihr bewertet, wie gut eure KI-Implementierung funktioniert, konzentriert euch auf dieselben vier Metriken, die ihr hoffentlich bereits verfolgt. Lasst euch nicht von KI-spezifischen Metriken wie „generierte Codezeilen“ ablenken – sie sagen nichts Nützliches aus.

Ich zeige euch, was ihr messen solltet und was ich in der Praxis beobachtet habe:

Lead Time für Änderungen

Damit wird gemessen, wie lange es dauert, eine Änderung in die Produktion zu bringen. Mit KI sollte sich das doch verbessern, oder? Nun ja, so einfach ist es nicht.

Beim Projekt von GE Healthcare konnten Entwickler mit KI zwar schneller Code schreiben, aber die gesamte Lead Time veränderte sich aufgrund regulatorischer Anforderungen kaum.

In Webentwicklungsprojekten habe ich jedoch erlebt, wie Teams ihre Lead Time deutlich verkürzt haben, wenn sie KI mit guter Automatisierung kombinierten. Ihr programmiert nicht nur schneller – ihr werdet im gesamten Prozess besser, Ideen in funktionierende Software zu verwandeln.

Wiederherstellungszeit

Wenn etwas nicht funktioniert: Wie schnell könnt ihr es beheben?

Das ist bei KI-generiertem Code entscheidend, denn ihr werdet auf unerwartete Probleme stoßen. Beim zuvor gezeigten Beispiel zur Berechnung der Kalenderwoche haben wir den Fehler schnell gefunden und behoben, weil wir gute Tests und Deployment-Prozesse eingerichtet hatten.

Euer Ziel sollte sein, eure Wiederherstellungszeit beizubehalten oder zu verbessern, auch wenn ihr KI einführt. Wenn sie sich verschlechtert, geht ihr wahrscheinlich zu schnell vor.

Deployment-Häufigkeit

Aktuelle Studien zeigen, dass 75 % der Unternehmen inzwischen mehrmals pro Woche deployen. Wenn ihr einmal täglich deployt, seid ihr gut aufgestellt.

Mit KI deployt ihr möglicherweise häufiger, aber erzwingt es nicht – die Häufigkeit sollte sich nach euren geschäftlichen Anforderungen richten.

In meinen Projekten habe ich festgestellt, dass KI vor allem bei kleinen, häufigen Änderungen hilft:

Fehler beheben
Kleinere Features hinzufügen
Abhängigkeiten aktualisieren.

Die wichtigen Architekturentscheidungen erfordern weiterhin menschliches Denken und Planung.

Fehlerrate

Diese Kennzahl solltet ihr genau im Blick behalten, wenn ihr AI einsetzt. Eure Fehlerrate sollte nicht steigen, nur weil ihr AI-generierten Code verwendet. Falls doch, müsst ihr eure Validierungsprozesse stärken.

Ich verfolge Fehler in der Produktion sorgfältig, insbesondere in der Anfangsphase der AI-Einführung.

Meiner Erfahrung nach entstehen AI-bezogene Fehler meist durch missverstandene Anforderungen und nicht durch tatsächliche Programmierfehler – die AI schreibt syntaktisch korrekten Code, der jedoch das falsche Problem löst.

Diese Kennzahlen zusammen betrachten

So könnt ihr diese Kennzahlen in der Praxis nutzen:

Beginnt damit, sie zu erfassen, bevor ihr AI einführt. Ermittelt einen Ausgangswert. Beobachtet dann, wie sie sich verändern, wenn ihr AI-Tools einführt. Achtet auf Muster:

Werden einfache Änderungen schneller umgesetzt, während komplexe weiterhin gleich viel Zeit benötigen?
Findet ihr mehr Probleme beim Testen statt erst in der Produktion?
Verbringt euer Team weniger Zeit mit Boilerplate-Code und mehr mit Architektur?

Erinnert ihr euch an die große GitHub-Behauptung, dass die Entwicklung um 55 % schneller wird? In der Praxis werdet ihr in manchen Bereichen vielleicht moderate Verbesserungen sehen und in anderen gar keine. Das ist in Ordnung. Euer Ziel sind kontinuierliche, nachhaltige Verbesserungen – keine revolutionären Veränderungen.

Die Kennzahlen lügen nicht. Wenn eure Durchlaufzeit sinkt und eure Fehlerrate nicht steigt, macht ihr etwas richtig. Werden beide schlechter, tretet einen Schritt zurück und überprüft eure Prozesse.

Fassen wir zusammen

Nachdem ich euch durch die praktischen Aspekte AI-gestützter Entwicklung geführt habe, möchte ich ehrlich zu euch sein: AI wird die Softwareentwicklung nicht über Nacht revolutionieren.

Was ich bei der Einführung in verschiedenen Unternehmen gelernt habe: Am effektivsten ist AI, wenn ihr sie als ein weiteres Tool in eurem Entwicklungs-Toolkit betrachtet – wenn auch als ein besonders leistungsstarkes.

Der wahre Mehrwert von AI in der Softwareentwicklung liegt nicht darin, Entwickler zu ersetzen oder Code schneller zu schreiben. Es geht darum, wofür wir unsere Zeit einsetzen. Statt uns mit Boilerplate-Code herumzuschlagen oder API-Dokumentationen zu durchforsten, könnt ihr euch auf die anspruchsvollen Aspekte der Softwareentwicklung konzentrieren:

Die Bedürfnisse der Nutzer verstehen
Robuste Architekturen entwerfen
Komplexe Geschäftslogik umsetzen

Erinnert ihr euch an das Beispiel vom Anfang – das GE-Healthcare-Projekt?

Auch mit allen AI-Tools der Welt werdet ihr einen dreijährigen Entwicklungszyklus für ein Medizinprodukt nicht in einen dreimonatigen Sprint verwandeln. Aber ihr könnt diese drei Jahre produktiver gestalten, indem AI die Routineaufgaben übernimmt und euer Team sich auf die komplexen Herausforderungen konzentriert, die menschliche Einsicht erfordern.

Wenn ihr darüber nachdenkt, AI in euren Entwicklungsprozess einzuführen, beginnt mit den Grundlagen, die ich beschrieben habe. *

Sorgt für eine solide CI/CD-Pipeline
Stellt sicher, dass eure Tests robust sind
Versteht die Topologie eures Teams

Führt dann schrittweise AI-Tools dort ein, wo sie für euren spezifischen Kontext sinnvoll sind.

Am wichtigsten ist, dass ihr diese vier zentralen Kennzahlen weiterhin messt. Sie zeigen euch, ob AI euren Entwicklungsprozess tatsächlich verbessert oder nur zusätzliche Komplexität schafft.

In der Zukunft der Softwareentwicklung wird AI Entwickler nicht ersetzen. Entwickler, die AI-Tools effektiv einsetzen können, werden vielmehr besser abschneiden als jene, die das nicht können. Stellt sicher, dass ihr zur ersten Gruppe gehört.

Dieser Blog basiert auf einem Vortrag auf der GOTO-Konferenz 2023 in Kopenhagen. Seht euch Markos Vortrag an: