
Code debuggen: Eine Anleitung in 7 wiederholbaren Schritten
Lerne, wie du Code in 7 praktischen Schritten debuggst – mit Logs, Breakpoints, Regressionstests und einem Enter Pro Beispiel mit doppeltem Rabatt-Bug im Warenkorb.
Ein Warenkorb kann fehlerfrei kompilieren und trotzdem 5 Dollar zu viel abziehen. In dieser kontrollierten Übung wurde der Fehler bewusst eingebaut: Ein Rabattcode wird einmal angewendet, und eine Mengenänderung zieht ihn dann ein zweites Mal ab. Die entscheidende Frage ist, wie du beweist, wo genau dieser zusätzliche Abzug entsteht.
Die konkreten Zahlen machen die Untersuchung greifbar. Ein Warenkorb mit 54 Dollar wird mit einem Rabattcode zu** 49 Dollar**. Fügst du einen weiteren Artikel für** 24 Dollar** hinzu, müsste die korrekte Summe nach Rabatt** 73 Dollar** betragen. Die fehlerhafte Berechnung liefert jedoch** 68 Dollar**. Diese Diskrepanz kannst du nutzen, um den Zustandswechsel nachzuvollziehen – statt zu raten, welche Zeile verdächtig aussieht.
Wenn ich erkläre, wie man Code debuggt, beginne ich mit einer Regel: Bewahre den Fehlerzustand, bevor du das Programm änderst. Definiere das erwartete Ergebnis, grenze den Suchraum ein und teste eine Ursache. Ein Fix überzeugt erst, wenn er die Diskrepanz erklärt und dieselbe Abfolge besteht, die den Fehler überhaupt aufgedeckt hat.
Den Bug verstehen, bevor du ihn debuggst
Symptom und Grundursache trennen
Das Symptom ist das, was du beobachten kannst: eine falsche Summe, ein Absturz, eine leere Seite oder eine Anfrage, die nie fertig wird. Die Grundursache ist die verletzte Annahme, die dieses Symptom erzeugt. Im Warenkorb-Beispiel wächst der Abzug mit jeder Mengenänderung, obwohl der feste Rabattbetrag konstant bei 5 Dollar bleiben sollte.
Ich würde nicht bei der Währungsformatierung anfangen – sie zeigt nur das Ergebnis an, das sie erhält. Verfolge den Wert rückwärts durch die Zusammenfassungskomponente, die Summenberechnung, die Mengenänderung und den Rabattzustand, bis du die erste Abweichung von der erwarteten Berechnung findest.
Das ist eine nützliche Gewohnheit beim Debuggen von Code, den du nicht selbst geschrieben hast. Ein Stack Trace oder ein verdächtig wirkender Komponentenname liefert einen Ausgangspunkt, kein Urteil. Der eigentliche Ursprung kann früher im Datenfluss liegen oder außerhalb des Prozesses, der den Fehler anzeigt.
Den Fehler klassifizieren

Ein Syntaxfehler verhindert die Ausführung von Code, wenn seine Struktur die Regeln der Programmiersprache verletzt.
Ein Syntaxfehler verhindert das Parsen; eine** Laufzeitausnahme** unterbricht die Ausführung; ein** Logikfehler** erzeugt ein falsches Ergebnis. Integrationsfehler treten an den Grenzen zwischen Systemen auf. Umgebungsfehler hängen von Konfiguration, Berechtigungen oder Abhängigkeiten ab; Nebenläufigkeitsfehler hängen von Timing und geteiltem Zustand ab.
Unser Rabatt-Bug ist in erster Linie ein Zustands- und Logikproblem. Build-Tools können alle Dateien akzeptieren, während die geschäftliche Berechnung trotzdem falsch bleibt. Du solltest Beweise wählen, die zur Fehlerklasse passen, statt zu erwarten, dass ein erfolgreicher Befehl bereits Korrektheit belegt.
Beweise sichern und Auswirkungen bewerten
Erfasse das erwartete Ergebnis, das tatsächliche Ergebnis, die exakten Eingaben, die Handlungsfolge und die fehlerhafte Version. Ergänze Umgebungsdetails, Zeitstempel, Anfrage-IDs, Logs und jüngste Änderungen, wenn sie relevant sind. Du willst, dass eine andere Person denselben Fehler erreicht, ohne deine Sitzung aus dem Gedächtnis rekonstruieren zu müssen.
Ich unterscheide zwischen Untersuchung und Eindämmung. Wenn ein Produktionsfehler einen falschen Betrag abbucht, stoppe oder beschränke zuerst den betroffenen Pfad durch eine autorisierte Gegenmaßnahme. Eine wegwerfbare Warenkorb-Übung erlaubt freies Experimentieren; ein echter Zahlungsvorfall braucht kontrollierte Änderungen und einen klaren Verantwortlichen.
Code debuggen in 7 wiederholbaren Schritten
Die Schritte bilden eine Abfolge, aber du kannst zwischen Inspektion und Hypothesentest hin- und herspringen. Jede Schleife sollte die Unsicherheit verringern. Wenn du wiederholt unzusammenhängende Dateien bearbeitest, halte an und frage dich, welche Beobachtung die verbleibenden Erklärungen am stärksten voneinander trennen würde.

