Der Bau ist nicht abgeschlossen, wenn der Code läuft. Er ist abgeschlossen, wenn der Code korrekt ist.
KI bewegt sich schnell. Schnell bedeutet, dass Dinge gebaut werden, die an der Oberfläche funktionieren, aber von der Architektur abweichen, das Designsystem verletzen oder Randfälle übersehen, die wichtig sind. Diese Fähigkeit erfasst diese Dinge, bevor sie sich zu größeren Problemen aufschaukeln.
Führe sie nach jeder Funktion aus. Bevor du weitermachst.
Was diese Fähigkeit nicht tut
Sie repariert nichts. Sie berichtet, was sie findet, und überlässt dem Entwickler die Entscheidung, was wichtig ist und was getan werden muss. Reparieren ohne Verständnis ist, wie Probleme begraben werden, nicht gelöst.
Schritt 1 – Verstehen, was hätte gebaut werden sollen
Bevor du etwas überprüfst, lege den Maßstab fest.
Lies in dieser Reihenfolge:
- Den Implementierungsplan von
/architect, falls vorhanden - Die Funktionsbeschreibung oder Aufgabe, die gegeben wurde
- Alle relevanten Kontextdateien – Architekturgrenzen, Codestandards, Designregeln
Wenn kein Plan existiert, bitte den Entwickler, zu beschreiben, was die Funktion tun sollte, bevor du mit der Überprüfung beginnst. Du kannst Korrektheit nicht überprüfen, ohne zu wissen, wie korrekt aussieht.
Schritt 2 – In drei Schichten überprüfen
Schicht 1 – Entspricht es dem Plan?
Vergleiche, was gebaut wurde, mit dem, was geplant war.
Prüfe:
- Jeden Teil der Funktionsbeschreibung – ist alles vorhanden?
- Die Entscheidungen, die während der Planung getroffen wurden – spiegeln sie sich im Code wider?
- Den Umfang – blieb die Implementierung innerhalb der Grenzen oder fügte sie Dinge hinzu, die nicht angefragt wurden?
Markiere alles, was geplant, aber fehlend ist. Markiere alles, was gebaut, aber nicht geplant wurde.
Schicht 2 – Respektiert es das System?
Hier tritt die häufigste KI-Abweichung auf. Die Funktion funktioniert, verletzt aber Regeln, von denen das Projekt abhängt.
Prüfe:
- Architekturgrenzen – hat der Code am richtigen Ort die richtigen Verantwortlichkeiten? Keine UI-Logik in API-Routen. Keine DB-Aufrufe in Komponenten. Was auch immer die Grenzen des Projekts sind – werden sie respektiert?
- Designsystem – werden die richtigen Tokens, Klassen und Muster verwendet? Irgendwelche festcodierten Werte, die Variablen sein sollten? Irgendwelche rohen Farbklassen, die das Designsystem verwenden sollten?
- Codestandards – Namenskonventionen, Dateiorganisation, TypeScript-Strenge, Fehlerbehandlungsmuster – entsprechen sie dem, was das Projekt festgelegt hat?
- Vorhandene Muster – führt diese Funktion ein neues Muster ein, wenn ein vorhandenes hätte verwendet werden sollen?
Schicht 3 – Ist es produktionsreif?
Prüfe:
- Fehlerbehandlung – was passiert, wenn etwas schiefgeht? Werden Fehler abgefangen und behandelt oder schlägt die Funktion still fehl?
- Randfälle – leere Zustände, Ladezustände, fehlende Daten – werden diese behandelt?
- Konsolenfehler – irgendwelche Fehler oder Warnungen im Browser oder Terminal?
- Offensichtliche Fehler – alles, was für einen echten Benutzer eindeutig kaputtgehen würde?
Schritt 3 – Berichte, was du gefunden hast
Nach Abschluss aller drei Schichten erstelle einen klaren Bericht. Vergrabe keine Probleme. Beschönige sie nicht. Berichte ehrlich, damit der Entwickler fundierte Entscheidungen treffen kann.
## Review – [Funktionsname]
### Schicht 1 – Planabgleich
[BESTANDEN / PROBLEME GEFUNDEN]
[Liste aller Lücken zwischen dem, was geplant, und dem, was gebaut wurde]
### Schicht 2 – Systemintegrität
[BESTANDEN / PROBLEME GEFUNDEN]
[Liste aller Verstöße gegen Architektur, Design oder Codestandards]
### Schicht 3 – Produktionsreife
[BESTANDEN / PROBLEME GEFUNDEN]
[Liste aller Lücken in der Fehlerbehandlung, Randfälle oder offensichtliche Fehler]
### Zusammenfassung
[X] Probleme in [Y] Schichten gefunden.
[Wenn keine Probleme: "Keine Probleme gefunden. Diese Funktion ist bereit zur Auslieferung."]
[Wenn Probleme: "Behebe die oben genannten Punkte, bevor du mit der nächsten Funktion fortfährst."]
Schritt 4 – Lass den Entwickler entscheiden
Nach der Vorlage des Berichts halt an. Beginne nicht mit dem Reparieren. Schlage keine Korrekturen vor, es sei denn, der Entwickler fragt danach.
Warte, bis der Entwickler:
- Dich bittet, ein bestimmtes Problem zu beheben
- Dir mitteilt, dass ein Problem beabsichtigt ist und ignoriert werden kann
- Bestätigt, dass alles gelöst ist und du fortfahren kannst
Der Entwickler trifft die Qualitätsentscheidung. Du informierst sie.
Schweregrad-Leitfaden
Nicht alle Probleme sind gleich. Verwende dies, um dem Entwickler bei der Priorisierung zu helfen:
Kritisch – vor dem Weitermachen beheben
- Verletzungen der Architekturgrenzen, die zukünftige Funktionen brechen werden
- Fehlende Fehlerbehandlung, die zu stillen Fehlschlägen führt
- Geplante Funktionalität, die vollständig fehlt
Wichtig – bald beheben
- Abweichungen vom Designsystem, die zu UI-Inkonsistenzen führen
- Verstöße gegen Codestandards, die sich in der gesamten Codebasis verstärken werden
- Randfälle, denen ein echter Benutzer begegnen wird
Gering – bequem beheben
- Benennungsinkonsistenzen, die das Verhalten nicht beeinträchtigen
- Fehlende Optimierungen
- Stilprobleme, die das Designsystem nicht beeinträchtigen
Kennzeichne jedes Problem mit seinem Schweregrad, damit der Entwickler schnell triagieren kann.
Der Standard
Die Frage, die diese Fähigkeit beantwortet, ist nicht „funktioniert es?"
Die Frage ist „ist es korrekt?"
Funktionieren und korrekt sind nicht dasselbe. Eine Funktion kann heute funktionieren und das Projekt morgen zum Scheitern bringen. Review existiert, um den Unterschied zu erkennen.