Warum DevSecOps zum neuen Engpass im Zeitalter der KI-Programmierung wird

Kurz gesagt: Seit Jahrzehnten war das Schreiben von Software einer der kostspieligsten Aspekte bei der Entwicklung. Ingenieure mussten Anforderungen in eine Architektur umsetzen, Tausende von Codezeilen schreiben, Fehler beheben, Tests erstellen, Systeme miteinander verbinden und schließlich alles in Betrieb nehmen. Generative KI stellt diese Praxis auf den Kopf. Heute kann ein Entwickler einfach in alltäglicher Sprache beschreiben, was er benötigt, und ein KI-Codeagent erstellt einen großen Teil der eigentlichen Implementierung – APIs, SQL-Anfragen, Testsets, Infrastructure-as-Code, Dokumentation, Migrationsskripte, manchmal sogar ganze Anwendungen. Dies ist nicht länger ein Nischenexperiment. Googles DORA-Forschung von 2025 zeigte, dass 90 % der befragten Technologieprofis bereits KI in ihrer täglichen Arbeit einsetzten, und mehr als 80 % gaben an, dass dies ihre Produktivität steigerte. Doch es gibt einen Haken: Sobald gebaut

Software wird dramatisch günstiger, wodurch die Überprüfung dieser Software umso wichtiger wird. Mehr erstellter Code bedeutet eine größere Testfläche. Mehr eingebundene Abhängigkeiten bedeuten ein höheres Exponierungsrisiko entlang der Lieferkette. Mehr veröffentlichte Anwendungen erfordern mehr Infrastruktur zur Verwaltung. Mehr Releases bedeuten mehr Änderungen, die in die Produktion gelangen. Und mehr von KI erstellter Code führt zu weiteren offenen Fragen bezüglich seiner Herkunft, seiner Sicherheit, seiner Konformität sowie der Verantwortlichkeiten dafür. Der nächste echte Wendepunkt in der Softwareentwicklung könnte also gar nicht im kI-gestützten Programmieren liegen – es könnte KI-getriebenes DevSecOps sein: die automatisierte Vertrauensschicht zwischen von KI erzeugtem Code und den in der Produktion laufenden Systemen.

Die aktuelle Dynamik: KI greift den Programmierengpass an

Der klassische Ablauf im Softwareengineering sah im Allgemeinen so aus:

Anforderungen → Design → Programmierung → Testen → Sicherheit → Bereitstellung → Betrieb

Über weite Strecken dieser Geschichte nahm die eigentliche Programmierung den größten Teil der Arbeit in Anspruch.

Das manuelle Erstellen einer neuen API konnte einem Entwickler leicht mehrere Tage kosten.

Nun kann ein Entwickler stattdessen einem KI-Agenten folgende Anweisungen geben:

">Erstelle eine REST-API für die Onboarding-Prozesse neuer Kunden in Python. Enthalte Eingabenvalidierung, eine Persistenzschicht, Authentifizierung, Unit-Tests, ein Dockerfile sowie Bereitstellungsanleitungen."

Der Agent kann einen großen Teil dieser Arbeit bereits innerhalb weniger Minuten erledigen.

Das stellt einen grundlegenden Wandel in den Kostenstrukturen beim Erstellen von Software dar.

Die Kosten für die Entwicklung einer weiteren Funktion, eines weiteren Services oder einer weiteren App sinken stetig.

Die Reichweite der KI ist nicht mehr nur auf die automatische Vervollständigung von Code beschränkt – sie erstreckt sich nun auf agierendes Verhalten: Das Analysern ganzer Repositorien, das Bearbeiten mehrerer Dateien gleichzeitig, das Ausführen von Testfällen, das Beheben von Fehlern sowie das Eigenständige Erstellen von Pull-Requests.

