Ein LLM kann Ihren Code vorab prüfen. Es kann aber nicht das Meeting leiten.

Die kurze Antwort lautet Nein, aber die lange Antwort spart Ihnen Stunden

Eine vollständige Fagan-Inspektion benötigt einen Moderator, einen Vorleser, zwei bis vier Inspektoren und den Autor. Das Team verbringt zwei Stunden damit, etwa 250 Zeilen Code mit einem Tempo von 125 Zeilen pro Stunde zu reviewen. Das sind acht bis zwölf Personenstunden für eine kleine Änderung.

Ein LLM kann 250 Zeilen in weniger als einer Sekunde lesen. Es kann eine Checkliste abarbeiten, verdächtige Muster markieren und ein Fehlerprotokoll erstellen, bevor ein Mensch die Datei öffnet.

Das bedeutet nicht, dass es das Team ersetzen kann. Es bedeutet, dass das Team das Meeting nicht beginnen sollte, bevor das LLM seine Hausaufgaben erledigt hat.

Was ein LLM in einer Fagan-Inspektion tatsächlich leisten kann

Fagan-Inspektionen haben vier unterschiedliche Rollen. Jede Rolle hat eine Aufgabe, die sich unterschiedlich auf das abbilden lässt, was ein LLM kann und nicht kann.

Der Moderator plant die Inspektion, erzwingt Einstiegskriterien und hält das Meeting auf Kurs. Ein LLM kann eine Checkliste erstellen, überprüfen, dass Tests vor der Inspektion bestehen, und den Zeitaufwand anhand der Zeilenanzahl schätzen. Es kann nicht erkennen, ob ein Raum voller Ingenieure in eine Design-Debate abdriftet. Die Moderator-Rolle ist sozial, und LLMs sind nicht sozial.

Der Vorleser paraphrasiert den Code während des Meetings laut, um die Gruppe zu zwingen, die Logik in Verständnisgeschwindigkeit und nicht in Überfliegeschwindigkeit zu verarbeiten. Ein LLM kann Code zusammenfassen, aber es kann einen Raum voller Menschen nicht bremsen. Der wahre Wert des Vorlesers ist soziale Durchsetzung. Das LLM hat keinen Hebel.

Die Inspektoren finden Defekte, indem sie den Code anhand von Checklisten und Domänenwissen untersuchen. Hier ist das LLM am nützlichsten. Es kann nach fehlenden null-Prüfungen, Ressourcenlecks, unbehandelten Fehlerpfaden und Off-by-One-Fehlern schneller suchen als jeder Mensch. Es wird nicht müde. Es überspringt keine langweiligen Hilfsfunktionen, weil sie harmlos aussehen.

Der Autor beantwortet Fragen und behebt Defekte. Das LLM kann den Autor nicht ersetzen, weil es den Code nicht geschrieben hat und die Absicht nicht verifizieren kann.

Die realistische Antwort lautet also nicht Ersatz, sondern Rollenersetzung. Das LLM kann als unermüdlicher Vorab-Inspektor dienen, der die mechanischen Teile der Inspektoren-Rolle übernimmt, bevor die Menschen den Raum betreten.

Wo LLMs tatsächlich helfen: Die Vorbereitungsphase

Die wichtigste Phase einer Fagan-Inspektion ist die Vorbereitung. Jeder Inspektor reviewt das Material allein vor dem Meeting. Studien zeigen, dass die Vorbereitung etwa die Hälfte der Defekte findet, die im gesamten Prozess entdeckt werden. Wenn das LLM diese Phase beschleunigen kann, wird das menschliche Meeting kürzer und präziser.

Hier ist ein praktischer Ansatz. Füttern Sie das LLM mit dem Code, einer auf Ihre Sprache zugeschnittenen Checkliste und einem Prompt, der strukturierte Ausgabe erzwingt. Verwenden Sie die LLM-Ausgabe als Ausgangspunkt für menschliche Inspektoren, nicht als Ersatz.

Der Prompt ist wichtiger als das Modell. Eine vage Anfrage wie “reviewe diesen Code” liefert allgemeine Platituden. Ein strukturierter Prompt mit Checkliste und Ausgabeformat liefert umsetzbare Defekte.

