Quelltext der Seite Professionelles Debugging und KI-gestützte Fehleranalyse - aiMOOC

{{T}}

{{BR}}
= Einleitung =

'''Professionelles [[Debugging]]''' ist die Fähigkeit, Fehler nicht zufällig, sondern systematisch zu finden, zu erklären, zu beheben und gegen Rückfälle abzusichern. In moderner [[Softwareentwicklung]] reicht es nicht, nur eine Fehlermeldung zu kopieren und schnell etwas zu ändern. Du musst ein [[Fehlerbild]] beobachten, eine nachvollziehbare [[Hypothese]] bilden, geeignete [[Werkzeuge]] einsetzen, den [[Code]] verstehen, die Änderung testen und dokumentieren. Durch [[Künstliche Intelligenz|KI]] kommen neue Möglichkeiten hinzu: [[Large Language Model|Large Language Models]] können Fehlermeldungen erklären, mögliche Ursachen sammeln, Testfälle vorschlagen, Logs strukturieren, Codevarianten vergleichen und Dich beim Formulieren von [[Prompt|Prompts]] unterstützen.

Das Thema verbindet drei Bereiche: Erstens geht es um klassisches, professionelles [[Debugging]] mit [[Debugger|Debuggern]], [[Logdatei|Logdateien]], [[Stacktrace|Stacktraces]], [[Testfall|Testfällen]] und [[Code Review|Code Reviews]]. Zweitens lernst Du, wie [[KI-gestützte Fehleranalyse]] sinnvoll eingesetzt wird, ohne Kontrolle, Datenschutz und [[Softwarequalität]] aufzugeben. Drittens ordnest Du aktuelle Arbeitsweisen wie '''[[Vibe-Coding]]''' und '''[[Agentic-Coding]]''' ein. Beim [[Vibe-Coding]] beschreibst Du Deine Absicht in natürlicher Sprache und lässt eine KI viel Code erzeugen. Beim [[Agentic-Coding]] arbeitet ein [[KI-Agent]] mit Werkzeugen, kann Dateien lesen, Änderungen planen, Tests ausführen und iterativ auf Fehler reagieren. In beiden Fällen bleibt der Mensch verantwortlich: Du prüfst, verstehst, testest und entscheidest.

