# Code-Review mit KI-Agenten: Qualität bei mehr Durchsatz halten

> Trennen Sie das Review in drei Schichten: deterministische Checks in der CI, eine KI-Vorprüfung auf Logik- und Sicherheitsfehler und eine menschliche Freigabe für Absicht, Architektur und Risiko. Kleine Änderungen, Regeln im Repository und Branch-Schutz verhindern, dass die KI selbst über den Merge entscheidet.

Kanonische URL: https://www.ruebstudio.de/de/wissen/ki-agenten-entwicklung/code-review-ki-agenten  
Autor: Dr.-Ing. Marcus Rüb, CEO  
Veröffentlicht: 2026-11-13

Wenn KI-Agenten Funktionen, Tests und Refactorings in Minuten liefern, verschiebt sich der Engpass der Softwareentwicklung: Nicht das Schreiben dauert, sondern das Prüfen. Dieser Überblick zeigt, wie Sie Code-Review so organisieren, dass Qualität und Verantwortung erhalten bleiben, obwohl deutlich mehr Änderungen eintreffen, als Menschen Zeile für Zeile lesen können. Stand: November 2026.

## Was ist KI-Code-Review und wofür wird es eingesetzt?

KI-Code-Review bedeutet, dass ein Sprachmodell oder ein Verbund von Agenten einen Pull Request liest, Fehler sucht und sie als Kommentare an den betroffenen Zeilen hinterlässt. Es ergänzt das menschliche Review, ersetzt es aber nicht: Die KI filtert vor, der Mensch entscheidet über den Merge.

Im Alltag übernimmt die KI drei Aufgaben:

- **Fehler finden**, die beim Lesen eines Diffs leicht untergehen: vertauschte Bedingungen, fehlende Fehlerbehandlung, nicht abgedeckte Randfälle, Datenbankabfragen ohne Mandantenfilter.
- **Teamregeln durchsetzen**, die kein Linter kennt, etwa „neue API-Routen brauchen einen Integrationstest" oder „keine personenbezogenen Daten in Logzeilen".
- **Kontext liefern**: eine Zusammenfassung, was die Änderung tut, damit der menschliche Reviewer schneller zum Kern kommt.

