CommunityCodierung & Entwicklunggithub.com

Evidence-Review

Tiefgehende, evidenzbasierte Code-Überprüfung eines gesamten Projekts, eines Pfads, unbestätigter Änderungen, eines Branches oder eines GitHub PR/GitLab MR. Reproduziert Ergebnisse statt zu raten, bewertet Schichtauswahl und Wiederverwendung wie ein strenger Maintainer und erstellt einen strukturierten Bericht mit IDs, Schweregrad, Status und Verifikation.

Was ist Evidence-Review?

Die Fertigkeit "Evidence-Review" ermöglicht eine gründliche, evidenzbasierte Code-Überprüfung für verschiedene Geltungsbereiche, darunter das gesamte Repository, einen bestimmten Pfad, nicht bestätigte Änderungen (diff-Modus), einen Branch im Vergleich zu einem Basis-Branch oder einen Pull Request / Merge Request auf GitHub oder GitLab. Sie ahmt den Ansatz eines Senior-Engineers nach, der für die Auslieferung verantwortlich ist, indem sie den Code vollständig liest, Build- und Test-Tools ausführt, schwerwiegende Befunde mit Skripten reproduziert und einen strukturierten Bericht mit IDs, Schweregrad (Kritisch, Hoch, Mittel, Niedrig), Status und Verifikationsstufe (Ja, Teilweise, Artefakt, Nein, Nicht versucht) erstellt. Der Prozess umfasst sechs Schritte: Festlegen des Geltungsbereichs, Sammeln von Kontext (mit einer Runde Klärungsfragen), Budgetierung der Inspektion (Aufteilung bei mehr als 40 Dateien), Basislauf (Typcheck, Linting, Tests, Abhängigkeitsaudit) und Zuordnung der Vertrauensgrenzen. Die Fertigkeit unterstützt Plattformen wie Claude Code, Cursor (mit Sub-Agenten-Fähigkeit) und Codex, ist jedoch auf jeden agenten-basierten Code-Review-Ansatz anwendbar.

Funktioniert mit✓Claude Code✓Codex CLI✓Cursor
npx skills add https://github.com/avi-dev-user/evidence-review/tree/HEAD

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht Evidence-Review?

Sie führen die Überprüfung durch, die ein Senior-Engineer durchführt, wenn er für das ausgelieferte Produkt verantwortlich ist: Er liest den Geltungsbereich, führt die Tools aus, reproduziert das, was er vermutet, und sagt klar, was er nicht prüfen konnte. Zwei Standards definieren die Messlatte:

  • Das Projekt-Audit. Der Code im Geltungsbereich wird vollständig gelesen, Build und Tests werden ausgeführt, jeder schwerwiegende Befund wird mit einem Wegwerf-Skript reproduziert, es gibt eine klare Schweregradskala, Status, die sich mit der Behebung entwickeln, und einen ehrlichen Abschnitt "Was ist in gutem Zustand?".
  • Der strenge Maintainer. Zuerst wird gefragt, ob die Änderung in diese Schicht gehört, wird auf existierende Helfer oder Erweiterungspunkte mit Datei und Zeile verwiesen, werden alle Leser von gemeinsam genutztem Zustand verfolgt, bevor etwas als sicher bezeichnet wird, wird zwischen blockierend und nicht blockierend unterschieden, und Verträge werden festgelegt, bevor etwas von ihnen abhängt.

Tiefe kommt von Evidenz, nicht von Umfang. Ein kurzer Bericht, in dem jeder Befund echt ist, schlägt einen langen, der aufgebläht wirkt, um gründlich zu sein.

1. Geltungsbereich festlegen

Übergebene Argumente: "$ARGUMENTS" (leere Anführungszeichen bedeuten keine Argumente). Wenn dies immer noch wie ein Platzhalter aussieht, ersetzt Ihr Agent keine Argumente: Übernehmen Sie sie stattdessen aus der Anfrage des Benutzers.