Unten ist ein Python-Skript, das eine LLM-basierte Vorab-Inspektion mit einer OpenAI-kompatiblen API durchführt. Es liest eine Quelldatei, wendet eine Fagan-ähnliche Checkliste an und gibt ein strukturiertes Fehlerprotokoll aus.

#!/usr/bin/env python3
"""
LLM pre-inspection for Fagan-style review.
Produces structured defect log from a checklist.
"""

import argparse
import os
from pathlib import Path


def build_prompt(code: str, filepath: str, language: str) -> str:
    checklist = {
        "python": [
            "Missing null/None checks before dereferencing",
            "Unclosed file handles or missing context managers",
            "Bare except clauses that swallow exceptions",
            "Mutable default arguments in function signatures",
            "Race conditions in shared mutable state",
            "Missing input validation on public functions",
        ],
        "typescript": [
            "Non-null assertions (e.g., !) without justification",
            "Missing await on async calls",
            "Any types that should be narrowed",
            "Unhandled promise rejections",
            "Missing input validation on public functions",
        ],
        "rust": [
            "Unwrap or expect without comment explaining invariants",
            "Missing error propagation where Result is returned",
            "Unsafe blocks without safety comments",
            "Clone on large data structures in hot paths",
            "Missing input validation on public functions",
        ],
    }

    items = checklist.get(language, checklist["python"])
    checklist_text = "\n".join(f"  - {item}" for item in items)

    return (
        "You are a Fagan inspection assistant. Review the following code "
        "against the checklist. For each defect found, output a JSON object "
        "with keys: line, category, severity (minor/major/critical), description. "
        "If no defect is found for a checklist item, omit it. "
        "Be specific about line numbers and exact variable names. "
        "Do not suggest fixes. Fagan inspections only log defects, they do not solve them.\n\n"
        f"File: {filepath}\n"
        f"Language: {language}\n\n"
        "Checklist:\n"
        f"{checklist_text}\n\n"
        "Code:\n```\n"
        f"{code}\n"
        "```\n\n"
        "Output strict JSON array of defects only. No markdown, no preamble."
    )


def inspect_file(filepath: str, api_key: str, base_url: str) -> list:
    """Run LLM pre-inspection and return parsed defect list."""
    from openai import OpenAI

    path = Path(filepath)
    code = path.read_text()

    # Infer language from extension
    ext_map = {
        ".py": "python",
        ".ts": "typescript",
        ".tsx": "typescript",
        ".rs": "rust",
    }
    language = ext_map.get(path.suffix, "python")

    client = OpenAI(api_key=api_key, base_url=base_url)
    response = client.chat.completions.create(
        model=os.environ.get("INSPECTION_MODEL", "gpt-4.1-mini"),
        messages=[
            {"role": "system", "content": "You are a precise code inspection tool."},
            {"role": "user", "content": build_prompt(code, filepath, language)},
        ],
        temperature=0.2,
        max_tokens=2048,
    )

    raw = response.choices[0].message.content.strip()

    # Some models wrap JSON in markdown fences. Strip them.
    if raw.startswith("```json"):
        raw = raw[7:]
    if raw.startswith("```"):
        raw = raw[3:]
    if raw.endswith("```"):
        raw = raw[:-3]
    raw = raw.strip()

    import json
    try:
        defects = json.loads(raw)
        if not isinstance(defects, list):
            return []
        return defects
    except json.JSONDecodeError:
        print("Warning: LLM returned non-JSON output:")
        print(raw[:500])
        return []


def main():
    parser = argparse.ArgumentParser(description="LLM pre-inspection for Fagan review")
    parser.add_argument("files", nargs="+", help="Source files to pre-inspect")
    parser.add_argument("--api-key", default=os.environ.get("OPENAI_API_KEY"))
    parser.add_argument(
        "--base-url",
        default=os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
    )
    args = parser.parse_args()

    if not args.api_key:
        raise SystemExit("Error: set OPENAI_API_KEY or pass --api-key")

    all_defects = []
    for f in args.files:
        defects = inspect_file(f, args.api_key, args.base_url)
        all_defects.extend({"file": f, **d} for d in defects)

    if not all_defects:
        print("No defects flagged by LLM pre-inspection.")
        return

    print(f"LLM pre-inspection found {len(all_defects)} defect(s):\n")
    for d in all_defects:
        print(
            f"[{d['severity'].upper()}] {d['file']}:{d.get('line', '?')} "
            f"({d['category']}) {d['description']}"
        )