Eine wiederholbare Untersuchung bewahrt die Reproduktion und reduziert gleichzeitig die Anzahl plausibler Ursachen.
Schritt 1 — Den Fehler definieren und reproduzieren
Ersetze "der Rabattcode ist defekt" durch eine konkrete Abfolge: Warenkorb laden, den 5-Dollar-Rabattcode anwenden, die Menge des 24-Dollar-Artikels von eins auf zwei erhöhen und dann die Summe mit 78 − 5 = 73 Dollar vergleichen. Gib die Ausgangsmengen an, damit das erwartete Ergebnis eindeutig ist.
| Aktion | Zwischensumme | Erwartete Summe | Beweis aus der fehlerhaften Version |
|---|---|---|---|
| Anfangswarenkorb, kein Rabatt | 54 $ | 54 $ | 54 $ in Plan/Bericht |
| 5-Dollar-Rabatt anwenden | 54 $ | 49 $ | 49 $ in Vorschau |
| Kesselmenge auf 2 erhöhen | 78 $ | 73 $ | 68 $ in Vorschau; 10 $ Abzug |
Die Beträge 49 $ und 68 $ sind in aufeinanderfolgenden Screenshots der fehlerhaften Vorschau sichtbar. Der Ausgangswert 54 $ steht im Plan und im Build-Bericht; eine spätere, reparierte und zurückgesetzte Vorschau zeigt ebenfalls 54 $. Screenshots halten diese Zustände fest, während eine Aufnahme oder ein Interaktionstest die vollständige Klickfolge verifizieren würde.
Bei einem sporadischen Fehler erfasse Häufigkeit und Bedingungen, statt eine deterministische Abfolge zu erfinden. "Drei Fehlschläge bei zwanzig Versuchen nach erneutem Verbinden" ist ein nützlicher Beleg, wenn diese Versuche protokolliert wurden. "Manchmal defekt" liefert dir kaum etwas zum Vergleichen.

Die erwarteten Werte folgen den Preisen der Demo. Das fehlerhafte Ergebnis zieht denselben 5-Dollar-Rabatt ein zweites Mal ab.
Schritt 2 — Auf den kleinsten fehlschlagenden Fall reduzieren
Entferne alles, was die Diskrepanz nicht beeinflusst. Unsere Rechnung braucht nur Artikelpreise und -mengen, den Rabattzustand und die Summenberechnung. Produktbilder, Suche, Versand und Zahlungsintegration erklären in dieser kontrollierten Übung keinen zusätzlichen festen Abzug.
Ich bewahre den wichtigen Übergang unverändert, während ich den umgebenden Code reduziere. Ein minimales Beispiel, das die Mengenänderung entfernt, entfernt möglicherweise auch den Bug gleich mit. Du brauchst eine kleinere Reproduktion desselben Fehlers, kein anderes Programm, das zufällig funktioniert.
Dokumentiere, was du entfernt hast, und bestätige, dass das Symptom weiterhin auftritt. Diese Bestätigung schützt dich davor, Schlüsse aus einem Test zu ziehen, der den ursprünglichen Pfad nicht mehr durchläuft. Bei einem datenabhängigen Bug reduziere die Eingabemenge, ohne den Wert zu ändern, der ihn auslöst.
Schritt 3 — Fehler, Logs, Stack-Frames und Zustand prüfen
Lies zuerst den frühesten relevanten Fehler, bevor du die nachfolgende Kaskade betrachtest. Prüfe die tatsächlichen Werte an der Grenze: Artikelmengen, Zwischensumme, Rabattbetrag und angezeigte Summe vor und nach der Änderung. Die wichtige Frage ist, ob der Rabatt zweimal angewendet wird – nicht, ob die Oberfläche eine bestimmte Beschriftung zeigt.
Debugging-Tools in VS Code zeigen Variablen, Watch-Ausdrücke, Stack-Frames und Ausführungssteuerung. Setze einen Breakpoint an der Stelle, wo die Summe zugewiesen wird, und prüfe dann die Aufrufer und aktuellen Werte. Ich beobachte denselben Wert über mehrere aufeinanderfolgende Schreibvorgänge, statt beim ersten plausibel aussehenden Wert aufzuhören.