ArgumentGeltungsbereichModusAusgabe
keinesDas gesamte Repository, Arbeitsverzeichnis wie es istProjektBerichtsdatei
ein PfadDieser Pfad vollständig, plus die Definitionen, die er eine Ebene tief aufruftProjektBerichtsdatei
diffGestagte + ungestagte Änderungen: git diff HEADÄnderungIm Chat
branch [basis]git diff <basis>...HEAD (drei Punkte: vom Merge-Base)ÄnderungIm Chat
`pr <nurl>`Den PR/MR-Head gegen seinen Ziel-BranchÄnderung
--update <datei>Erneute Prüfung eines vorhandenen Berichts; nur im Projekt-Modus, mit oder ohne PfadAktualisierungBearbeitet diese Datei
  • Basis-Branch für branch: git symbolic-ref --short refs/remotes/origin/HEAD; falls dies fehlschlägt, main, dann master; wenn keines existiert, ist es eine offene Frage (Abschnitt 2).
  • Unaufgeräumter Baum im Projekt-Modus: Überprüfen Sie das Arbeitsverzeichnis wie es ist und zeichnen Sie HEAD <sha> + unbestätigte Änderungen als Revision auf. Geänderte Dateien erhalten pfad:zeile, keine festen Links.
  • Keine Argumente und ein unaufgeräumter Baum: Das ist eine offene Frage (Projekt oder diff?).
  • Monorepo: Für einen Pfad führen Sie die Befehle des Pakets aus, dem er gehört (nächstgelegenes package.json / pyproject.toml / go.mod / Cargo.toml / *.csproj) und lesen Sie die Regeln-Dateien vom Stamm des Repos bis zu diesem Paket.

Der Änderungsmodus überprüft dennoch den umgebenden Code. Die Überprüfungseinheit umfasst die geänderten Blöcke plus die gesamten Funktionen, in denen sie sich befinden, jeden Aufrufer eines geänderten Symbols, jeden Leser und Schreiber jedes Zustands, den die Änderung betrifft, die Tests, die sie abdecken, und die Dokumentation, die sie beschreibt. Ein isoliert gelesener Diff ist der Weg, wie die teuren Fehler genehmigt werden.

Abrufen eines PR oder MR

Niemals über das Arbeitsverzeichnis des Benutzers auschecken. Verwenden Sie immer einen separaten Worktree an einem temporären Ort:

  • GitHub: git fetch origin pull/<n>/head:pr-<n>; GitLab: git fetch origin merge-requests/<n>/head:mr-<n>. Dann git worktree add <temp>/pr-<n> pr-<n>.
  • Metadaten: gh pr view <n> --json title,body,comments,reviews,baseRefName,headRefName oder glab mr view <n> --comments. Wenn keines der CLIs verfügbar oder angemeldet ist, überprüfen Sie nur den Diff und geben Sie im Header an, dass der Diskussionsverlauf nicht gelesen wurde.
  • Um die Basis für den Vergleich auszuführen (Abschnitt 4), fügen Sie einen zweiten Worktree am Merge-Base hinzu. Wechseln Sie niemals den Head-Worktree hin und her.
  • Entfernen Sie die Worktrees am Ende (git worktree remove).

2. Kontext und eine Runde Fragen