Gartner bezeichnet diesen Trend als KI-basierte Softwareentwicklung – ein Modell, bei dem die KI durch den gesamten Entwicklungslebenszyklus integriert ist, anstatt nur bei Codeausschnitten zu helfen. Das Unternehmen prognostiziert, dass bis 2028 90 % der Unternehmensentwickler auf KI-gestützte Code-Assistenten zurückgreifen werden.

Doch ein schnelleres Schreiben von Code führt nicht automatisch zu einer schnelleren Veröffentlichung von Software.

Dieser Unterschied ist der entscheidende Punkt.

Wir verschieben das Engpassproblem

Stellen Sie sich eine Ingenieurorganisation vor, die früher folgendes veröffentlichte:

100 Softwareänderungen pro Woche.

Siehe da: Die Testpipeline, die Sicherheitsprüfungen sowie die Bereitstellungsinfrastruktur waren alle darauf ausgelegt, eine ähnliche Last zu bewältigen.

Nun kommen KI-Agenten ins Spiel.

Die Entwickler arbeiten plötzlich viel schneller, und die wöchentliche Menge an Erzeugnissen steigt auf:

300 Softwareänderungen.

Das ist ein enormer Sprung in der reinen Programmierkapazität.

Aber jetzt:

300 Änderungen erfordern eine Code-Überprüfung.

300 Änderungen erfordern Tests.

300 Änderungen benötigen eine Sicherheitsfreigabe.

300 Änderungen können neue Abhängigkeiten mit sich bringen.

300 Änderungen müssen gegen die Richtlinien überprüft werden.

300 Änderungen erfordern eine Entscheidung zur Bereitstellung.

Und all das führt letztendlich dazu, dass mehr Software im Produktivbetrieb überwacht werden muss.

Die Einschränkung ist nicht verschwunden – sie hat sich nur verlagert.

Die alte Frage lautete:

Können wir Software schnell genug entwickeln?

Die neue Frage lautet:

Können wir Software schnell genug validieren und sicher ausführen?

DORA beschreibt die Wirkung von KI als die eines Verstärkers – sie verstärkt alle bereits vorhandenen ingenieurtechnischen Praktiken, egal ob gut oder schlecht. Ihre Erkenntnisse deuten darauf hin, dass KI die Liefergeschwindigkeit erhöhen kann, während gleichzeitig Schwachstellen in Systemen aufgedeckt werden, die nicht dafür konzipiert sind, eine solche Geschwindigkeit zu bewältigen.

Diese Neudeutung ist von großer Bedeutung.

Die neue Gleichung der Softwareentwicklung

Einfach ausgedrückt sieht das entstehende Muster ungefähr so aus: Die Einführung von KI führt zu einem Anstieg der Codeerzeugung, was wiederum einen Anstieg der Anzahl der Änderungen im Entwicklungsprozess verursacht. Dies erfordert deutlich mehr Validierungen, was die Teams dazu bringt, stärker auf Automatisierung zurückzugreifen – und letztendlich zwingt dies Organisationen, mehr in Plattformentwicklung zu investieren.

Oder zusammengefasst in einem Satz:

Das Schreiben von Code wird günstiger. Das Vertrauen darauf wird zum wertvollen Aspekt.

Das ist der Hauptgrund, warum DevSecOps an Bedeutung gewinnen wird, da künstlich intelligenzgestützte Entwicklung zur Norm wird und nicht in den Hintergrund tritt.

Was ist DevSecOps genau?

Es ist einfach, DevSecOps auf „Hinzufügen eines Sicherheitsscanners an den CI/CD-Pipeline“ zu reduzieren, doch das unterschätzt, was es tatsächlich umfasst.

DevSecOps ist weitaus umfassender als das.

In seinem Kern vereint es:

Entwicklung + Sicherheit + Betrieb

zu einem kontinuierlichen Lieferprozess.

Bilden Sie sich es als das System vor, das entscheidet, ob etwas, das von einem Entwickler erstellt wurde – oder zunehmend von einem KI-Agenten generiert wurde – tatsächlich für den Einsatz in der Produktion geeignet ist.