Eine echte Debugger-Oberfläche aus der VS-Code-Dokumentation. Das Panel zeigt mehrere Arten von Beweisen gleichzeitig.
Ein Logikfehler löst womöglich überhaupt keine Ausnahme aus. Du kannst vorübergehend die Eingaben und das berechnete Ergebnis protokollieren oder direkt vor der falschen Zuweisung pausieren. Halte den Beobachtungsbereich eng genug, um ihn zu interpretieren; eine Konsole voller kompletter Objekte begräbt oft genau den Übergang, den du sehen musst.
Schritt 4 — Den Suchraum einschränken
Teile den verdächtigen Pfad in sinnvolle Grenzen auf. Ist der Artikelzustand falsch, ist die Zwischensumme falsch, oder wird die angezeigte Summe erst danach falsch? Wenn die Zwischensumme 78 Dollar beträgt, aber** 68 Dollar** angezeigt werden, kannst du die Multiplikation beiseitelassen und die Rabattanwendung untersuchen.
Bei einer Regression sucht git bisect zwischen einer bekannt guten und einer bekannt schlechten Revision. In einer idealen Binärsuche schrumpfen 1.024 Kandidaten in 10 Halbierungsrunden auf einen einzigen. Echte Untersuchungen brauchen zudem verlässliche Endpunkte, reproduzierbare Builds und eine zuverlässige Gut-oder-schlecht-Prüfung.

Bisect findet die Änderung, die mit einer Regression zusammenhängt; es erklärt die zugrunde liegende Ursache nicht von selbst.

Die Grafik zeigt eine ideale Suche. Defekte Builds, übersprungene Revisionen oder mehrere unabhängige Fehler können einen echten Durchlauf komplizieren.
Ich würde einen Bisect in einem sauberen Worktree oder einem wegwerfbaren Branch ausführen und zuvor nicht committete Arbeit sichern. Markiere eine Revision nur dann als schlecht, wenn dieselbe Reproduktion fehlschlägt. Ein unabhängiges Problem bei der Installation einer Abhängigkeit ist kein Beweis dafür, dass die Rabattberechnung fehlerhaft ist.
Schritt 5 — Eine Hypothese nach der anderen testen
Mache die Hypothese widerlegbar: "Die Mengenänderung fügt dem gespeicherten Rabattabzug weitere 5 Dollar hinzu." Wenn das stimmt, sollte der Abzug nach der ersten Mengenänderung von 5 auf 10 Dollar steigen, während der Rabattcode aktiv bleibt. Das Entfernen dieser Akkumulation sollte genau einen festen Rabatt wiederherstellen.
Kombiniere keine Berechnungsänderung mit einer Komponentenüberarbeitung, einem Abhängigkeits-Update und einer neuen Rabattregel. Ich möchte, dass das Ergebnis eines einzelnen Experiments eine einzelne Erklärung unterscheidet. Ein bestandenes Ergebnis nach vier unzusammenhängenden Änderungen lässt die Ursache unklar.
Scheitert die Hypothese, notiere warum, und wähle die nächste anhand der Beweise. Die gleiche unbelegte Erklärung mit leicht anderen Formulierungen zu wiederholen, ist kein neues Experiment. Du solltest nach jedem Versuch sagen können, was sich an deinem Verständnis geändert hat.
Schritt 6 — Die Grundursache beheben
Das Zustandsmodell weist auf eine gezielte Reparatur hin: Leite den festen Abzug aus dem Rabattzustand ab, statt ihn bei Mengenänderungen zu akkumulieren. Das folgt den React-Empfehlungen zum Vermeiden redundanten Zustands. Wenn ein Wert aus aktuellen Eingaben berechnet werden kann, kann eine separat gespeicherte Kopie davon abweichen.