Sammeln Sie und halten Sie für den Berichtsheader fest:

  • Revision (vollständiger SHA), Branch, Remote-URL. Ohne Remote überspringen Sie den Rest dieses Aufzählungspunkts und verwenden Sie pfad:zeile. Andernfalls führen Sie zuerst git fetch --quiet aus, dann git branch -r --contains <sha>; wenn der Fetch fehlschlägt, behandeln Sie den SHA als nicht gepusht. Links werden nur an den SHA geheftet, wenn er gepusht wurde und der Host GitHub oder GitLab ist (Konvertieren Sie SSH-Remotes zu https):
    • GitHub https://github.com/<o>/<r>/blob/<sha>/<pfad>#L<a>-L<b>
    • GitLab https://<host>/<gruppe>/<repo>/-/blob/<sha>/<pfad>#L<a>-<b>
    • alles andere: pfad:zeile.
  • Projektregeln: CLAUDE.md, AGENTS.md, CONTRIBUTING.md, Lint/Typ-Konfigurationen, PR-Vorlagen und Regeln-Dateien in übergeordneten Verzeichnissen. Befunde werden zuerst anhand der eigenen Regeln des Projekts beurteilt, dann nach allgemeinem Geschmack.
  • Wofür das System da ist: README, Dokumentation, Bereitstellungs-Manifeste, CI-Konfiguration, Einstiegspunkte.
  • Für einen PR: seine Beschreibung, verknüpfte Issues, bestehende Review-Kommentare und deren Lösung sowie den Ziel-Branch. Lesen Sie frühere Review-Runden, um bereits gelöste Punkte nicht erneut aufzuwerfen, und prüfen Sie, ob angeforderte Änderungen tatsächlich vorgenommen wurden.
  • Absicht. Geben Sie in einem Satz an, welches Problem der Code oder die Änderung löst. Wenn Sie das nicht können, ist dies eine offene Frage, da die Antwort die Art und Weise der Implementierung ändern könnte.

Berichtssprache, erster Treffer gewinnt: die explizite Anfrage des Benutzers; die Regeln-Datei des Projekts; Regeln in einem übergeordneten Verzeichnis; das Publikum (ein Upstream-Open-Source-PR wird Englisch); die Sprache der vorhandenen Dokumentation des Projekts. Wenn nichts zutrifft, ist es eine offene Frage.

Offene Fragen. Sammeln Sie alle offenen Fragen aus den Abschnitten 1 und 2 (Geltungsbereich, Basis-Branch, Publikum, ein vom Anforderer gewünschter Fokus, Sprache, Absicht) und stellen Sie sie gemeinsam, in einer Nachricht. Fragen Sie nichts, was Sie selbst herausfinden können. Wenn niemand antworten kann (ein interaktionsfreier Durchlauf, oder der Benutzer hat gesagt, nicht zu fragen), verwenden Sie diese Standardwerte und listen Sie jeden unter "Annahmen" im Berichtsheader auf: Projekt-Modus für keine Argumente; Maintainer als Publikum; Englisch; kein benannter Fokus; Absicht wie in der PR-Beschreibung oder README angegeben.

Ein vom Anforderer benannter Fokus erhält einen eigenen Abschnitt am Anfang des Berichts, unabhängig von seinem Schweregrad.

3. Budget und Triage

Entscheiden Sie, was "im Geltungsbereich" ist, bevor Sie etwas Zeile für Zeile lesen.

  • Vom zeilenweisen Lesen ausschließen: Lockfiles, vendor/, node_modules/, dist//build/, generierter Code, minifizierte Dateien, Binärdateien, Snapshots, große Testdaten, API-Sammlungen. Durchsuchen oder überfliegen Sie sie nach relevanten Inhalten (eine anfällige Version, ein Geheimnis, eine Endpunktliste).
  • Zählen Sie, was übrig ist, zählen Sie nur Nicht-Test-Quelldateien. Über etwa 40 Dateien oder 8.000 Zeilen hinaus teilen Sie den Code in Bereiche auf und verteilen Sie schreibgeschützte Unteragenten, einen pro Bereich, um Kandidaten-Befunde mit Datei:Zeile und Begründung zu sammeln. Dies ist bei dieser Größe erforderlich, nicht optional: Ein Kontext kann nicht alles lesen, und ein stilles Überfliegen ist schlimmer als eine ehrliche Aufteilung. Jeder Kandidat wird im Hauptthread verifiziert (Abschnitt 7). Wenn Ihr Agent keine Unteragenten hat, überprüfen Sie einen Bereich pro Durchlauf, führen Sie eine schriftliche Kandidatenliste zwischen den Durchläufen und geben Sie im Geltungsbereich an, wie die Arbeit aufgeteilt wurde.
  • Tests: Lesen Sie vollständig die Tests, die die riskantesten Pfade abdecken, und jeden Test, von dessen Mocks ein Befund abhängt; überfliegen Sie den Rest nach Setup und Abdeckung und erwähnen Sie dies im Geltungsbereich.
  • Nach Risiko ordnen: Einstiegspunkte und Authentifizierung zuerst, dann alles, was in einen Datenspeicher schreibt, dann ausgehende Aufrufe, dann der Rest.
  • Abdeckung ehrlich dokumentieren. Der Geltungsbereich des Berichts sagt, was vollständig gelesen, was überflogen und was übersprungen wurde. Behaupten Sie niemals eine vollständige Lektüre, die Sie nicht durchgeführt haben.