Eine vollständige DevSecOps-Pipeline umfasst in der Regel:

Quellcodeverwaltung

Tracking-Code, Branches, Commits, Pull Requests sowie die Entwicklungsgeschichte im Laufe der Zeit.

Codequalität

Linting, statische Analyse, architektonische Überprüfungen sowie Bewertung der Wartbarkeit.

SAST

Durch statische Anwendungs-Sicherheitstests werden Sicherheitslücken direkt im Quellcode gesucht.

Erkennung von Geheimnissen

Scans nach Passwörtern, API-Schlüsseln, Zertifikaten oder Tokens, die versehentlich in das Repository eingefügt wurden.

SCA

Durch Software-Composition-Analyse werden riskante oder anfällige Abhängigkeiten von Drittanbietern erkannt.

SBOM

Eine Software-Bill-of-Materials-Liste führt alle tatsächlichen Komponenten auf, die in einer Anwendung enthalten sind.

Sicherheit von IaC

Scanner, die Terraform-, CloudFormation-, Kubernetes-Manifeste sowie ähnlichen Infrastrukturcode prüfen.

Kontainer-Sicherheit

Überprüfung von Container-Bildern auf anfällige Betriebssystem-Pakete, veraltete Bibliotheken und Fehlkonfigurationen.

Testing

Unit-, Integrationstests, Regressionstests, API-Tests, Leistungstests sowie zunehmend von KI erzeugte Tests, die bestätigen, dass das Verhalten korrekt ist.

Richtlinien und Konformität

unternehmensspezifische Regeln, die überprüfen, ob die Software organisatorische, regulatorische und architektonische Standards erfüllt.

CI/CD

Sobald etwas genehmigt wurde, wird die Software erstellt, verpackt und in den verschiedenen Umgebungen bereitgestellt.

Einsatz

Rollout-Strategien wie Canary-Releases, Blue/Green-Deployment sowie Feature Flags bestimmen, wie der Code in die Produktion gelangt.

Sicherheit und Beobachtbarkeit im Laufzeitbetrieb

Live-Anwendungen werden kontinuierlich auf Schwachstellen, Angriffe, Abstürze, ungewöhnliches Verhalten sowie Leistungsabfälle überwacht.

Dieses gesamte System wird umso wichtiger, je größer der Anteil an tatsächlicher Programmierung durch Maschinen wird.

KI verändert auch DevSecOps

Es gibt eine weitere Dimension dieser Veränderung, die es zu untersuchen lohnt.

DevSecOps wird nicht nur mit einer größeren Menge an von KI erstelltem Code umgehen.

DevSecOps selbst wird von KI angetrieben.

Derzeit könnte ein typischer Scanner etwas wie Folgendes melden:

Kritische Schwachstelle in Abhängigkeit X entdeckt.

Eine von KI angetriebene Version desselben Systems kann noch weiter gehen:

Kritische Schwachstelle entdeckt. Hier ist der Grund, warum das wichtig ist. Hier ist der betroffene Codepfad. Hier ist die empfohlene Version. Ich habe die Korrektur erstellt. Ich habe die Regressionstests durchgeführt. Hier ist der Pull Request.

Das stellt eine völlig andere Arbeitsweise dar.

Von der Erkennung zur autonomen Behebung

Betrachten Sie, wie sich diese Fähigkeit in Etappen entwickelt.

Generation 1: Erkennung

Das Tool warnt einen Menschen:

„Es gibt eine Schwachstelle.“

Dann macht sich der Ingenieur daran, die Sache zu untersuchen.

Generation 2: Empfehlung

Das Tool geht noch einen Schritt weiter:

„Es gibt eine Schwachstelle, und hier ist die Lösung.“

Der Ingenieur führt die vorgeschlagene Korrektur durch.

Generation 3: Behebung

Das Tool unternimmt einen weiteren Schritt:

„Es gibt eine Schwachstelle. Ich habe bereits die Korrektur geschrieben und einen Pull Request erstellt.“

Die Aufgabe des Ingenieurs besteht nun darin, diesen zu prüfen.

Generation 4: Autonome DevSecOps

Schließlich können bei Änderungen mit ausreichend niedrigem Risiko die gesamte Kette:

Erkennen → Verstehen → Beheben → Testen → Validieren → Bereitstellen → Überwachen

größtenteils ohne menschliche Einmischung ablaufen.

Anstatt jeden Schritt manuell auszuführen, konzentrieren sich die Menschen eher auf die Festlegung von Richtlinien, das Handhaben von Ausnahmen und die Überwachung des Systems als Ganzes.

Die Software-Lieferkette wird entscheidend

Es gibt einen zweiten Grund, warum dieser Wandel so wichtig ist.

Modernes Software wird selten vollständig von Grund auf entwickelt. Stattdessen wird sie aus vielen externen Quellen zusammengesetzt: Bibliotheken aus Open-Source-Registern, APIs Dritter, vorgefertigte Container-Bilder, Anwendungsframeworks, verwaltete Cloud-Dienste, wiederverwendbare Infrastrukturmodule – und mittlerweile auch Ausgaben, die direkt von KI-Tools erzeugt werden.

KI beschleunigt diese Zusammenstellung erheblich.

Sonatapes Forschung von 2026 zu Software-Lieferketten beschreibt das Ökosystem als auf einer Maschenebene angesiedelt, wobei auf automatisierte Builds, erweiterte Abhängigkeitsgraphen sowie KI-Agenten hingewiesen wird, die die Herkunft und Zuverlässigkeit wichtiger machen als je zuvor.

Deshalb benötigen Organisationen zunehmend Antworten auf Fragen wie:

Wo stammt dieser Code her?

Welche KI hat ihn erzeugt?

Welche Modellversion hat ihn generiert?

Welche Abhängigkeiten wurden verwendet?

Wurden diese Abhängigkeiten überprüft und freigegeben?

Welche Sicherheitschecks wurden durchgeführt?

Welche Richtlinien wurden angewandt?

Wer hat die Bereitstellung genehmigt?

Was läuft aktuell in der Produktion?

Das bringt DevSecOps weit über einfache Automatisierung hinaus.

Dadurch entsteht ein unternehmensweites Vertrauenssystem für Software.

Verantwortung bei KI wird zu einer neuen Anforderung

Diese Sorge taucht bereits in Branchenumfragen auf.

Eine GitLab-Umfrage aus dem Jahr 2026 ergab, dass 80 Prozent der Befragten angaben, ihre Organisationen hätten KI-Tools schneller eingeführt, als sie entsprechende Governance-Politiken entwickeln konnten, und 92 Prozent berichteten von Governance-Problemen, die speziell mit von KI erzeugtem Code zusammenhingen.

Stellen Sie sich einen Prüfer vor, der fragt:

"Warum greift dieser Codeabschnitt auf die finanziellen Daten der Kunden zu?"

Zuvor konnte man einfach den verantwortlichen Entwickler nennen.

In einem agilen Entwicklungsprozess könnte die ehrliche Antwort stattdessen lauten:

„Ein KI-Code-Agent hat es während der Arbeit an Funktion #4821 erstellt.“

Das eröffnet eine ganz neue Reihe von Governance-Fragen.

Welcher Prompt hat seine Erstellung ausgelöst?

Auf welchen Kontext hatte es Zugriff?

Hat es eine neue Abhängigkeit herangezogen?

War diese Abhängigkeit für die Verwendung freigegeben?

Welche Tests wurden tatsächlich durchgeführt?

Hat ein Mensch die Änderung vor dem Merge überprüft?

Welcher KI-Sicherheits-Agent, falls überhaupt, hat sie bewertet?