Das Beispiel in der Dokumentation verwendet Namen; dasselbe Prinzip gilt für eine Warenkorbsumme, die aus Artikeln und Rabattzustand abgeleitet wird.
Ein vereinfachtes Reparaturmuster leitet den Rabatt aus dem aktuellen Rabattzustand ab:
const subtotal = getSubtotal(state.quantities);
const couponDeduction = state.couponApplied ? COUPON_VALUE : 0;
const total = subtotal - couponDeduction;
Ich bevorzuge diese Reparatur, weil eine Mengenänderung keine Rabattgeschichte mehr akkumuliert. Du brauchst trotzdem klare Geschäftsregeln: ob der Rabatt fest oder proportional ist, ob er die Zwischensumme überschreiten darf, und wie die Währung dargestellt wird. Eine Produktionsberechnung nutzt normalerweise ganzzahlige Untereinheiten oder eine andere bewusst gewählte Geldrepräsentation.
Eine Mengenänderung sollte den Artikelzustand und die Zwischensumme ändern, während der feste Rabatt bei 5 Dollar bleibt. Prüfe den tatsächlichen Projekt-Diff, um zu bestätigen, dass der akkumulierende Abzug entfernt wurde.
Schritt 7 — Den Fix verifizieren, dokumentieren und überwachen
Wiederhole die ursprüngliche Abfolge und teste dann angrenzende Fälle: Menge verringern, Rabatt entfernen, erneut anwenden und einen Artikel entfernen. Bewahre den Fehler als Regressionstest. Eine Prüfung, die den Warenkorb nur mountet, schützt den Mengenänderungs-Übergang nicht.
| Regressionsfall | Erwartete Bedingung |
|---|---|
| Rabatt auf den Anfangswarenkorb angewendet | Summe 49 $ |
| Menge mit aktivem Rabatt erhöht | Summe 73 $ |
| Menge auf Ausgangswert zurückgesetzt | Summe 49 $ |
| Einen bereits aktiven Rabatt erneut anwenden | Ein Rabatt, nicht zwei |
| Rabatt entfernen | Summe entspricht der aktuellen Zwischensumme |
Du solltest auch die umliegenden Regeln überprüfen, die der Patch berührt. Wenn Summen an einen Server oder Zahlungsanbieter gesendet werden, verifiziere die Übereinstimmung an dieser Grenze. Ich würde Ursache, geänderte Dateien, Testergebnisse und Release- oder Rollback-Status festhalten, bevor ich ein Produktionsproblem schließe.
Die Debugging-Methode an den Bug-Typ anpassen
Zu wissen, wie man Code debuggt, bedeutet auch zu wissen, welches Werkzeug den fehlenden Beweis liefert. Ein Breakpoint ist ausgezeichnet für lokalen Zustand; er ist weniger nützlich für einen Fehler, der gestern über drei Services hinweg auftrat. Wähle die Methode anhand der Grenze, die du untersuchen musst.
| Bug-Typ | Erste Frage | Nützlicher Beweis |
|---|---|---|
| Ausnahme | Welche Eingabe erreichte den ersten relevanten fehlschlagenden Frame? | Stack Trace und pausierte Variablen |
| Falsche Ausgabe | Wo weicht der Wert zuerst ab? | Zwischenwerte und Assertions |
| Regression | Was hat sich seit der letzten bekannt guten Version geändert? | Versions-Diff und Bisect |
| Langsamer Vorgang | Welche Phase verbraucht die Zeit? | Profiling, Zeitmessungen und Traces |
| Sporadischer Fehler | Welche Zustands- oder Timing-Bedingungen fallen zusammen? | Korrelierte Ereignisse und IDs |
| Nur umgebungsabhängiger Fehler | Was unterscheidet sich zwischen den Umgebungen? | Konfiguration, Versionen, Berechtigungen und Daten |
| UI-Fehler | Ist das Ereignis, die Antwort, der Zustand oder das Rendering fehlgeschlagen? | Browser-Tools und Komponententests |
Breakpoints und Stepping für den Live-Zustand nutzen
Ein Zeilen-Breakpoint pausiert an einer Stelle; ein bedingter Breakpoint pausiert nur, wenn seine Bedingung wahr ist. Die Breakpoint-Dokumentation von Chrome behandelt außerdem Event-, DOM-, Request- und Exception-Breakpoints. Du kannst den Trigger wählen, der dem Symptom am nächsten liegt.