{{#ev:youtube|   https://www.youtube.com/watch?v=ReId8CToUSg   |500|center}}

[[Datei:Rubber duck assisting with debugging.jpg|500px|rahmenlos|center]]

Die bekannte Methode des [[Rubber Duck Debugging|Rubber-Duck-Debuggings]] zeigt einen Kern professioneller Fehleranalyse: Wer ein Problem so präzise erklären kann, dass auch ein Gegenüber ohne Kontext den Ablauf versteht, findet oft selbst die Ursache. KI kann hier wie eine sehr schnelle Gesprächspartnerin wirken. Sie ersetzt aber nicht das eigene Denken, sondern fordert bessere [[Fehlerbeschreibung|Fehlerbeschreibungen]], klare Beispiele und überprüfbare Annahmen.

{{BR}}
== Lernziele ==

Nach diesem aiMOOC kannst Du erklären, was professionelles [[Debugging]] von bloßem Ausprobieren unterscheidet. Du kannst Fehler reproduzieren, eingrenzen, Hypothesen formulieren, geeignete Werkzeuge auswählen und einen [[Bugfix]] mit Tests absichern. Du kannst [[KI]] als Hilfsmittel für [[Fehleranalyse]], [[Prompt Engineering]], [[Code Review]] und Testentwurf nutzen. Außerdem kannst Du Chancen und Risiken von [[Vibe-Coding]] und [[Agentic-Coding]] beurteilen und einen verantwortungsvollen Arbeitsprozess für Schule, Ausbildung, Studium oder Beruf entwickeln.

{{BR}}
== Was bedeutet Debugging? ==

[[Debugging]] bezeichnet in der [[Informatik]] den Vorgang, Fehler oder unerwartetes Verhalten in einem [[Computerprogramm]] zu diagnostizieren und zu beheben. Ein [[Programmfehler|Bug]] ist nicht immer eine einzelne falsche Zeile. Oft entsteht ein Fehler durch das Zusammenspiel von [[Anforderung]], [[Architektur]], [[Datenmodell]], [[Benutzereingabe]], [[Schnittstelle]], [[Nebenläufigkeit]], [[Abhängigkeit]] oder [[Konfiguration]]. Professionelles Debugging fragt deshalb nicht nur: '''Welche Zeile ist falsch?''' Es fragt: '''Was hätte passieren sollen, was ist tatsächlich passiert, unter welchen Bedingungen tritt es auf und welche Erklärung passt zu allen Beobachtungen?'''

Ein wichtiger Unterschied besteht zwischen '''Symptom''', '''Ursache''' und '''Lösung'''. Das [[Symptom]] ist das sichtbare Problem, etwa ein Absturz, eine falsche Ausgabe oder eine langsame Antwortzeit. Die [[Ursache]] ist der technische oder fachliche Grund, zum Beispiel eine falsche Annahme, ein Grenzfall, eine fehlerhafte Datenbankabfrage oder ein unvollständiger Test. Die [[Lösung]] ist die gezielte Änderung, die die Ursache beseitigt, ohne neue Fehler einzubauen. Wer nur Symptome bekämpft, riskiert [[Regression|Regressionen]] und schwer wartbaren Code.

{{BR}}
== Professioneller Debugging-Prozess ==

Ein professioneller [[Debugging-Prozess]] ist iterativ. Du gehst nicht blind von einer Vermutung zur nächsten, sondern arbeitest mit überprüfbaren Schritten. Besonders hilfreich ist ein Ablauf aus Beobachten, Reproduzieren, Eingrenzen, Erklären, Ändern und Absichern.

# [[Fehlerbeschreibung]]: Beschreibe erwartetes Verhalten, tatsächliches Verhalten, Umgebung, Eingaben, Versionen und Fehlermeldungen.
# [[Reproduzierbarkeit]]: Erstelle einen Weg, mit dem der Fehler zuverlässig ausgelöst werden kann.
# [[Minimales Beispiel]]: Reduziere das Problem auf einen möglichst kleinen Fall, der den Fehler noch zeigt.
# [[Hypothese]]: Formuliere eine prüfbare Vermutung zur Ursache.
# [[Instrumentierung]]: Sammle Daten mit [[Logging]], [[Tracing]], [[Debugger]], [[Profiler]] oder [[Testfall|Tests]].
# [[Bugfix]]: Ändere nur so viel wie nötig und begründe die Änderung.
# [[Regressionstest]]: Sichere ab, dass derselbe Fehler nicht erneut auftritt.
# [[Code Review]]: Lasse Logik, Lesbarkeit, Sicherheit und Nebenwirkungen prüfen.

[[Datei:Gdb-7.3-debugging-session.png|500px|rahmenlos|center]]

Ein [[Debugger]] unterstützt Dich dabei, ein Programm kontrolliert auszuführen. Mit [[Haltepunkt|Haltepunkten]] kannst Du die Ausführung an einer Stelle stoppen. Mit Einzelschritten untersuchst Du, welche Anweisung als Nächstes ausgeführt wird. Mit Beobachtungen von [[Variable|Variablen]], [[Call Stack|Aufrufstapel]] und [[Speicher]] erkennst Du, wie sich der Zustand des Programms verändert. Das Ziel ist nicht, wahllos im Programm herumzuklicken, sondern gezielt Daten zu einer Hypothese zu sammeln.

{{BR}}
== Werkzeuge der Fehleranalyse ==

Professionelle [[Softwareentwicklung]] nutzt mehrere Werkzeuge, weil verschiedene Fehlerarten unterschiedliche Spuren hinterlassen. Ein [[Debugger]] eignet sich besonders für lokale Kontrollfluss- und Zustandsfehler. [[Logging]] hilft, Ereignisse über längere Zeit sichtbar zu machen. [[Tracing]] zeigt, wie Anfragen durch verteilte Systeme laufen. [[Profiling]] findet Leistungsprobleme. [[Statische Codeanalyse]] erkennt bestimmte Muster, bevor der Code ausgeführt wird. [[Unit-Test|Unit-Tests]], [[Integrationstest|Integrationstests]] und [[End-to-End-Test|End-to-End-Tests]] machen Verhalten überprüfbar.

[[Datei:Debuggerfirefox95.png|500px|rahmenlos|center]]

In [[Webentwicklung]] und [[Frontend]]-Arbeit sind Entwicklerwerkzeuge im [[Browser]] besonders wichtig. Dort kannst Du Netzwerkaufrufe, Konsolenausgaben, JavaScript-Fehler, DOM-Strukturen, Speicherverbrauch und Performance untersuchen. In [[Backend]]-Systemen spielen zusätzlich [[Logdatei|Logdateien]], Metriken, [[Datenbank]]-Abfragen, Container-Logs und [[Monitoring]] eine große Rolle. In [[Cloud Computing|Cloud-Umgebungen]] wird die Fähigkeit wichtig, zwischen Codefehler, Konfigurationsfehler, Berechtigungsproblem, Netzwerkeffekt und externer Abhängigkeit zu unterscheiden.

{{BR}}
== KI-gestützte Fehleranalyse ==

[[KI-gestützte Fehleranalyse]] bedeutet, dass Du ein [[Sprachmodell]] oder einen [[KI-Agent|Agenten]] nutzt, um schneller zu verstehen, was ein Fehler bedeuten könnte. Eine KI kann Fehlermeldungen übersetzen, [[Stacktrace|Stacktraces]] zusammenfassen, wahrscheinliche Ursachen priorisieren, Testfälle erzeugen, Dokumentation durchsuchen, Refactoring-Vorschläge machen oder alternative Erklärungen liefern. Die Qualität hängt stark vom [[Kontext]] ab. Je präziser Du erwartetes Verhalten, tatsächliches Verhalten, Umgebung, relevante Codeausschnitte, Logs, bisherige Versuche und Einschränkungen beschreibst, desto hilfreicher wird die Antwort.

KI ist kein [[Orakel]]. Ein Modell kann plausible, aber falsche Erklärungen liefern, veraltete Bibliotheken empfehlen, Sicherheitsrisiken übersehen oder Code erzeugen, der nur für den gezeigten Beispielweg funktioniert. Darum gilt: KI-Vorschläge müssen durch [[Test|Tests]], [[Code Review]], [[Dokumentation]], Ausführung und fachliches Verständnis überprüft werden. Besonders wichtig ist der Schutz vertraulicher Daten. Du solltest keine [[API-Schlüssel]], Passwörter, personenbezogenen Daten, internen Zugangsdaten oder unveröffentlichten Geschäftsgeheimnisse in ungeprüfte KI-Systeme kopieren.

{{BR}}
== Debugging-Prompts professionell formulieren ==

Ein guter [[Prompt]] für Debugging ist wie ein guter Fehlerbericht. Er ist konkret, reproduzierbar und überprüfbar. Statt nur zu schreiben '''Mein Code geht nicht''', beschreibst Du das Ziel, die Umgebung, den relevanten Code, die Fehlermeldung und Deine bisherigen Beobachtungen. Du kannst die KI gezielt bitten, keine endgültige Lösung zu behaupten, sondern Hypothesen mit Prüfwegen zu nennen. So wird aus einer schnellen Antwort ein strukturierter Analyseprozess.

Ein professioneller Debugging-Prompt kann folgende Bestandteile enthalten:

# [[Rolle]]: Bitte die KI, als erfahrene Entwicklerin, Testerin oder Sicherheitsprüferin zu agieren.
# [[Kontext]]: Beschreibe Sprache, Framework, Version, Betriebssystem, Architektur und relevante Abhängigkeiten.
# [[Soll-Ist-Vergleich]]: Erkläre erwartetes Verhalten und beobachtetes Verhalten.
# [[Reproduktion]]: Gib genaue Schritte, Eingaben und Daten an.
# [[Fehlermeldung]]: Füge Stacktrace, Logauszug oder Konsolenausgabe ein, wenn sie keine sensiblen Daten enthalten.
# [[Einschränkung]]: Nenne, was nicht verändert werden darf, etwa öffentliche Schnittstellen oder Datenbankschema.
# [[Ausgabeformat]]: Bitte um Hypothesen, Prüfplan, minimale Änderung und passende Tests.

{{BR}}
== Vibe-Coding: Chancen und Grenzen ==

'''[[Vibe-Coding]]''' beschreibt eine Arbeitsweise, bei der Du Software stark über natürliche Sprache steuerst. Du formulierst Absicht, gewünschte Funktion, Stil oder Verhalten, und eine KI erzeugt große Teile des Codes. Das kann beim schnellen [[Prototyping]], beim Erkunden unbekannter Bibliotheken oder beim Erstellen kleiner Werkzeuge sehr produktiv sein. Vibe-Coding verschiebt die Arbeit vom manuellen Schreiben einzelner Zeilen hin zu [[Anforderung|Anforderungsbeschreibung]], Kontextsteuerung, Prüfung und Iteration.

Das Risiko liegt darin, dass der erzeugte Code schneller wächst, als er verstanden wird. Wenn Du Änderungen nur akzeptierst, weil sie im Moment funktionieren, können unklare Architektur, Sicherheitslücken, doppelte Logik, fehlende Tests und schwer wartbare Abhängigkeiten entstehen. Professionelles Vibe-Coding braucht deshalb klare Grenzen: kleine Schritte, Versionskontrolle, Tests, Review, verständliche Commit-Nachrichten und bewusste Entscheidungen über [[Architektur]] und [[Softwarequalität]]. Die entscheidende Frage lautet nicht: '''Kann die KI Code erzeugen?''' Die entscheidende Frage lautet: '''Kannst Du nachweisen, dass der Code korrekt, sicher, wartbar und zur Aufgabe passend ist?'''

{{BR}}
== Agentic-Coding: KI-Agenten im Entwicklungsprozess ==

'''[[Agentic-Coding]]''' geht über einfache Codevorschläge hinaus. Ein [[KI-Agent]] erhält ein Ziel, plant Teilschritte, liest Dateien, verändert Code, führt Tests oder Befehle aus, analysiert Fehlerausgaben und versucht iterativ, die Aufgabe zu erfüllen. Dadurch ähnelt der Prozess stärker einer Zusammenarbeit mit einem automatisierten Teammitglied. Agentic-Coding kann bei wiederholbaren Aufgaben helfen, etwa beim Aktualisieren einer API-Nutzung, beim Schreiben fehlender Tests, beim Refactoring kleiner Module oder beim Erstellen eines ersten Lösungsvorschlags für ein Issue.

Gerade weil Agenten mehr Handlungsspielraum haben, braucht diese Arbeitsweise klare [[Governance]]. Du solltest den Arbeitsbereich begrenzen, Änderungen in separaten Branches ausführen, automatische Tests verlangen, riskante Befehle blockieren, sensible Dateien ausschließen und jeden Diff prüfen. Ein guter Agentic-Coding-Prozess endet nicht mit '''Die KI ist fertig''', sondern mit einem nachvollziehbaren [[Pull Request]], einer Testübersicht, einem Review und einer menschlichen Freigabe. KI kann Ausführung beschleunigen, aber Verantwortung bleibt bei Menschen und Organisationen.

{{BR}}
== Qualitäts- und Sicherheitsprinzipien ==

Bei KI-unterstützter Programmierung ist [[Softwarequalität]] kein Zusatz, sondern Voraussetzung. Besonders wichtig sind [[Testbarkeit]], [[Wartbarkeit]], [[Sicherheit]], [[Datenschutz]], [[Lizenz]]-Bewusstsein und [[Nachvollziehbarkeit]]. Jede KI-generierte Änderung sollte so behandelt werden wie Code eines unbekannten Teammitglieds: lesen, verstehen, testen und prüfen. Das gilt besonders für Authentifizierung, Autorisierung, Kryptografie, Zahlungsprozesse, personenbezogene Daten, Produktionsdatenbanken und sicherheitskritische Infrastruktur.

Ein verantwortungsvoller Workflow kann so aussehen: Du startest mit einem Issue, definierst Akzeptanzkriterien, arbeitest in einem Branch, lässt KI nur auf notwendige Dateien zugreifen, forderst Tests ein, prüfst Abhängigkeiten, untersuchst Sicherheitsfolgen und dokumentierst die Entscheidung. Bei unklaren Änderungen solltest Du die KI nicht nach einer bloßen Korrektur fragen, sondern nach einem Diagnoseplan: Welche Ursachen sind möglich? Welche Beobachtung spricht wofür? Welcher Test entscheidet zwischen den Hypothesen? So bleibt Debugging wissenschaftsnah: Du arbeitest mit Beobachtung, Hypothese, Experiment und Auswertung.

{{BR}}
== Beispiel: Von der Fehlermeldung zum abgesicherten Fix ==

Angenommen, eine Webanwendung zeigt nach dem Speichern eines Formulars manchmal eine Fehlermeldung. Unprofessionell wäre es, sofort irgendeinen Codeabschnitt zu ändern. Professionell beschreibst Du zuerst den Kontext: Browser, Rolle der Nutzerin, Eingabedaten, Uhrzeit, Version und konkrete Fehlermeldung. Dann prüfst Du, ob der Fehler reproduzierbar ist. Du untersuchst Netzwerkaufrufe, Backend-Logs und Datenbankantworten. Du formulierst Hypothesen, zum Beispiel: Ein Pflichtfeld wird im Frontend anders validiert als im Backend, eine API liefert bei leeren Werten ein anderes Format oder ein Token läuft während des Speicherns ab.

Eine KI kann Dir helfen, die Logs zu gruppieren, mögliche Ursachen zu sammeln oder Testfälle für Grenzwerte vorzuschlagen. Sie darf aber nicht ungeprüft den Produktionscode verändern. Du entscheidest, welche Hypothese plausibel ist, schreibst einen Test, der den Fehler zeigt, änderst den Code minimal, führst die Tests aus, ergänzt bei Bedarf Dokumentation und lässt den Patch prüfen. Erst wenn der Fehler reproduzierbar behoben und gegen Rückfälle abgesichert ist, ist das Debugging professionell abgeschlossen.

{{BR}}
= Interaktive Aufgaben =

{{BR}}
== Quiz: Teste Dein Wissen ==

{{MC}}

'''Was ist das Ziel von professionellem Debugging?'''
(Systematisches Diagnostizieren, Beheben und Absichern von Fehlern)
(!Schnelles Ausprobieren beliebiger Codeänderungen)
(!Das Entfernen aller Kommentare aus dem Code)
(!Das Ersetzen aller Tests durch KI-Antworten)

{{E}}
<br>

{{MC}}

'''Was beschreibt ein minimales reproduzierbares Beispiel?'''
(Einen kleinen Fall, der den Fehler zuverlässig zeigt)
(!Eine besonders lange Dokumentation ohne Code)
(!Eine zufällige Vermutung ohne Ausführung)
(!Eine Designidee ohne Bezug zum Fehler)

{{E}}
<br>

{{MC}}

'''Warum ist eine Hypothese beim Debugging wichtig?'''
(Sie macht eine Ursache prüfbar)
(!Sie ersetzt alle Tests)
(!Sie verhindert das Lesen von Logs)
(!Sie garantiert automatisch die richtige Lösung)

{{E}}
<br>

{{MC}}

'''Welches Werkzeug hält ein Programm gezielt an einer bestimmten Stelle an?'''
(Ein Haltepunkt)
(!Ein Kommentar)
(!Ein Farbschema)
(!Ein Dateiname)

{{E}}
<br>

{{MC}}

'''Wobei kann KI in der Fehleranalyse sinnvoll helfen?'''
(Beim Sammeln von Hypothesen, Erklären von Fehlermeldungen und Entwerfen von Tests)
(!Beim sicheren Erraten geheimer Passwörter)
(!Beim Überspringen von Code Review)
(!Beim Veröffentlichen ungeprüfter Produktionsdaten)

{{E}}
<br>

{{MC}}

'''Was kennzeichnet Vibe-Coding am besten?'''
(Die Beschreibung einer Absicht in natürlicher Sprache, aus der KI Code erzeugt)
(!Das ausschließliche Programmieren ohne Computer)
(!Das manuelle Sortieren von Logdateien nach Farbe)
(!Das Abschalten aller Entwicklungswerkzeuge)

{{E}}
<br>

{{MC}}

'''Was unterscheidet Agentic-Coding von einfacher Codevervollständigung?'''
(Ein Agent kann planen, Dateien bearbeiten, Tests ausführen und iterieren)
(!Ein Agent schreibt nur einzelne Buchstaben vor)
(!Ein Agent verhindert jede Form von Automatisierung)
(!Ein Agent funktioniert nur ohne Aufgabenbeschreibung)

{{E}}
<br>

{{MC}}

'''Was solltest Du mit KI-generiertem Code tun, bevor er übernommen wird?'''
(Verstehen, testen und im Review prüfen)
(!Blind akzeptieren)
(!Sofort in Produktion einspielen)
(!Alle Fehlermeldungen ignorieren)

{{E}}
<br>

{{MC}}

'''Welche Information gehört nicht in einen ungeprüften KI-Prompt?'''
(API-Schlüssel und Zugangsdaten)
(!Eine anonymisierte Fehlermeldung)
(!Ein kleines Testbeispiel)
(!Eine Beschreibung des erwarteten Verhaltens)

{{E}}
<br>

{{MC}}

'''Warum sind Regressionstests nach einem Bugfix wichtig?'''
(Sie helfen zu verhindern, dass derselbe Fehler wiederkehrt)
(!Sie löschen automatisch alle alten Dateien)
(!Sie ersetzen die Versionsverwaltung)
(!Sie machen Fachanforderungen unnötig)

{{E}}
<br>

{{BR}}
== Memory ==

<div class="memo-quiz">
{|
|-
| Bug || Fehler im Programmverhalten
|-
| Symptom || Sichtbares Problem
|-
| Hypothese || Prüfbare Erklärung
|-
| Breakpoint || Gezielte Unterbrechung
|-
| Logfile || Protokoll von Ereignissen
|-
| Regressionstest || Schutz vor Rückfällen
|-
| Prompt || Auftrag an die KI
|-
| Agent || KI-System mit Werkzeugnutzung
|}
{{E}}
<br>

{{BR}}
== Drag and Drop ==

<div class="lueckentext-quiz">

{| class="wikitable" 
! Ordne die richtigen Begriffe zu.
! Thema
|-
| '''Fehlerbild'''
| Beobachtung des unerwarteten Verhaltens
|-
| '''Reproduktion'''
| Wiederholbares Auslösen des Fehlers
|-
| '''Hypothese'''
| Vermutung über die Ursache
|-
| '''Instrumentierung'''
| Sammeln von Logs Traces und Messwerten
|-
| '''Fix'''
| Gezielte Änderung im Code
|-
| '''Absicherung'''
| Test gegen Rückfall

|}
{{E}}

<br>

{{BR}}
== Kreuzworträtsel ==

<div class="kreuzwort-quiz">
{|
|-
| Debugger || Werkzeug zur kontrollierten Programmuntersuchung
|-
| Logdatei || Datei mit aufgezeichneten Ereignissen
|-
| Hypothese || Prüfbare Vermutung zur Fehlerursache
|-
| Testfall || Konkrete Eingabe mit erwartetem Ergebnis
|-
| Review || Menschliche Prüfung von Codeänderungen
|-
| Kontext || Informationen, die eine KI für eine Aufgabe braucht
|}
{{E}}
<br>

{{BR}}
== LearningApps ==

<iframe> https://learningapps.org/index.php?s=Professionelles+Debugging+KI+Fehleranalyse+Vibe+Coding+Agentic+Coding </iframe>

{{BR}}
== Lückentext ==

<quiz display=simple>
{'''Vervollständige den Text.'''<br>
|type="{}"}
Beim professionellen { Debugging } wird ein Fehler systematisch untersucht und nicht nur zufällig überdeckt. Eine gute { Fehlerbeschreibung } vergleicht erwartetes Verhalten mit beobachtetem Verhalten. Ein reproduzierbarer Fehler kann mit festen { Schritten } wieder ausgelöst werden. Eine { Hypothese } ist eine prüfbare Vermutung über die Ursache. Ein { Debugger } kann ein Programm an einem Haltepunkt stoppen. Durch { Logging } werden Ereignisse während der Ausführung sichtbar. KI kann bei der Analyse helfen, bleibt aber ohne { Kontext } unsicher. Beim { Vibe-Coding } wird die Absicht stark über natürliche Sprache beschrieben. Beim { Agentic-Coding } kann ein KI-System Werkzeuge nutzen und iterativ Änderungen prüfen. Vor der Übernahme von KI-Code brauchst Du Tests, Verständnis und { Review }.
</quiz>

<br>

{{BR}}
= Offene Aufgaben =

{{BR}}
=== Leicht ===
# [[Fehlerbeschreibung]]: Suche eine einfache Fehlermeldung aus einer Programmierübung und schreibe eine saubere Beschreibung mit Soll-Verhalten, Ist-Verhalten, Umgebung und Reproduktionsschritten.
# [[Rubber Duck Debugging]]: Erkläre einem Gegenstand oder einer Mitschülerin Schritt für Schritt, was Dein Code tun soll, und notiere, an welcher Stelle Deine Erklärung unsicher wird.
# [[Prompt Engineering]]: Formuliere zwei unterschiedliche Prompts zu derselben Fehlermeldung und vergleiche, welcher Prompt die hilfreichere Antwort erzeugt.
# [[Logdatei]]: Erfinde fünf Logeinträge für ein kleines Programm und markiere, welche Einträge für die Fehlersuche nützlich wären.

{{BR}}
=== Standard ===
# [[Minimales Beispiel]]: Reduziere einen fehlerhaften Codeabschnitt so weit, dass der Fehler noch auftritt, aber alle unnötigen Teile entfernt sind.
# [[Testfall]]: Schreibe einen Test, der einen bekannten Fehler sichtbar macht, und erkläre, warum dieser Test vor dem Fix fehlschlagen sollte.
# [[KI-gestützte Fehleranalyse]]: Gib einer KI eine anonymisierte Fehlermeldung und fordere drei Hypothesen mit Prüfplan an; bewerte anschließend, welche Hypothese am besten überprüfbar ist.
# [[Code Review]]: Prüfe einen KI-generierten Lösungsvorschlag auf Lesbarkeit, Nebenwirkungen, fehlende Tests und Sicherheitsrisiken.

{{BR}}
=== Schwer ===
# [[Agentic-Coding]]: Entwirf einen sicheren Workflow, in dem ein KI-Agent nur in einem begrenzten Branch arbeiten darf, Tests ausführt und einen prüfbaren Pull Request erstellt.
# [[Fehleranalysebericht]]: Schreibe einen professionellen Bericht zu einem Bug mit Symptom, Ursache, Untersuchungsmethode, Fix, Testabsicherung und offener Restunsicherheit.
# [[Sicherheitsanalyse]]: Untersuche ein Beispiel, bei dem KI-generierter Code Eingaben nicht validiert, und entwickle Gegenmaßnahmen gegen Missbrauch.
# [[Teamprozess]]: Entwickle Regeln für ein Entwicklungsteam, das Vibe-Coding nutzen möchte, ohne Wartbarkeit, Datenschutz und Verantwortlichkeit zu verlieren.

{{:Offene Aufgabe - MOOC erstellen}}

{{BR}}
= Lernkontrolle =

# [[Transferaufgabe Debugging-Prozess]]: Du erhältst eine unklare Fehlermeldung aus einer Webanwendung. Entwickle einen vollständigen Untersuchungsplan, der Reproduktion, Hypothesen, Werkzeuge, Tests und Dokumentation verbindet.
# [[Vergleich Vibe-Coding und Agentic-Coding]]: Vergleiche beide Arbeitsweisen anhand eines konkreten Softwareprojekts und begründe, für welche Projektphase welche Arbeitsweise geeignet oder riskant wäre.
# [[Bewertung KI-generierter Lösungen]]: Analysiere einen KI-Vorschlag, der zwar den Fehler behebt, aber doppelte Logik einführt. Erkläre, wie Du Qualität, Wartbarkeit und Testbarkeit verbessern würdest.
# [[Datenschutz und Sicherheit]]: Entwickle Regeln für den Umgang mit Logs, Kundendaten, Zugangsdaten und internem Code bei der Nutzung von KI-Systemen im Debugging.
# [[Fehlerkultur]]: Erkläre, warum eine gute Fehlerkultur in Teams professionelles Debugging fördert, und zeige an einem Beispiel, wie Schuldzuweisung die Fehleranalyse verschlechtert.

<br>
<br>

{{BR}}
= Lernnachweis =

Für den [[Lernnachweis]] erstellst Du ein kleines Portfolio. Es enthält einen anonymisierten Fehlerbericht, ein minimales reproduzierbares Beispiel, mindestens einen Testfall, eine dokumentierte KI-Anfrage mit Reflexion, einen geprüften Lösungsvorschlag und eine kurze Bewertung der Risiken. Wichtig ist nicht, dass jeder Fehler sofort perfekt gelöst wird, sondern dass Dein Vorgehen nachvollziehbar, überprüfbar und verantwortungsvoll ist.

{{BR}}
= OERs zum Thema =

<iframe> https://de.m.wikipedia.org/wiki/Debuggen </iframe>

<iframe> https://de.m.wikipedia.org/wiki/Debugger </iframe>

<iframe> https://de.m.wikipedia.org/wiki/Large_Language_Model </iframe>

<br>

{{BR}}
= Links =

{| align=center
{{:D-Tab}}
'''[[Professionelles Debugging und KI-gestützte Fehleranalyse]]'''
# [[Debugging]]
# [[Debugger]]
# [[Programmfehler]]
# [[Fehleranalyse]]
# [[Softwaretest]]
# [[Logging]]
# [[Tracing]]
# [[Versionsverwaltung]]
# [[Künstliche Intelligenz]]
# [[Large Language Model]]
# [[Prompt Engineering]]
# [[Vibe-Coding]]
# [[Agentic-Coding]]
# [[Code Review]]
# [[Softwarequalität]]
|}

[[Kategorie:Informatik]]
[[Kategorie:Programmieren]]
[[Kategorie:Softwareentwicklung]]
[[Kategorie:Debugging]]
[[Kategorie:Künstliche Intelligenz]]
[[Kategorie:Medienbildung]]
[[Kategorie:Berufliche Bildung]]
[[Kategorie:Studium]]
[[Kategorie:Klasse 11-13]]
{{BR}}
= aiMOOC-Projekte =
[[Kategorie:AI_MOOC]] [[Kategorie:GPT aiMOOC]]
{{MT}}