Kurz gesagt: Die Ursprungsverfolgbarkeit von KI entwickelt sich zu einem neuen, erforderlichen Element in der Software-Lieferkette.

Der Aufstieg der KI-DevSecOps-Plattform

Heute nutzen Unternehmen in der Regel eine Mischung aus unvollständig vernetzten Tools, wie zum Beispiel:

Entwickler → GitHub → Jenkins → SonarQube → Snyk → Artifactory → Kubernetes → Datadog → ServiceNow

Jedes Werkzeug befasst sich mit einem bestimmten Aspekt des Workflows.

KI macht diese Fragmentierung deutlich teurer, denn Agenten benötigen eine Übersicht über den gesamten Lebenszyklus, um nützlich zu sein.

Ein KI-Agent, der ein Produktionsproblem behebt, könnte auf Folgendes zugreifen müssen:

• Die ursprüngliche Anforderung
• Quellcode
• Commit-Historie
• Testergebnisse
• Daten zu Schwachstellen
• Deployment-Historie
• Infrastrukturkonfiguration
• Ausführungslogs
• Produktions-Telemetriedaten
• Ehemalige Incidentschreibungen

Dieser Bedarf treibt den Markt in Richtung vereinter Engineering-Plattformen.

Gartner zählt bereits Plattformengineering sowie Plattformengineering mit GenAI-Technologien zu den wichtigsten Trends im Softwareengineering und prognostiziert, dass bis 2027 70 Prozent der Organisationen, die Plattformteams betreiben, GenAI-Funktionen in ihre internen Entwicklerplattformen integriert haben werden.

DORA weist auf einen damit verbundenen Punkt hin: Die Qualität einer Plattform bestimmt maßgeblich, ob die Einführung von KI tatsächlich die Leistungsfähigkeit der Organisation steigert oder stattdessen nur „Rückwärtsprobleme“ verursacht.

Wohin sich der Wert verschiebt

Diese Veränderung hat erhebliche Auswirkungen auf die gesamte Technologiebranche.

Während der ersten Welle des Hypes um generative KI konzentrierte sich die meiste Aufmerksamkeit auf eine Frage:

Welcher Code-Assistent ist am besten?

Diese Frage ist nach wie vor relevant.

Aber daneben taucht eine größere unternehmensbezogene Frage auf:

Wer kontrolliert den Weg von einer von KI erzeugten Idee bis zu vertrauenswürdigem Produktionssoftware?

Derzeit konzentriert sich dort enormer Wert. Betrachten Sie die beteiligten Schichten:

KI-basiertes Programmieren

Werkzeuge wie Copilot, Claude Code, Cursor und ähnliche.

↓

Quellcode & Zusammenarbeit

Plattformen wie GitHub, GitLab und Bitbucket.

↓

Sicherheit

SAST, SCA, Scannen von Geheimnissen, Container-Sicherheit und Sicherheit der Lieferkette.

↓

Verwaltung von Artefakten

Pakete, Container und Nachweisdokumente.

↓

CI/CD

Automatisierte Erstellung, Tests und Bereitstellung.

↓

Cloud-Plattformen

Infrastruktur und Laufzeitumgebungen.

↓

Beobachtbarkeit

Protokolle, Metriken, Spuren, Vorfälle und Erkenntnisse aus der Produktion.

↓

Verwaltung

Richtlinien, Genehmigungen, Prüfprotokolle und Konformitätsaufzeichnungen.

Jene Plattform, die es schafft, diese Komponenten zu vereinen, wird von außergewöhnlicher strategischer Bedeutung sein.

Die Zukunft: Entwickler werden Orchesterer

Das bedeutet keineswegs, dass die Rolle des Entwicklers verschwindet.

Was sich ändert, ist das Tagesgeschäft dieser Arbeit.

Derzeit verbringen die meisten Entwickler den größten Teil ihrer Zeit damit, Implementierungslogik zu schreiben.