Die offizielle Übersicht ordnet verschiedene Symptome unterschiedlichen Pausebedingungen zu.
Nutze "Step Over", um das Ergebnis eines Aufrufs zu prüfen, "Step Into", wenn du seine Implementierung brauchst, und "Step Out", nachdem du die aktuelle Funktion geprüft hast. Ich nutze Watch-Ausdrücke für eine kleine Menge relevanter Werte. Alles zu beobachten kann fast so ablenkend sein wie alles zu loggen.
Die JavaScript-debugger-Anweisung kann eine Pause anfordern, wenn Debugging-Werkzeuge verfügbar sind. Entferne temporäre Debugging-Anweisungen vor dem Release. Wenn der bereitgestellte Code gebündelt oder transpiliert ist, prüfe die Source-Map-Konfiguration, damit der angezeigte Quellcode dem tatsächlich laufenden Code entspricht.

Eine debugger-Anweisung ist ein Inspektionshilfsmittel. Sie hat keine nützliche Pausewirkung, wenn kein Debugging-Werkzeug verfügbar ist.
Logs, Tracing und Profiling für verteilte Beweise nutzen
Strukturierte Logs erfassen Ereignisse mit konsistenten Feldern; Tracing verfolgt Arbeit über Grenzen hinweg; Profiling untersucht, wo Zeit oder Ressourcen verbraucht werden. Eine Anfrage-ID erlaubt dir, zusammenhängende Ereignisse zu verknüpfen, ohne von benachbarten Zeitstempeln zu raten. Protokolliere keine Zugangsdaten, Zahlungsgeheimnisse oder unnötige personenbezogene Daten.
Für den Warenkorb könnten nützliche Diagnosefelder Menge, Zwischensumme, Rabattzustand, Berechnungsgrund und resultierende Summe sein. Für einen entfernten Bestellablauf brauchst du zudem den vom Server akzeptierten Betrag und das Ergebnis. Ich vermeide die Behauptung, ein Frontend-Wert belege, was ein separater Dienst tatsächlich verarbeitet hat.