4. Basislauf

Sicherheit vor dem Ausführen von irgendetwas

  • Code, den Sie nicht geschrieben haben (ein PR von einem Fork oder einem unbekannten Mitwirkenden, ein Repository, das Ihnen gerade übergeben wurde): Installation, Build und Tests führen diesen Code aus, einschließlich Installations-Hooks und Test-Setup. Listen Sie die Befehle, die Sie ausführen möchten, und was sie ausführen, und fragen Sie zuerst. Wenn niemand antworten kann, führen Sie nichts aus: Überprüfen Sie statisch und erwähnen Sie dies im Header.
  • Prüfen Sie, wohin die Tests zeigen. Lesen Sie das Test-Setup und die Umgebungsdateien. Wenn die Suite etwas außerhalb von localhost erreichen würde (eine gemeinsam genutzte Datenbank, eine Staging-API, eine echte Warteschlange), führen Sie sie nicht aus; dokumentieren Sie warum.
  • Halten Sie den Checkout sauber. Installieren Sie mit Lockfile-respektierenden Befehlen (npm ci, pip install -r mit Hashes, wo verfügbar, uv sync --frozen). Leiten Sie Build- und Coverage-Ausgaben außerhalb des Checkouts oder bestätigen Sie, dass sie gitignoriert sind (Test-Runner schreiben Coverage oft standardmäßig in das Repo: Übergeben Sie das Ausgabeverzeichnis, z. B. jest --coverageDirectory <temp>). Am Ende muss git status keine von Ihnen vorgenommene Änderung anzeigen.
  • Führen Sie niemals etwas gegen Produktions- oder gemeinsam genutzte Umgebungen aus. Produktionsprüfungen werden zu Empfehlungen mit dem genauen Befehl zum Ausführen (z. B. ein Query-Plan auf der Live-Datenbank).

Was ausgeführt werden soll

Finden Sie die tatsächlichen Befehle in package.json-Skripten / pyproject.toml / Makefile / CI-Konfiguration, führen Sie dann jeden aus und dokumentieren Sie das genaue Ergebnis: Typecheck, Linting, Build, Tests mit Abdeckung pro Datei und das Abhängigkeits-Audit des Ökosystems (npm audit, pip-audit, cargo audit, govulncheck, bundle audit, dotnet list package --vulnerable; osv-scanner als Fallback). Audits benötigen Netzwerk und eine Lockfile; wenn beides fehlt, dokumentieren Sie es. Die meisten Audit-Tools beenden mit einem Fehlercode, wenn sie Sicherheitshinweise finden: Das ist ein Ergebnis, kein fehlgeschlagener Befehl.

  • Ein Projekt ohne Tests, Build oder Linter: Dokumentieren Sie "keine konfiguriert" einmal. Es ist ein Befund, nicht einer pro Datei.
  • Veraltete Abhängigkeiten werden nur gemeldet, wenn sie eine bekannte Sicherheitslücke aufweisen, das Ende ihrer Lebensdauer überschritten haben oder ein benötigtes Upgrade blockieren.
  • Eine private Abhängigkeit, die Sie nicht installieren können: Dokumentieren Sie sie, überprüfen Sie sie anhand des verfügbaren Codes (eine installierte Kopie, eine kopierte Kopie) und sagen Sie, welches Bibliotheksverhalten ungeprüft blieb.