if __name__ == "__main__":
    main()

Installieren Sie das OpenAI-SDK mit pip install openai, setzen Sie Ihren API-Key und führen Sie python inspect.py src/auth.py aus. Das Skript gibt ein strukturiertes Fehlerprotokoll aus, das menschliche Inspektoren als Ausgangs-Checkliste verwenden können.

Das ist nicht die Inspektion. Das ist die Vorbereitung. Die Defekte brauchen immer noch menschliches Urteilsvermögen.

Was LLMs vermissen: Die Defekte, die echtes Geld kosten

Die teuersten Defekte sind keine Syntaxfehler. Es sind falsche Annahmen.

Ein LLM wird die fehlende null-Prüfung finden. Es wird nicht erkennen, dass der null-Fall nie eintreten sollte, weil der Upstream-Service das Feld garantiert, und der echte Bug ist, dass Ihr Team den Vertrag vor drei Wochen geändert und vergessen hat, den Downstream-Code zu aktualisieren.

Ein LLM wird eine unbehandelte Exception markieren. Es wird nicht bemerken, dass der Exception-Handler fehlt, weil der Autor annahm, dass die Datenbank-transaction automatisch zurückgerollt wird, und diese Annahme für das spezifische Isolationslevel, das Ihr Team verwendet, falsch ist.

Das sind Defekte auf Absichtsebene. Sie erfordern Domänenwissen, historischen Kontext und die Fähigkeit zu fragen: “Was hat der Autor angenommen, das nicht stimmt?” Ein LLM hat keinen Zugriff auf die undokumentierten Annahmen Ihres Teams. Es hat keine Erinnerung an die Architekturentscheidung aus dem letzten Quartal. Es kann ein Anforderungsdokument nicht betrachten und feststellen, dass der Code die falsche Anforderung implementiert.

Fagan-Inspektionen wurden genau dafür entwickelt, diese Defekte zu finden. Die menschlichen Inspektoren bringen unterschiedliche mentale Modelle und verschiedene Kontexte mit. Wenn sie uneinig sind, was der Code tun sollte, liegt in der Lücke zwischen ihren Annahmen der echte Bug.

Ein LLM hat ein mentales Modell, und es ist auf öffentlichem Code trainiert, nicht auf Ihrer Codebase.

Der echte Trade-Off: Abdeckung vs. Verständnis

LLM-Vorab-Inspektion gibt Ihnen Abdeckung. Es liest jede Zeile, prüft jede Funktion und lässt sich nie von einer Slack-Benachrichtigung ablenken. Es ist der perfekte enge Inspektor.

Menschliche Inspektion gibt Ihnen Verständnis. Sie verbindet den Code mit der Spezifikation, die Spezifikation mit dem Datenbankschema und das Schema mit der Geschäftsregel, die sich im letzten Sprint-Planning-Meeting geändert hat. Es ist der einzige Weg, Defekte zu finden, die außerhalb des Codes leben.

Der Trade-Off ist nicht Mensch gegen Maschine. Es ist tief gegen breit.

Wenn Sie Ihr Inspektionsteam durch ein LLM ersetzen, werden Sie mehr Syntax-Level-Defekte finden und mehr Absichts-Level-Defekte verpassen. Das Nettoergebnis hängt davon ab, welche Art von Bugs Sie umbringen. Wenn Ihre Produktionsvorfälle meist null-Dereferenzierungen und Ressourcenlecks sind, wird ein LLM helfen. Wenn Ihre Vorfälle meist falsche Business-Logic und verpasste Edge-Cases sind, wird ein LLM Ihnen falsche Sicherheit geben.

So führen Sie eine hybride Inspektion in der Praxis durch

Hier ist ein praktischer Workflow, der das LLM für das nutzt, worin es gut ist, und das menschliche Team für das bewahrt, was nur Menschen können.

Vor dem Meeting führen Sie das LLM-Vorab-Inspektionsskript auf dem Code aus. Geben Sie jedem menschlichen Inspektor die Ausgabe plus den Originalcode. Verlangen Sie, dass sie jeden LLM-Befund während ihrer individuellen Vorbereitung verifizieren oder zurückweisen. Das zwingt sie, Zeilen zu untersuchen, die sie sonst überflogen hätten.