Logpoints können einen Wert protokollieren, ohne den Quellcode zu ändern oder die Anwendung zu pausieren.
Tests, Assertions und Binärsuche zur Isolierung der Ursache nutzen
Eine Assertion macht aus einer Annahme eine Prüfung. Ein Unit-Test kann eine reine Summenfunktion verifizieren; ein Interaktionstest kann die Rabattanwendung gefolgt von einer Mengenänderung durchspielen. Du brauchst beides, wenn Berechnung und Ereignisabfolge unabhängig voneinander scheitern können.
Ich wähle den kleinsten Test, der den Fehler bewahrt, und füge dann eine breitere Prüfung dort hinzu, wo der Fehler eine Grenze überschreitet. Das hält den Test aussagekräftig. Ein großer End-to-End-Fehlschlag sagt dir vielleicht, dass die Reihenfolge falsch ist, lässt aber unklar, welche Schicht fehlerhaft ist.
KI-generierten Code debuggen, ohne dem Fix blind zu vertrauen
Die generierte Änderung vor der Ausführung prüfen
KI für Code-Debugging kann helfen, Hypothesen zu ordnen und unbekannten Code zu untersuchen, aber plausible Erklärungen sind kein Ausführungsbeweis. Prüfe betroffene Dateien, Befehle, Abhängigkeiten, externe Aufrufe und Datenänderungen. Du solltest den Umfang des Patches verstehen, bevor du ihn akzeptierst.
Ich trenne Type-Checking, Build, Testausführung und beobachtetes Verhalten. Sie beantworten unterschiedliche Fragen. Ein Reducer-Test kann bestehen, während ein Button-Handler weiterhin defekt ist, also halte den Testumfang explizit, wenn du KI-generierten Code in deinen eigenen Projekten debuggst.
Dem Modell Beweise statt einer Bitte um Neuschreiben geben
Gib den kleinsten relevanten Code, die exakte Diskrepanz, die Reproduktion, die Umgebung und die Invariante an. Für diesen Warenkorb lautet die Invariante: "Der feste 5-Dollar-Rabatt wird unabhängig von Mengenänderungen genau einmal angewendet." Bitte um eine priorisierte Erklärung und die kleinste Änderung, mit der man sie testen kann.
Eine fokussierte Anfrage könnte so aussehen: "Verfolge, wie sich couponDeduction nach SET_QUANTITY ändert. Erkläre, warum aus der Zwischensumme von 78 Dollar 68 Dollar werden. Schlage einen minimalen Patch vor, der den festen Rabatt bei 5 Dollar hält, und füge einen Test für das Anwenden des Rabatts vor einer Mengenänderung hinzu." Damit gibst du dem Modell etwas, worüber es nachdenken kann, und dir etwas, das du überprüfen kannst.
Den Diff prüfen und unabhängig verifizieren
Lies den vorgeschlagenen Unterschied, bevor du eine beruhigende Zusammenfassung akzeptierst. Hat die Reparatur den akkumulierenden Abzug in der Mengenänderung entfernt, oder nur dessen Auswirkung in der Anzeige verborgen? Wurde der Rabattbetrag geändert, ein Paket eingeführt oder eine unzusammenhängende Komponente verändert?
Ich möchte Tests, die gegen den Fehler scheitern und gegen die Reparatur bestehen, mit erhaltenen Befehlen und Ausgaben. Du solltest auch die ursprüngliche Reproduktion erneut ausführen. Ein generierter Test kann eine falsche Erwartung ebenso selbstsicher behaupten, wie generierter Anwendungscode eine falsche Summe berechnen kann.
Eine Enter Pro App von der Vorschau bis zum Code debuggen
Die Rabatt-Debugging-Demo zeigt, wie man Code debuggt, anhand eines kontrollierten Enter Pro Projekts. Sechs Screenshots folgen dem Prompt, dem Plan, der fehlerhaften Vorschau, der Reparaturanfrage und der reparierten Vorschau. Der Fehler wurde für diese Übung absichtlich eingebaut.
Eine Regel vor dem Bauen festlegen
Der Prompt legt die Preise auf 24, 18 und 12 Dollar fest, startet jede Menge bei eins und schließt Versand und Steuern aus. Die Regel ist einfach: Ein aktiver Rabattcode zieht genau 5 Dollar ab. Er fordert zuerst die fehlerhafte Version an, damit der Fehler vor der Reparatur bewahrt werden kann.

Enter Pro Build-Prompt: absichtlich einen zweiten 5-Dollar-Abzug nach einer Mengenänderung eingebaut.
Der Plan sagt anfangs 54 Dollar voraus, 49 Dollar nach Rabattanwendung und eine angezeigte Summe von 68 Dollar gegenüber den korrekten 73 Dollar nach Erhöhung der Kesselmenge. Ein Plan hält das beabsichtigte Verhalten fest; die Vorschau liefert den nächsten Beweis.

Der Projektplan hält die Preise, die erwarteten Summen und den geplanten Mengenänderungs-Bug fest.
Den Fehler in der Vorschau festhalten
Mit allen Mengen auf eins und aktivem Rabattcode zeigt die Vorschau eine Zwischensumme von 54 Dollar, einen Abzug von 5 Dollar und beide Summen bei 49 Dollar. Die Erhöhung der Kesselmenge auf zwei erhöht die Zwischensumme auf 78 Dollar, aber der Abzug wird zu 10 Dollar. Die angezeigten 68 Dollar und die unabhängig berechneten 73 Dollar legen die Diskrepanz offen.

Vor der Mengenänderung: Zwischensumme 54 $, Rabattabzug 5 $, angezeigte und korrekte Summe jeweils 49 $.