Im Änderungsmodus führen Sie die Suite auf dem Head aus und, wenn etwas fehlschlägt, auch auf der Basis (in ihrem eigenen Worktree), sodass jeder Fehler als neu oder vorhanden gekennzeichnet wird.

5. System zuordnen

Bevor Sie Zeile für Zeile lesen, notieren Sie sich:

  • Einstiegspunkte: HTTP-Routen, Protokollhandler (WebSocket, gRPC, Telefonie und dergleichen), CLI-Befehle, Warteschlangenverbraucher, Cronjobs, Migrationen, Startvorgang.
  • Vertrauensgrenzen: Wer jeden Einstiegspunkt erreichen kann, wie der Aufrufer authentifiziert wird und wo die Mandanten-/Benutzeridentität herkommt.
  • Datenspeicher, ihre Indizes und welche Pfade jede Sammlung oder Tabelle lesen und schreiben.
  • Ausgehende Aufrufe: Timeouts, TLS, Wiederholungen, was ein mehrdeutiger Fehler bedeutet.
  • Mehrstufige Operationen, deren Mitte fehlschlagen kann.
  • Die tatsächlichen Formate der Daten. Sammeln Sie Beispielwerte aus README, API-Dokumentation, Testdaten, Seed-Daten und API-Sammlungen: Pfadformate, Datumsformate, ID-Formate, Groß-/Kleinschreibung. Jeder Parser und Pfad-Helfer wird später gegen alle davon getestet.

Im Änderungsmodus ordnen Sie stattdessen den Einflussbereich zu: Durchsuchen Sie alle Aufrufer und Leser dessen, was die Änderung betrifft, mit Datei:Zeile.

6. Tiefenlesen

Lesen Sie jetzt reviewer-lens.md. Es ist eine Checkliste von Fragen, kein Quota: Die meisten Abschnitte haben zu den meisten Dateien nichts zu sagen, und ein Abschnitt, der nichts zu sagen hat, bekommt nichts. Berichten Sie nur Kandidaten mit einem konkreten Auslöseszenario.

Lesen Sie jede Datei im Geltungsbereich vollständig, nicht auszugsweise. Beziehen Sie die Teile von Bibliotheken ein, auf die sich der Code verlässt, wenn das Verhalten an der Nahtstelle wichtig ist (wie sich eine Client-Bibliothek nach einer Verbindungstrennung verhält, wie ein Framework einen Fehler behandelt, nachdem die Antwort gesendet wurde). Viele echte Fehler befinden sich dort.

Den Code nicht von der Prüfung ausnehmen. Die Teile, die gut durchdacht aussehen, erhalten die gleichen mechanischen Prüfungen wie der Rest: Query-Pläne für ihre heißen Abfragen, die tatsächlichen Datenformate durch ihre Parser, Leser ihres gemeinsamen Zustands. Vorsichtig aussehender Code verbirgt die Fehler, nach denen niemand gesucht hat.

Führen Sie eine laufende Liste von Kandidaten, jeder mit: Ort, was schiefgeht, das konkrete Szenario (Eingaben und Zustand, die es auslösen) und wie Sie es beweisen würden.

Führen Sie ebenfalls eine Liste der Dinge, die gut gemacht sind, mit den Beweisen. Behauptungen "Bestätigt funktionsfähig" benötigen die gleiche Strenge wie Befunde: Sie haben die Leser überprüft, den Test ausgeführt, den Bibliothekscode gelesen.

7. Verifizieren