Wichtig ist die Abgrenzung zum Schreiben selbst. Wie Teams Agenten wie Claude Code, Codex oder Cursor im Alltag einsetzen, behandelt der Überblick [Agentische Softwareentwicklung im Team](https://www.ruebstudio.de/de/wissen/ki-agenten-entwicklung/agentische-softwareentwicklung-team). Dieser Artikel setzt eine Stufe später an: bei der Frage, wie das Ergebnis dieser Agenten geprüft wird, bevor es in den Hauptzweig gelangt.

## Warum wird das Review zum Engpass, wenn Agenten Code schreiben?

Agenten erhöhen die Menge an Änderungen, nicht die Zahl der Menschen, die sie verantworten. Ohne Anpassung entstehen große, schnell aufeinanderfolgende Pull Requests, die oberflächlich durchgewinkt werden. Daten aus der DORA-Forschung deuten darauf hin, dass mehr KI-Einsatz ohne solide Grundlagen die Lieferstabilität verschlechtern kann.

Der DORA-Bericht 2024 beobachtete laut [Google Cloud](https://cloud.google.com/blog/products/devops-sre/announcing-the-2024-dora-report) mit zunehmender KI-Nutzung einen geschätzten Rückgang des Liefer-Durchsatzes um 1,5 % und der Lieferstabilität um 7,2 %. Die Autoren führen das darauf zurück, dass ein besserer Entwicklungsprozess die Auslieferung nicht automatisch verbessert, wenn Grundlagen wie kleine Änderungspakete und robuste Tests fehlen. Es handelt sich um geschätzte Zusammenhänge aus Befragungsdaten, nicht um nachgewiesene Ursachen.

Der [DORA-Bericht 2025](https://dora.dev/research/2025/dora-report/) beschreibt KI als Verstärker, der vorhandene Stärken und Schwächen einer Organisation vergrößert. Für das Review heißt das: Ein Team mit klaren Regeln und kleinen Änderungen profitiert, ein Team mit schwammigen Freigaben bekommt mehr schwammig geprüften Code.

Drei Mechanismen machen das Review unter Agenten-Last fragil:

- **Größe:** Ein Agent kann in einem Lauf Hunderte Zeilen über viele Dateien ändern. Die [Engineering-Richtlinien von Google](https://google.github.io/eng-practices/review/developer/small-cls.html) nennen rund 100 Zeilen als meist vernünftig und 1.000 Zeilen als meist zu groß, und kleine Änderungen werden dort als schneller und gründlicher prüfbar beschrieben.
- **Plausibilität:** KI-Code sieht sauber aus, ist gut benannt und kommentiert. Das senkt die Aufmerksamkeit des Lesers, obwohl die Logik falsch sein kann.
- **Takt:** Wenn jede Stunde neue Pull Requests eintreffen, entsteht Druck, schneller freizugeben. Freigaben werden dann zur Formsache.

## Wie funktioniert ein KI-gestützter Review-Prozess?

Ein belastbarer Prozess besteht aus drei Schichten mit klarer Aufgabentrennung: Maschinen prüfen, was sich eindeutig prüfen lässt, die KI sucht nach inhaltlichen Fehlern, und der Mensch beurteilt Absicht, Architektur und Risiko. Jede Schicht entlastet die nächste, keine ersetzt sie.

**Schicht 1: deterministische Prüfungen.** Formatierung, Linter, Typprüfung, Tests, Abhängigkeits- und Geheimnis-Scans laufen in der CI und sind als erforderliche Statusprüfungen hinterlegt. Laut [GitHub](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches) müssen dann alle erforderlichen Statusprüfungen bestehen, bevor in einen geschützten Branch gemergt werden kann. Was hier abgedeckt ist, muss die KI nicht kommentieren.

**Schicht 2: KI-Vorprüfung.** Ein oder mehrere Agenten lesen den Diff samt umgebendem Code und melden Logikfehler, Sicherheitslücken und Verstöße gegen Teamregeln. Claude Code Review arbeitet laut [Dokumentation](https://code.claude.com/docs/en/code-review) in vier Stufen: Mehrere Agenten suchen parallel, ein Verifikationsschritt prüft die Kandidaten gegen den Code und filtert Fehlalarme, die verbleibenden Befunde werden dedupliziert und nach Schweregrad sortiert, dann als Kommentare gepostet.

**Schicht 3: menschliche Freigabe.** Ein Mensch mit Verantwortung für den betroffenen Code genehmigt. Über die Branch-Schutzregel „Require pull request reviews before merging" und Code Owners erzwingt GitHub, dass die passende Person zustimmt, bevor gemergt wird.

Dazu kommen **Regeln als Dateien im Repository**. Was das Team prüfen lassen will, steht versioniert neben dem Code, nicht in den Köpfen einzelner Reviewer. Das macht das Review nachvollziehbar und für Agenten wie für Menschen gleich lesbar.

## Welche Varianten von KI-Code-Review gibt es?

Es gibt fünf verbreitete Bauformen: in die Code-Plattform integrierte Reviews, einen verwalteten Review-Dienst, Agenten in der eigenen CI, eine lokale Vorprüfung vor dem Pull Request und eigene Review-Agenten. Sie schließen sich nicht aus, viele Teams kombinieren eine lokale Vorprüfung mit einer automatischen Prüfung am Pull Request.

**In die Plattform integriert.** GitHub Copilot code review kommentiert Pull Requests und schlägt Korrekturen vor. Laut [GitHub-Dokumentation](https://docs.github.com/en/copilot/concepts/agents/code-review) prüft Copilot standardmäßig nur, wenn es als Reviewer zugewiesen wird; automatische Reviews lassen sich pro Person, Repository oder Organisation einschalten, und es gibt die Stufen Lite, Balanced und Max. Einige Dateien wie Abhängigkeitsdateien (etwa `package.json`), Logs und SVGs werden ausgelassen.

**Verwalteter Dienst.** Claude Code Review läuft auf der Infrastruktur von Anthropic, liest das Repository nur lesend und baut oder startet den Code nicht. Der Dienst ist laut [Dokumentation](https://code.claude.com/docs/en/code-review) für Team- und Enterprise-Pläne mit GitHub-Repositories verfügbar und kennt die Stufen Quick, Standard und Deep.

**Agent in der eigenen CI.** Mit der GitHub Action `anthropics/claude-code-action@v1` läuft Claude auf Ihren eigenen Runnern. Ein Workflow kann bei jedem Pull Request einen Review-Skill starten; mit dem Argument `--comment` erscheinen die Befunde laut [Dokumentation](https://code.claude.com/docs/en/github-actions) als Inline-Kommentare am Pull Request statt nur im Workflow-Log. Diese Variante gibt Ihnen Kontrolle über Auslöser, Modell und Laufzeitgrenzen.

**Lokale Vorprüfung.** Entwickler lassen den Agenten vor dem Öffnen des Pull Requests prüfen, in Claude Code etwa mit dem Befehl `/code-review`. Fehler werden behoben, bevor ein Kollege überhaupt Zeit investiert.

**Eigene Review-Agenten.** Teams mit speziellen Anforderungen schreiben eigene Subagenten oder Skills, zum Beispiel für Migrationsskripte oder Schnittstellenverträge.

Welche Werkzeuge sich im Detail unterscheiden und welches zu welchem Team passt, gehört in einen eigenen Vergleich. Für den Gesamtprozess zählt vor allem, dass jede Variante an dieselben Regeln und dieselbe menschliche Freigabe gebunden ist.

## Worauf sollten sich menschliche Reviewer konzentrieren?

Menschen prüfen, was die KI nicht beurteilen kann: ob die Änderung das richtige Problem löst, ob sie zur Architektur passt und welches Risiko sie im Betrieb birgt. Stil, Formatierung und offensichtliche Fehler sollten zu diesem Zeitpunkt bereits von CI und KI erledigt sein.

Eine praktische Arbeitsteilung:

| Prüffrage | Wer prüft |
|---|---|
| Formatierung, Typen, Tests grün | CI |
| Logikfehler, Randfälle, unsichere Muster | KI-Vorprüfung |
| Teamregeln aus REVIEW.md oder Instruktionsdateien | KI-Vorprüfung, Stichprobe durch Mensch |
| Löst die Änderung das richtige Problem? | Mensch |
| Passt sie zur Architektur, ist sie rückrollbar? | Mensch |
| Berührt sie Sicherheit, Datenschutz, Geld oder Verträge? | Mensch, ggf. Code Owner |

Hilfreich ist der Maßstab, den Google als obersten Grundsatz seiner [Review-Richtlinien](https://google.github.io/eng-practices/review/reviewer/standard.html) formuliert: Reviewer sollen eine Änderung genehmigen, sobald sie die Gesamtqualität des Codes eindeutig verbessert, auch wenn sie nicht perfekt ist. Umgekehrt rechtfertigt nichts, Änderungen einzuchecken, die die Codequalität eindeutig verschlechtern. Dieser Maßstab gilt für Agenten-Code unverändert.

Konkret heißt das für menschliche Reviewer bei Agenten-Code:

- **Absicht vor Zeilen:** zuerst Ticket oder Spezifikation lesen, dann prüfen, ob der Diff genau das umsetzt und nicht mehr.
- **Tests kritisch lesen:** Agenten schreiben Tests, die zum eigenen Code passen. Prüfen Sie, ob ein Test die fachliche Anforderung abbildet oder nur das Ist-Verhalten festschreibt.
- **Unerwartete Dateien:** Änderungen an Konfiguration, Abhängigkeiten, CI-Workflows oder Instruktionsdateien bekommen besondere Aufmerksamkeit.
- **KI-Befunde bewerten, nicht abarbeiten:** Ein Kommentar der KI ist ein Hinweis. Wer ihn verwirft, sollte kurz begründen, warum.

## Welche Regeln braucht ein Team für KI-gestütztes Review?

Ein Team braucht drei Arten von Regeln: was die KI melden soll, wer am Ende freigibt und welche Größe eine Änderung haben darf. Alle drei gehören versioniert ins Repository oder in die Branch-Einstellungen, damit sie für Menschen und Agenten verbindlich und überprüfbar sind.

**Was die KI melden soll.** Claude Code Review liest laut [Dokumentation](https://code.claude.com/docs/en/code-review-customize) `CLAUDE.md` als Projektkontext und `REVIEW.md` als reine Review-Anweisungen. Darin legen Sie fest, was als wichtig gilt, welche Pfade übersprungen werden und wie viele Kleinigkeiten höchstens erscheinen. Ein Beispiel in Anlehnung an die Dokumentation:

```markdown
# Review-Anweisungen

## Was "Important" bedeutet
Nur Befunde, die Verhalten brechen, Daten preisgeben oder ein Rollback
verhindern. Stil- und Benennungsfragen sind höchstens Nit.

## Nits begrenzen
Höchstens fünf Nits pro Review.

## Nicht melden
- Alles, was die CI bereits prüft: Lint, Formatierung, Typfehler
- Generierte Dateien unter src/gen/ und alle *.lock-Dateien

## Immer prüfen
- Neue API-Routen haben einen Integrationstest
- Logzeilen enthalten keine E-Mail-Adressen oder Nutzer-IDs
- Datenbankabfragen sind auf den Mandanten des Aufrufers beschränkt
```

Bei GitHub Copilot übernehmen `.github/copilot-instructions.md`, pfadbezogene Dateien unter `.github/instructions/` und eine `AGENTS.md` im Wurzelverzeichnis diese Rolle.

**Wer liest welche Regeln von wo?** Hier liegt ein Sicherheitsdetail. Claude Code Review liest `REVIEW.md` vom Basis- oder Standard-Branch und nie aus den Änderungen des Pull Requests selbst. Copilot liest Instruktionen laut GitHub dagegen vom Head-Branch des Pull Requests, damit Änderungen daran im selben Pull Request testbar sind. Das heißt: Ein Pull Request kann bei Copilot die Regeln mitändern, nach denen er geprüft wird. Behandeln Sie Änderungen an Instruktionsdateien deshalb wie Änderungen an Sicherheitskonfiguration und lassen Sie sie über Code Owners freigeben.

**Wer freigibt.** Die KI darf nie allein entscheiden. Claude Code Review genehmigt oder blockiert laut Anthropic nie einen Pull Request, und sein Check-Run endet nicht als Fehlschlag. Copilot-Reviews zählen standardmäßig nicht als erforderliche Freigabe; schaltet man Copilot-Freigaben ein, verfällt eine solche Freigabe bei jedem neuen Push. Ob Sie diese Option nutzen, ist eine bewusste Governance-Entscheidung. Für geschäftskritischen Code ist eine menschliche Freigabe über Branch-Schutz und Code Owners der sichere Standard.

**Wie groß eine Änderung sein darf.** Legen Sie eine Obergrenze fest, ab der ein Pull Request geteilt wird, und schreiben Sie sie in die Anweisungen für die Agenten, die Code erzeugen. Die Google-Orientierung von rund 100 Zeilen ist ein guter Ausgangspunkt, die endgültige Grenze ist eine Teamentscheidung.

## Welche Voraussetzungen sollten erfüllt sein?

Ein KI-Review ist nur so gut wie die Umgebung, in der es läuft. Nötig sind eine funktionierende CI mit Tests, geschützte Branches, klare Verantwortlichkeiten für Codebereiche und eine Entscheidung, welche Daten an welchen Anbieter gehen dürfen.

- **CI und Tests:** Ohne automatisierte Tests prüft die KI ins Leere, weil niemand bestätigt, dass das Verhalten stimmt. Ein KI-Review baut oder startet den Code bei Claude Code Review laut Dokumentation nicht.
- **Branch-Schutz:** Erforderliche Reviews und Statusprüfungen am Hauptzweig sind die technische Klammer um den ganzen Prozess.
- **Code Owners:** Für sensible Bereiche wie Authentifizierung, Abrechnung oder Infrastruktur eine `CODEOWNERS`-Datei mit verantwortlichen Personen oder Teams.
- **Datenfreigabe:** Klären Sie mit Datenschutz und Informationssicherheit, ob Quellcode an einen Cloud-Dienst gehen darf. Claude Code Review ist laut Anthropic zum Beispiel nicht für Organisationen mit Zero Data Retention verfügbar; wer das braucht, muss Alternativen prüfen, etwa einen Agenten in der eigenen CI im Rahmen bestehender API-Vereinbarungen oder ein selbst betriebenes Modell.
- **Budget und Grenzen:** Jede automatische Prüfung kostet Rechenzeit oder Token. Laufzeitgrenzen, Prüftiefe und die Auslöser (bei jedem Push oder nur auf Anfrage) gehören bewusst gesetzt.

## Wie führen Sie KI-Code-Review in Schritten ein?

Beginnen Sie mit einem Repository, einer klaren Regeldatei und einer Pflicht zur menschlichen Freigabe. Messen Sie einige Wochen, wie viele KI-Befunde berechtigt sind, und weiten Sie erst dann auf weitere Repositories aus. So lernen Team und Werkzeug gemeinsam.

1. **Ausgangslage festhalten:** Wie lange warten Pull Requests heute auf ein Review, wie groß sind sie, wie oft gibt es Rückläufer nach dem Merge? Ohne diese Zahlen können Sie später keine Wirkung belegen.
2. **Branch-Schutz setzen:** erforderliche menschliche Freigabe, erforderliche Statusprüfungen, Code Owners für sensible Pfade.
3. **CI aufräumen:** Was ein Linter oder Typprüfer erkennt, gehört in die CI und wird in den Review-Anweisungen ausgeschlossen.
4. **Regeldatei anlegen:** `REVIEW.md` oder Copilot-Instruktionen mit wenigen, konkreten Punkten. Lieber fünf Regeln, die immer greifen, als fünfzig, die niemand pflegt. Je präziser die Spezifikation vor dem Schreiben ist, desto leichter wird das Review; dazu mehr im Artikel zur [spec-getriebenen Entwicklung mit Agenten](https://www.ruebstudio.de/de/wissen/ki-agenten-entwicklung/spec-driven-development-agenten).
5. **Pilot starten:** ein Repository, automatische Reviews bei Öffnen des Pull Requests. Jeder verworfene KI-Kommentar bekommt eine kurze Begründung.
6. **Nachschärfen:** Wiederkehrende Fehlalarme werden in der Regeldatei ausgeschlossen, wiederkehrende echte Fehler werden zur festen Regel oder zu einem neuen Test.
7. **Größengrenze für Agenten:** In den Anweisungen für codeerzeugende Agenten festhalten, dass Änderungen klein und thematisch geschlossen bleiben.
8. **Ausweiten:** weitere Repositories, gegebenenfalls unterschiedliche Prüftiefen für Routinecode und kritische Systeme.

## Wo liegen Grenzen und Risiken?

KI-Reviews übersehen Fehler, erzeugen Fehlalarme und können Vertrauen erzeugen, das sie nicht verdienen. Das größte Risiko ist organisatorisch: Wenn ein grüner KI-Check als Freigabe gelesen wird, sinkt die Prüftiefe genau dann, wenn mehr Code eintrifft.

- **Keine Garantie:** Anthropic schreibt ausdrücklich, dass ein Review ohne Befunde nicht bedeutet, dass der Code fehlerfrei oder sicher ist. GitHub rät, Copilots Rückmeldungen sorgfältig zu prüfen und ein menschliches Review zu ergänzen.
- **Fehlalarme:** Zu viele unberechtigte Kommentare führen dazu, dass alle ignoriert werden. Begrenzen Sie Kleinigkeiten und verlangen Sie Belege, etwa eine Datei- und Zeilenangabe für Verhaltensbehauptungen.
- **Gleiche blinde Flecken:** Wenn derselbe Modelltyp Code schreibt und prüft, teilt er womöglich dieselben Fehlannahmen. Deterministische Tests und menschliches Urteil sind deshalb keine Redundanz, sondern die eigentliche Absicherung.
- **Manipulierbare Regeln:** Instruktionsdateien und Kommentare im Code sind Eingaben für das Modell. Änderungen daran gehören unter Code-Owner-Schutz, und bei Plattformen, die Regeln aus dem Head-Branch lesen, besonders. Welche Angriffe auf Agenten es grundsätzlich gibt, beschreibt der Überblick [Sicherheit von KI-Agenten](https://www.ruebstudio.de/de/wissen/ki-agenten-architektur/sicherheit-ki-agenten).
- **Fehlende Ausführung:** Eine KI, die den Code nur liest, erkennt Laufzeitprobleme wie Leistungseinbrüche oder Wettlaufsituationen schlecht. Dafür braucht es Tests und Beobachtung im Betrieb.
- **Kosten und Takt:** Automatische Reviews bei jedem Push verbrauchen Budget. Prüftiefe und Auslöser sollten zum Risiko des Codes passen.

Wann passt der Ansatz nicht? In Repositories ohne Tests und ohne Branch-Schutz verschleiert ein KI-Review eher die Lücken, als sie zu schließen. Dort zuerst die Grundlagen schaffen.

## Wie fange ich an?

Starten Sie klein: ein Repository, eine kurze Regeldatei, verpflichtende menschliche Freigabe und eine Größengrenze für Agenten-Änderungen. Nach einigen Wochen wissen Sie, welche KI-Befunde wirklich helfen, und können den Prozess mit Belegen statt Bauchgefühl ausweiten.

Ein pragmatischer erster Schritt für diese Woche:

- Branch-Schutz am Hauptzweig prüfen und eine menschliche Freigabe verpflichtend machen.
- Eine `REVIEW.md` oder Copilot-Instruktionsdatei mit höchstens zehn Regeln anlegen, davon mindestens drei „Immer prüfen"-Punkte aus echten Fehlern der letzten Monate.
- Automatische KI-Reviews für ein Repository einschalten und jeden verworfenen Kommentar kurz begründen lassen.
- In den Anweisungen für codeerzeugende Agenten eine Obergrenze für die Größe von Pull Requests festhalten.

In unserem eigenen Betrieb hat sich bewährt, Review-Regeln wie Code zu behandeln: Sie werden per Pull Request geändert, haben einen verantwortlichen Owner und werden nachgeschärft, sobald ein Fehler durchrutscht. Wenn Sie Ihr Team in diese Arbeitsweise einführen wollen, ist ein gemeinsamer [Workshop zu agentischer Softwareentwicklung](https://www.ruebstudio.de/de/workshop) ein guter Rahmen, um Regeln, Branch-Schutz und Rollen an einem echten Repository festzulegen. Wie die Agenten auf der Schreibseite in den Teamalltag passen, beschreibt der Überblick [Agentische Softwareentwicklung im Team](https://www.ruebstudio.de/de/wissen/ki-agenten-entwicklung/agentische-softwareentwicklung-team).

## Häufige Fragen

### Kann ein KI-Review die menschliche Freigabe ersetzen?

Nein. Claude Code Review genehmigt oder blockiert laut Dokumentation nie einen Pull Request, und Copilot-Reviews zählen standardmäßig nicht als erforderliche Freigabe. Die Merge-Entscheidung bleibt beim Team.

### Welche Datei steuert, was die KI im Review meldet?

Bei Claude Code Review sind es REVIEW.md und CLAUDE.md im Repository, bei GitHub Copilot .github/copilot-instructions.md, pfadbezogene .instructions.md-Dateien und AGENTS.md. Halten Sie dort nur Regeln fest, die das Review tatsächlich verändern.

### Wie groß darf ein Pull Request sein, den ein Agent erzeugt?

Die Engineering-Richtlinien von Google nennen rund 100 Zeilen als meist vernünftig und 1.000 Zeilen als meist zu groß. Diese Orientierung gilt für Agenten genauso, weil der Mensch am Ende jede Zeile verantworten muss.

### Bedeutet ein Review ohne Befunde, dass der Code fehlerfrei ist?

Nein. Anthropic weist ausdrücklich darauf hin, dass ein Review ohne Befunde nicht heißt, dass der Code fehlerfrei oder sicher ist. Tests, statische Analyse und menschliches Urteil bleiben nötig.

## Quellen

- [Claude Code Docs: Code Review](https://code.claude.com/docs/en/code-review)
- [Claude Code Docs: Customize Code Review (REVIEW.md, CLAUDE.md)](https://code.claude.com/docs/en/code-review-customize)
- [Claude Code Docs: Claude Code GitHub Actions](https://code.claude.com/docs/en/github-actions)
- [GitHub Docs: About GitHub Copilot code review](https://docs.github.com/en/copilot/concepts/agents/code-review)
- [GitHub Docs: About protected branches](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches)
- [Google Engineering Practices: The Standard of Code Review](https://google.github.io/eng-practices/review/reviewer/standard.html)
- [Google Engineering Practices: Small CLs](https://google.github.io/eng-practices/review/developer/small-cls.html)
- [Google Cloud Blog: Highlights from the 10th DORA report (2024)](https://cloud.google.com/blog/products/devops-sre/announcing-the-2024-dora-report)
- [DORA: State of AI-assisted Software Development 2025](https://dora.dev/research/2025/dora-report/)