Nach Erhöhung der Kesselmenge auf zwei: Zwischensumme 78 $, Abzug 10 $, angezeigt 68 $, korrekt 73 $.
Der sichtbare Plan speichert couponDeduction. APPLY_COUPON setzt sie auf 5 Dollar; SET_QUANTITY fügt weitere 5 Dollar hinzu, wenn der Rabatt aktiv ist. Dieser geplante Zustandspfad stimmt mit dem beobachteten Anstieg des Abzugs überein. Prüfe den entsprechenden Reducer-Code, bevor du ihn patchst.
Eine gezielte Reparatur anfragen
Die Reparaturanfrage behält Projekt, Produkte und Rabattregel bei. Sie fordert einen Regressionstest, der vor dem Patch fehlschlägt und danach besteht, die tatsächlich geänderten Dateinamen und den Diff, die genauen Befehle und alle Prüfungen, die nicht ausgeführt werden konnten. Das gibt dem Agenten eine spezifische Invariante, die er schützen muss.

Der Reparaturprompt fordert eine minimale Änderung und echten Regressionsbeweis, während der 68/73-Fehlschlag weiterhin sichtbar bleibt.
Die Reparatur auf der richtigen Ebene verifizieren
Der letzte Screenshot bezeichnet den Rabatt-Bug als repariert und besagt, dass der Abzug jetzt aus dem Rabattzustand abgeleitet wird. Seine Vorschau ist zurückgesetzt: jede Menge ist eins, der Rabatt ist inaktiv, und beide Summen betragen 54 Dollar. Das hält die reparierte Basislinie fest; es zeigt nicht die reparierte Summe von 73 Dollar nach einer Mengenänderung.

Reparierte Vorschau im zurückgesetzten Zustand: beide Summen 54 $. Der Bericht nennt separat nicht ausgeführte UI-Prüfungen.
Der Bericht zitiert einen npm-Test-Log-Screenshot vor dem Fix mit Exit-Code 1. Der Screenshot zeigt nicht die vollständigen rohen fehlgeschlagenen und bestandenen Durchläufe oder den tatsächlichen Diff. Er besagt zudem, dass die Tests die Reducer- und Summenfunktionen abdecken, ohne jsdom- und Testing-Library-Umgebung für UI/DOM-Tests.
Der Anwenden-Button ist deaktiviert, während der Rabatt aktiv ist, daher ist die erneute Anwendung eine Prüfung auf Reducer-Ebene. Mobile Breiten und das dunkle Styling sind ebenfalls als unverifiziert markiert. Um die Verifizierung abzuschließen, setze den reparierten Warenkorb zurück und wiederhole 54 $ → 49 $ → 73 $ zweimal, dann prüfe Verringerungen und das Entfernen des Rabatts. Behalte den Diff und die vollständige Regressionsausgabe.
Den Bug eskalieren und mit Beweisen schließen
Eskalieren, wenn das Risiko den Wert eines weiteren Experiments übersteigt
Eskaliere, wenn der Fehler Zahlungen, Datenverlust, eine Sicherheitslücke, unsicheres Verhalten oder ein System betrifft, das du nicht untersuchen kannst. Du kannst weiterhin nicht invasive Beweise sammeln, aber der Verantwortliche muss über Eindämmung und Release entscheiden. Ich würde keinen spekulativen Rabatt-Patch gegen echte Kundentransaktionen testen.
Ein reproduzierbares Beweispaket übergeben
Eine Übergabe sollte die fehlerhafte Version, die Reproduktion, das erwartete und tatsächliche Ergebnis, relevante Logs, getestete Hypothesen und die aktuelle Gegenmaßnahme enthalten. Füge Anfrage-IDs und Timing hinzu, wenn der Fehler Services überschreitet. Du übergibst den Untersuchungsstand, nicht einfach eine vage Beschwerde.
Die Debugging-Checkliste vervollständigen
Bestätige vor dem Schließen die Ursache, den gezielten Diff, die ursprüngliche Reproduktion, den Regressionsschutz, angrenzende Pfade und den Deployment-Status. Entferne temporäre Diagnosen oder mache sie sicher und bewusst. Ich notiere außerdem jede ungelöste Prüfung, damit ein zukünftiger Reviewer Schweigen nicht mit einem Bestehen verwechselt.