Für jeden Kandidaten, der Hoch oder Kritisch sein könnte, und jeden Mittel, wo es günstig ist:

  • Reproduzieren Sie ihn mit einem Wegwerf-Skript in einem temporären Verzeichnis, niemals im Repo. Bevorzugen Sie echte Abhängigkeiten in kleinem Maßstab (eine In-Memory- oder containerisierte Datenbank, ein gestubbter Upstream an der HTTP-Grenze) gegenüber Mocks des zu überprüfenden Codes.
  • Für Leistungsbehauptungen: Messen Sie: Query-Pläne (explain(), EXPLAIN ANALYZE), Zeitmessungen vorher und nachher, bei einer Datengröße, bei der das Problem sichtbar wird.
  • Für Behauptungen "Das ist sicher" über gemeinsamen Zustand: Listen Sie jeden Leser und Schreiber auf.
  • Begrenzen Sie den Aufwand: etwa 15 Minuten oder 5 Versuche pro Kandidat. Danach kennzeichnen Sie ihn und fahren mit dem Grund fort. Stoppen Sie die Reproduktion, sobald jeder Kritische/Hoch-Kandidat eine Kennzeichnung hat.

Kennzeichnen Sie die Beweise jedes Befundes:

  • ja: durch laufenden Code reproduziert.
  • teilweise: Teil der Behauptung reproduziert; der Abschnitt gibt an, welcher Teil.
  • artefakt: durch eine Datei, ein Manifest, eine Image-Schicht oder einen Commit gezeigt, wo das Ausführen hier nicht möglich ist (eine fehlende Bereitstellungsvariable, ein Geheimnis im Verlauf).
  • nein: versucht und nicht reproduzierbar; sagen Sie, warum es dennoch gemeldet wird, oder lassen Sie es fallen.
  • nicht versucht: nur durch Überlegung.

Dann seien Sie ehrlich:

  • Ein Kandidat ohne plausible Auslösemöglichkeit in dieser Bereitstellung wird fallengelassen, nicht als Niedrig eingestuft.
  • Eine Schlussfolgerung bleibt als solche gekennzeichnet ("wahrscheinlich", "Ich konnte dies von hier aus nicht überprüfen").
  • Ein Test, der nur besteht, weil ein Mock etwas zurückgibt, das der echte Code nie zurückgibt, ist ein Befund über den Test, kein Beweis über den Code.

8. Klassifizieren

Schweregrad, beurteilt nach Auswirkung und Erreichbarkeit in dieser Bereitstellung. Wenn die Erreichbarkeit von etwas abhängt, das Sie nicht überprüfen können (Netzwerk-ACLs, wer einen Port erreichen kann), geben Sie den Schweregrad an, als ob er erreichbar wäre, und geben Sie daneben an, was ihn senken würde.

  • Kritisch: jetzt ausnutzbar, mit schwerwiegenden Auswirkungen.
  • Hoch: Datenverlust, mandanten- oder benutzerübergreifender Zugriff oder eine defekte Kernfunktion.
  • Mittel: ein echter Fehler oder ein Risiko, der/das bestimmte Bedingungen erfordert.
  • Niedrig: Hygiene, Wartbarkeit, Dokumentation, Abweichung von Abhängigkeiten.

Für eine Bibliothek beurteilen Sie nach der Auswirkung auf einen typischen Verbraucher. Für ein Einzelbenutzer-Tool ist Datenverlust immer noch Hoch, und ein Sicherheitsbefund benötigt einen realistischen Angreifer.

Im Änderungsmodus kennzeichnen Sie jeden Befund ebenfalls:

  • neu: Fehler, der mit dem Patch eingeführt wurde.
  • vorhanden: im Basiscode vorhanden; der Bericht erwähnt, ob er gemildert wird oder gleich bleibt.
  • aufgedeckt: eine vorhandene Schwachstelle, die der Patch aus einer Entfernung erreichbar macht, die vorher nicht erreichbar war.

9. Bericht schreiben

Verwenden Sie diese Abschnitte im Bericht. Die Reihenfolge ist festgelegt. Jeder Abschnitt, der leer wäre, wird weggelassen.

Bericht für das Projekt ""