In Zukunft wird sich das darauf konzentrieren, als Orchesterer intelligenter Systeme zu fungieren.

Anstatt der Maschine zu sagen:

Schreibe diese Funktion.

wird der Ingenieur eher sagen:

Bilde diese Fähigkeit auf.

Die KI übernimmt dann die Erstellung der Implementierung.

Die Aufmerksamkeit des Menschen richtet sich auf die Beurteilung von Architekturauswahlen, Geschäftsregeln und Risikobelastungen.

Sicherheitsexperten suchen nach Schwachstellen.

Testagenten überprüfen, ob das Verhalten korrekt ist.

Deployment-Agenten kümmern sich um die Implementierungsmechanismen.

Observability-Agenten überwachen das System, sobald es im Live-Betrieb ist.

Zunehmend besteht die Aufgabe des Menschen darin, das System als Ganzes zu überwachen, anstatt es Stück für Stück zusammenzustellen.

Gartner hat eine ähnliche Prognose abgegeben und beschreibt, wie Entwickler sich auf Orchestrierung, Problemanalyse, Systemdesign konzentrieren sowie sicherstellen, dass von KI erzeugte Ergebnisse tatsächlich den Qualitätsanforderungen entsprechen.

Auch DevSecOps-Engineer ändern sich

Die Rolle der DevSecOps entwickelt sich in ähnlicher Richtung weiter.

Die Aufgaben umfassen traditionell:

• Das Erstellen von Pipelines
• Die Wartung von Jenkins
• Die Konfiguration von Scannern

Verwaltung von Bereitstellungsskripten

Fehlerbehebung in Umgebungen

Dies bezieht sich zunehmend auf Aspekte wie:

• Architektur der Plattformen, die Software von Anfang bis Ende liefern
• Einrichtung der Richtlinien, auf die eine ganze Organisation angewiesen ist
• Schreibung der Sicherheitsregeln, die von Agenten befolgt werden müssen
• Überwachung dessen, was autonome Programmieragenten tun dürfen
• Entwicklung von Systemen, die Probleme automatisch beheben statt auf einen Menschen zu warten
• Aufspüren der Herkunft jeder Softwarekomponente
• Erstellung gemeinsamer Vorlagen, die Teams wiederverwenden können, anstatt von Grund auf anzufangen
• Berechnung des ingenieurtechnischen Risikos, das die Organisation trägt
• Aufrechterhaltung zuverlässiger Funktion von autonomen Bereitstellungssystemen

Anders ausgedrückt:

Die Aufgabe von DevSecOps konzentriert sich nicht mehr darauf, die Entwicklungsprozesse am Laufen zu halten, sondern darauf, die Kontrollschicht zu schaffen, die Software zu steuern, die durch KI erzeugt wird.

Sicherheitsaspekte: Vom Kontrollpunkt zur Schutzmaßnahme

In den meisten Organisationen heute fungiert die Sicherheit als Kontrollpunkt.

Die Entwickler fertigen etwas ab.

Die Sicherheitsteam prüft es.

Es tauchen Probleme auf.

Die Entwickler beheben sie.

Die Sicherheitsteam prüft es erneut.

Dieses Hin- und Her wird unpraktisch, sobald KI die Entwicklungsgeschwindigkeit erheblich über das frühere Niveau hebt.

Die neue Vorgehensweise sieht eher so aus:

Richtlinie → Automatisierung → Kontinuierliche Durchsetzung

Die Sicherheitsteams formulieren die Regeln einmalig.

Die Plattform wendet diese Regeln dann kontinuierlich an, ohne auf eine manuelle Bestätigung jedes Mal warten zu müssen.

So funktioniert das in der Praxis.

Regel: Keine API, die der Internetwelt zugänglich ist, darf ohne Authentifizierung genutzt werden.

Ein KI-Agent liefert eine API aus, bei der diese Überprüfung fehlt.

Die DevSecOps-Plattform bemerkt dies sofort.