Der Abschluss verknüpft Ursache und Reparatur mit den bewahrten Beweisen. Ein erfolgreicher Build deckt nur einen Teil davon ab.
Fazit: Code zuverlässig debuggen
Du brauchst keine dramatische Neuschreibung, um Code effektiv zu debuggen. Du brauchst eine präzise Diskrepanz, eine bewahrte Reproduktion und Beweise, die die Ursache einschränken. In der Warenkorb-Übung ist der entscheidende Hinweis, dass der Abzug bei einer Mengenänderung von 5 auf 10 Dollar steigt.
Mein bevorzugter Prozess beim Debuggen von KI-generiertem Code ist: zuerst untersuchen, dann eine einzige relevante Sache ändern und danach den ursprünglichen Übergang verifizieren. Die Enter Pro Demo macht die Berechnung und den Zustandswechsel sichtbar, während ihr Reparaturbericht Berechnungsprüfungen von nicht ausgeführten UI-Prüfungen trennt. Bewahre Diff, Regressionsausgabe und wiederholte Vorschauergebnisse zusammen, damit die nächste Person die Reparatur bewerten kann.
Probiere diesen Workflow in Enter Pro aus: bewahre einen Fehlerfall, fordere eine gezielte Reparatur an und prüfe die Beweise, bevor du sie akzeptierst.
Häufig gestellte Fragen
Was ist das Erste, was man tun sollte, wenn Code fehlschlägt?
Schreibe das erwartete und tatsächliche Verhalten auf, bewahre die fehlschlagende Eingabe und erstelle eine Reproduktion. Verursacht der Fehler aktiven Schaden, muss die Eindämmung möglicherweise vor weiteren Untersuchungen erfolgen.
Wie debugge ich Code, der nur manchmal fehlschlägt?
Erfasse Zustandsübergänge, Timing, Wiederholungsversuche und IDs über mehrere Durchläufe hinweg. Vergleiche fehlgeschlagene und erfolgreiche Durchläufe unter ähnlichen Bedingungen. Ein einziger erfolgreicher erneuter Durchlauf zeigt nicht, dass eine sporadische Ursache verschwunden ist.
Sollte ich Print-Anweisungen oder einen Debugger verwenden?
Nutze einen Debugger, wenn du live den Kontrollfluss und lokale Werte brauchst. Nutze Logs für entfernte, historische oder zeitkritische Beweise. Temporäre Print-Anweisungen sind nützlich, wenn sie eine konkrete Frage beantworten und danach entfernt werden.
Kann KI Code für mich debuggen?
KI für Code-Debugging kann Ursachen vorschlagen, relevanten Code untersuchen und Tests oder Patches vorschlagen. Du musst die Änderung trotzdem prüfen und das Ergebnis verifizieren. Behandle generierte Erklärungen und gemeldete Prüfungen gemäß den verfügbaren Beweisen.
Wie debugge ich Code, ohne den Bug zu verschlimmern?
Bewahre den ursprünglichen Zustand, arbeite in einer isolierten Umgebung und ändere jeweils eine relevante Variable. Behalte einen Rollback-Weg für Produktionsänderungen und vermeide diagnostische Aktionen, die echte Kundendaten verändern.
Warum kehrt ein Bug nach der Reparatur zurück?
Der Patch hat möglicherweise nur das Symptom verborgen, einen weiteren Pfad übersehen oder es versäumt, den Fall in einem Regressionstest festzuhalten. Vergleiche den neuen Fehler mit den ursprünglichen Beweisen, bevor du annimmst, er habe dieselbe Ursache.
Wie kann ich Enter Pro zum Debuggen von Code nutzen?
Halte die fehlerhafte Vorschau und die Reparatur in einem Projekt zusammen. Gib Enter Pro die Handlungsfolge, die erwarteten und tatsächlichen Summen sowie die Regel, die der Patch bewahren muss. Bitte es, die Berechnung zu untersuchen, eine gezielte Änderung vorzunehmen und Regressionsbeweise zu behalten. Prüfe den tatsächlichen Diff und wiederhole die Abfolge selbst.
Was sollte ich prüfen, nachdem Enter Pro einen Bug reparriert hat?
Wiederhole den ursprünglichen Fehler und angrenzende Pfade, und prüfe dann die vollständigen Testergebnisse. In dieser Demo muss die reparierte Vorschau 73 Dollar zeigen, nachdem der Rabatt angewendet und die Kesselmenge auf zwei erhöht wurde. Der Reset-Screenshot mit 54 Dollar allein kann das nicht belegen. Behandle Reducer-Tests, UI-Interaktionstests und Build-Prüfungen als separate Beweise.