Während des Meetings paraphrasiert der Vorleser weiterhin den Code laut. Die Inspektoren bringen weiterhin Probleme vor. Aber jetzt starten sie mit einer kuratierten Liste mechanischer Defekte, die bereits triagiert sind. Die Meeting-Zeit kann von zwei Stunden auf neunzig Minuten schrumpfen, oder das Team kann mehr Code im selben Zeitfenster reviewen.

Der Moderator bekommt eine neue Verantwortung: LLM-Genauigkeit tracken. Loggen Sie, wie viele LLM-markierte Defekte real waren, wie viele False Positives und wie viele menschlich-exklusive Defekte das LLM verpasst hat. Nach drei oder vier Inspektionen wissen Sie, ob Ihr Checklisten-Prompt Feintuning braucht.

Das ist derselbe Prozess, den die NASA in den 1990er Jahren verwendete, als sie mit werkzeugunterstützter Inspektion experimentierten. Automatisierte Checker fanden die einfachen Defekte und ließen die schweren den Menschen. Die Menschen schnitten besser ab, weil sie nicht mental erschöpft waren, die einfachen zu finden.

Das Fazit

Ein LLM kann ein vollständiges Inspektionsteam nicht ersetzen, weil Inspektion nicht nur Code-Lesen ist. Es ist ein strukturierter sozialer Prozess, der darauf ausgelegt ist, Lücken zwischen dem, was der Autor annahm, und dem, was der Code tatsächlich tut, aufzudecken.

Was ein LLM kann, ist das menschliche Team effektiver zu machen, indem es die mechanische Last entfernt. Es kann eine fünfte Rolle spielen: der unermüdliche Vorab-Inspektor, der das Schlachtfeld vorbereitet, bevor die Menschen ankommen.

Wenn Sie Inspektionen überspringen, weil sie zu teuer sind, macht ein LLM sie nicht kostenlos. Es macht sie kürzer. Das ist oft genug.

FAQ

Was ist eine Fagan-Inspektion?

Ein strukturierter, sechs-phasiger Review-Prozess, der 1976 von Michael Fagan bei IBM erfunden wurde. Er verwendet definierte Rollen (Moderator, Vorleser, Inspektoren, Autor), obligatorische individuelle Vorbereitung und zeitlich begrenzte Meetings, um Defekte vor dem Testen zu finden. Sie meldet konsistent 60 bis 90 Prozent Defekt-Entfernungsraten.

Kann ein LLM einen menschlichen Code-Reviewer ersetzen?

Nicht für die Defekte, die am meisten zählen. Ein LLM findet mechanische Probleme wie fehlende null-Prüfungen und Ressourcenlecks. Es verpasst Absichts-Level-Defekte wie falsche Annahmen über Upstream-Verträge, fehlende Business-Logic und Diskrepanzen zwischen Code und Anforderungen.

Wie integriert man ein LLM in eine Fagan-Inspektion?

Verwenden Sie das LLM während der Vorbereitungsphase. Führen Sie es gegen eine Checkliste aus, füttern Sie seine Ausgabe an menschliche Inspektoren vor dem Meeting und verlangen Sie, dass sie jeden Befund verifizieren. Das verkürzt das Meeting und verbessert die menschliche Konzentration, ohne menschliches Urteilsvermögen zu entfernen.

Was macht einen LLM-Checklisten-Prompt effektiv?

Spezifität. Generische Prompts produzieren generische Ausgabe. Effektive Prompts nennen exakte Defektkategorien, verlangen strukturierte JSON-Ausgabe, verbieten Lösungsvorschläge und fragen nach exakten Zeilennummern und Variablennamen. Die Checkliste sollte zu Ihrer Sprache und den häufigsten entkommenen Defekten Ihres Teams passen.

Probieren Sie es an einer Datei aus

Wählen Sie eine Datei, die im letzten Monat einen Produktionsvorfall verursacht hat. Schreiben Sie eine Checkliste mit fünf spezifischen Defekttypen, die Ihr Team interessieren. Führen Sie das obige Skript mit dieser Checkliste aus. Geben Sie die Ausgabe an zwei Ingenieure weiter, die die Datei nicht geschrieben haben.

Vergleichen Sie die LLM-Funde mit den menschlichen Funden. Zählen Sie die Überschneidungen. Zählen Sie, was jede Seite verpasst hat. Diese Lücke ist Ihre Antwort.