Die Bereitstellung wird automatisch blockiert.

Dem Programmieragenten wird genau mitgeteilt, warum das der Fall ist.

Der Programmieragent behebt den Fehler in der API.

Es werden erneut Tests durchgeführt.

Die Sicherheitsregel ist nun eingehalten.

Die Bereitstellung kann fortgesetzt werden.

Niemand im Sicherheitsteam hat dies manuell überprüft.

Trotzdem wird die Richtlinie zu jedem Zeitpunkt des Prozesses eingehalten.

Das ist der eigentliche Vorteil von kI-gestütztem DevSecOps.

Warum Unternehmen möglicherweise mehr statt weniger für DevSecOps ausgeben

Es ist verlockend anzunehmen, dass KI es Unternehmen ermöglicht, mit weniger Tools und geringeren Ausgaben für Infrastruktur auszukommen.

In kritischen Bereichen des Technologiestacks ist das Gegenteil wahrscheinlicher.

KI ermöglicht es Organisationen, weitaus mehr Software zu entwickeln als zuvor.

Jede zusätzlich veröffentlichte Anwendung bringt jedoch ihre eigenen Folgen mit sich: eine weitere API, die bereitgestellt werden muss, ein weiterer Container, der ausgeführt werden soll, eine weitere Reihe von Abhängigkeiten, die überwacht werden müssen, mehr Cloud-Ressourcen, die bereitgestellt werden müssen, eine weitere Runde der Sicherheitsüberprüfung, eine weitere Bereitstellung, die verwaltet werden muss, zusätzliche Telemetriedaten, die durchgesehen werden müssen, neue Sicherheitslücken, die behoben werden müssen, sowie weitere Nachweise zur Konformität, die gesammelt und aufbewahrt werden müssen.

Kurz gesagt bedeutet mehr Software in Produktion einfach, dass alles, was überwacht, überprüft und zuverlässig gehalten werden muss, in größerem Umfang vorhanden ist.

Frühere Umfragen von GitLab zu DevSecOps zeigten bereits, dass Sicherheitsexperten befürchten, dass von KI erzeugter Code ihre Arbeitslast erhöhen wird. Die Studie für 2026 weist auf das sogenannte „AI-Effizienz-Paradoxon“ hin, bei dem eine schnellere Codeerstellung in Kombination mit unvollständigen Tools später im Prozess neue Engpässe verursachen kann.

Daher verschiebt sich die wirtschaftliche Ausrichtung von:

Dem Bezahlen von Mitarbeitern hauptsächlich dafür, Code zu erstellen

nach:

Dem Bezahlen von Plattformen, die in der Lage sind, große Mengen an Softwareinhalten sicher zu verwalten.

Ein einfaches Beispiel

Hier ist eine konkrete Veranschaulichung.

Stellen Sie sich vor, eine Bank benötigt eine neue Funktion:

Es soll Kunden ermöglicht werden, ihre Kreditkarte über die Mobile-App zu sperren.

Vorher

Ein Produktmanager formuliert die Anforderungen.

Ein Entwickler entwirft die API.

Der Entwickler schreibt den Code.

Ein Kollege überprüft ihn.

Die QA-Abteilung erstellt einen Testumfang.

Die Sicherheitseinheit führt ihre Scans durch.

DevOps setzt den Pipeline-Prozess zusammen.

Die Operations-Abteilung kümmert sich um den Rollout.

Das Ganze kann Tage oder Wochen in Anspruch nehmen, bis es abgeschlossen ist.

Morgen

Anstelle dessen schreibt ein Produktmanager:

"Lassen Sie authentifizierte Kunden eine Karte einfrieren und auftauen, jede Aktion zu Prüfzwecken protokollieren sowie den Kunden bei solchen Vorgängen benachrichtigen."

Ein Engineering-Mitarbeiter nimmt diese Anforderung auf und arbeitet daran.

Dadurch entstehen:

• API
• Datenbankänderungen
• Business-Logik
• Unit-Tests
• API-Tests
• Infrastrukturänderungen
• Dokumentation

Das kann nur wenige Minuten dauern.

Nun tritt die AI DevSecOps-Plattform in Aktion.

Es wird festgestellt, dass die KI eine erforderliche Autorisierungsprüfung am neuen Endpunkt weggelassen hat.

Sicherheitsagent: BLOCKIEREN.

Ebenso wird entdeckt, dass eine neu eingeführte Open-Source-Bibliothek eine kritische, bekannte Schwachstelle aufweist.

Lieferkettenrichtlinie: BLOCKIEREN.

Der Programmieragent ersetzt die Bibliothek durch eine sicherere Abhängigkeit.

Es werden erneut Tests durchgeführt.

Testagent: BESTANDEN.

Die Plattform bestätigt, dass Verschlüsselung, Protokollierung und Authentifizierung ordnungsgemäß funktionieren.

Konformitätsrichtlinien: BESTANDEN.

Die App wird in eine Testumgebung verschickt.

Synthetische Transaktionen werden durchgeführt, um echte Nutzungsszenarien nachzustellen.

Ausführungszeit-Validierung: BESTANDEN.

Durch einen Canary-Rollout wird ein kleiner Anteil, beispielsweise 5 %, des Live-Traffics an die neue Version geleitet.

Die Überwachung zeigt keine ungewöhnlichen Fehlerraten.

Der Datenverkehr wird schrittweise erhöht, bis er alle erreicht.

Die Funktion ist jetzt verfügbar.

Die gesamte Abfolge hinterlässt eine vollständige Audit-Spur:

Anforderung → KI-Agent → Code → Abhängigkeiten → Tests → Sicherheitsentscheidungen → Genehmigungen → Bereitstellung → Laufzeitbelege

Das ist AI DevSecOps in Aktion.

Und hier kommt der interessante Teil.

Die Erstellung des Codes war tatsächlich der einfachste Schritt.

Der wertvolle Teil war die Infrastruktur, die zuverlässig antworten konnte:

Ist diese Software tatsächlich bereit für die Produktion?

Der größere Wandel

Über einen langen Zeitraum konzentrierten sich Gespräche über KI in der Softwareentwicklung hauptsächlich auf eine Sache: die Leistung der Entwickler.

Wie viel schneller kann KI diejenigen, die Code schreiben, machen?

Diese Frage erscheint allmählich zu begrenzt.

Eine größere Frage verdient mehr Aufmerksamkeit:

Was passiert, sobald die Erstellung von Software nicht mehr eine knappe Ressource ist?

Sobald Code in Überfluss vorhanden ist, benötigen Organisationen eigentlich eine Methode, um genauso schnell Vertrauen aufzubauen wie der Code geschrieben wird.

Das bedeutet Tests, Sicherheit, die Verwaltung der Software-Lieferkette, Governance, die automatische Durchsetzung von Richtlinien, die Automatisierung der Bereitstellung sowie das Überwachen von Systemen in der Produktion. Zudem muss man nachverfolgen, woher die von KI erzeugten Arbeiten tatsächlich stammen. Und immer häufiger geht es darum, Probleme ohne Wartezeit auf einen Menschen zu beheben. Zusammen bilden all diese Aspekte die nächste Generation von DevSecOps.

In der früheren Phase künstlicher Intelligenz in der Softwareentwicklung ging es hauptsächlich darum, Menschen dabei zu helfen, schneller Code zu schreiben.

Die nächste Phase zielt darauf ab, Menschen und KI-Agenten dazu zu ermöglichen, gemeinsam und sicher ganze Softwarefabriken zu betreiben.

So betrachtet ist DevSecOps keine Funktion, die nach der Entwicklung kommt und danach aufräumt.

DevSecOps wird zum Steuerungsmechanismus, auf dem die gesamte von KI angetriebene Softwarefabrik läuft.