Revision: <sha> auf <branch> über <url> [oder HEAD + unbestätigte Änderungen oder pfad:zeile]
Bereitstellung: Lokal | PR/MR <url> | Sonstige
Sprache:
Geltungsbereich: Gelesen: <n> Quell-Dateien, <n> Tests; Überflogen: <n>; Übersprungen: <n>
Coverage: <zusammenfassung der Art der Lektüre und der Tests>
Annahmen: Liste der Annahmen aus Abschnitt 2

<Fokus des Anforderers, falls vorhanden>

Nicht verifizierte Bereiche

Was nicht ausgeführt werden konnte, nicht statisch überprüft werden konnte oder ausgelassen wurde, weil die Abhängigkeit nicht installiert werden konnte. Jeder mit Ort und Begründung.

Zusammenfassung

StatusKritischHochMittelNiedrig
Offen<n><n><n><n>
Behoben<n><n><n><n>
Nachsicht gewährt<n><n><n><n>

Eine Zeile pro Kategorie. Offen + Behoben + Nachsicht gewährt = Gesamt. Keine Tabelle, wenn alles Nachsicht gewährt oder Behoben ist, stattdessen ein Satz: "Alle <n> Befunde wurden behoben." Wenn es keine Befunde gibt: "Keine Befunde."

Befunde

Jeder Befund erhält einen Abschnitt:

<id> <titel> — <status>

  • Schweregrad: Kritisch | Hoch | Mittel | Niedrig
  • Beweis: ja | teilweise | artefakt | nein | nicht versucht
  • Zugehörige Code-Referenzen:
  • Szenario: Die Eingaben und der Zustand, die den Fehler auslösen (wahrheitsgetreu, konkret, reproduzierbar durch jemand anderen mit einem Skript).
  • Was passiert: Das beobachtete oder abgeleitete Verhalten.
  • Erwartung: Das Verhalten, das als richtig angesehen wird.
  • Empfehlung: Die spezifische Änderung (Musteränderung, hinzuzufügende Prüfung, aufzurufender Helfer mit Datei und Zeile, neu zu schreibende oder zu entfernende Bedingung).
  • Wiederherstellen / mildern: Sofern zutreffend, der Befehl oder Skript zum Wiederherstellen oder um die Auswirkung in dieser Bereitstellung zu mildern. Keine Aktion = weglassen.
  • → Gelöst von: Wenn behoben, SHA und Kurztitel des Fixes, plus git show --stat <sha> oder eine Zusammenfassung der Änderung.

Sortiert nach Schweregrad absteigend, dann id.

Was ist in gutem Zustand

Listen Sie Dinge auf, die Sie überprüft haben und die gut funktionieren, mit den Beweisen: "Die Migration <name> wurde getestet, sie ist idempotent unter <bedingung>." "Die Authentifizierungsschicht <helper> wurde gelesen; sie lehnt <bedingung> ab und gibt <format> zurück." Ein Punkt pro Sache. Keine vagen Aussagen.

Bereits gemeldet / Nachsicht gewährt

Listen Sie Befunde auf, die anderswo gemeldet wurden (mit einem Link) und solche, mit denen das Projekt nach vorheriger Diskussion leben wird (eine vertretbare Designentscheidung, eine bekannte Einschränkung). Jeder mit Ort und Begründung. Dieser Abschnitt vermeidet, dass der Bericht als "neu und unbekannt" erscheint, wenn die Maintainer bereits informiert wurden.

10. Linter-Reflexion

Nachdem der Bericht geschrieben wurde: Prüfen Sie, ob Sie wirklich jeden Befund reproduziert haben, den Sie als "ja" (reproduziert) oder "teilweise" gekennzeichnet haben. Wenn nicht passiert ist, korrigieren Sie das Etikett. Prüfen Sie dann, ob Sie das Gefühl haben, dass der Bericht dünn ist und Sie sich dabei ertappen, einen Befund hinzuzufügen, nur um die Seitenzahl zu erhöhen oder eine Kategorie zu füllen. Verwerfen Sie diesen Befund. Der Bericht ist dann fertig.

Verwandte Skills