DE EN

KI Co-Coding

Systematisches Prompting für Python, Code reviewen mit KI, effiziente Debugging-Strategien.

60 Min Schwer

Lernziele dieses Kapitels

  • Du schreibst effektive Prompts für Python-Code mit KI
  • Du reviewest KI-generierten Code kritisch und verbesserst ihn
  • Du nutzt KI-gestütztes Debugging für schnelle Fehlerbehebung
  • Du erweiterst PyBuddy um einen KI-Prompt-Generator

Effektives Prompting

Gute Prompts sind wie gute Aufträge: spezifisch, strukturiert und kontextreich. Statt "Schreib mir ein Spiel" sagst du: "Erstelle ein Zahlenratespiel in Python mit input(), Zufallszahlen und einem Versuchszähler. Kommentiere den Code."

Die beste Struktur für Prompts:

  1. Kontext: Wer bist du, was kannst du?

  2. Anforderung: Was soll genau gemacht werden?

  3. Format: Wie soll die Antwort aussehen?

  4. Einschränkungen: Was soll vermieden werden?

Python
# Schlechter vs. guter Prompt (als String)
schlecht = "Schreib mir ein Programm"

gut = '''Ich bin 16 Jahre alt und lerne Python. 
Erstelle ein Zahlenratespiel mit folgenden Anforderungen:
- Nutze random.randint() für eine Zahl 1-100
- Der Spieler gibt Tipps ein
- Nach jedem Tipp kommt "zu hoch" oder "zu niedrig"
- Zähle die Versuche
- Gib am Ende die Anzahl der Versuche aus
- Kommentiere den Code für Anfänger
Format: Nur Python-Code, keine Erklärungen dazwischen.'''

print("Länge schlecht:", len(schlecht))
print("Länge gut:", len(gut))
Ausgabe
Länge schlecht: 23 Länge gut: 342

Code-Review mit KI

KI ist ein exzellenter Code-Reviewer — wenn du die richtigen Fragen stellst. Lade die KI ein, deinen Code auf Bugs, Sicherheitslücken und Best Practices zu prüfen.

Typische Review-Fragen:

  • "Reviewe diese Funktion auf Bugs und Edge Cases."
  • "Prüfe auf Python-Best Practices (PEP 8)."
  • "Gibt es Sicherheitsprobleme?"
  • "Wie kann ich den Code effizienter machen?"
Python
# Beispiel-Code für ein KI-Review
def berechne_rabatt(preis, prozent):
    return preis - (preis * prozent / 100)

# KI-Prompt:
review_prompt = '''
Reviewe die Funktion berechne_rabatt().
- Prüfe auf Bugs (z.B. negative Preise, Prozent > 100)
- Schlage Input-Validierung vor
- Formatiere nach PEP 8
- Gib den verbesserten Code als Komplettlösung aus
'''

print(review_prompt)
Ausgabe
Reviewe die Funktion berechne_rabalt(). - Prüfe auf Bugs (z.B. negative Preise, Prozent > 100) ...

KI-gestütztes Debugging

Wenn dein Code nicht funktioniert, kopiere Fehlermeldung + Code in die KI. Die beste Frage ist konkret: "Ich bekomme [FEHLER]. Hier ist mein Code. Erkläre mir warum und wie ich ihn behebe."

Pro Tipp

Gib immer den vollständigen Fehlertext und den relevanten Code-Ausschnitt. Ohne Kontext ratet die KI nur.

Python
# Beispiel für KI-Debugging-Request
fehler_code = '''
noten = [2, 3, 1, 4]
durchschnitt = sum(noten) / len(noten)
print(f"Durchschnitt: {durchschnitt:.2f}")
'''

fehlermeldung = "TypeError: unsupported operand type(s) for /: 'int' and 'list'"

debug_prompt = f'''
Ich bekomme diesen Fehler:
{fehlermeldung}

Hier ist mein Code:
{fehler_code}

Erkläre mir:
1. Warum tritt der Fehler auf?
2. Wie behebe ich ihn?
3. Zeige mir den korrigierten Code.
'''

print(debug_prompt)
Ausgabe
Ich bekomme diesen Fehler: TypeError: unsupported operand type(s) for /: 'int' and 'list' ...

KI-Refactoring in der Praxis

Refactoring bedeutet: Code verbessern, ohne sein Verhalten zu ändern. Die KI kann dir helfen, unleserlichen Code in saubere, pythonic Lösungen zu verwandeln.

Python
# Vorher: Unleserlicher Code
def note_von_prozent(p):
    if p > 89:
        return 1
    if p > 76:
        return 2
    if p > 63:
        return 3
    if p > 50:
        return 4
    return 5

# Nach KI-Refactoring (besser):
def note_von_prozent(p):
    """Gibt die Schulnote (1-5) basierend auf Prozent zurück."""
    if not (0 <= p <= 100):
        raise ValueError("Prozent muss zwischen 0 und 100 liegen")
    
    grenzen = [(89, 1), (76, 2), (63, 3), (50, 4)]
    for grenze, note in grenzen:
        if p >= grenze:
            return note
    return 5

# Test
for p in [95, 82, 70, 55, 40]:
    print(f"{p}% = Note {note_von_prozent(p)}")
Ausgabe
95% = Note 1 82% = Note 2 70% = Note 3 55% = Note 4 40% = Note 5
Python vs. JavaScript — Das kennst du schon!

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python
def note_von_prozent(p):
    if p >= 89: return 1
    if p >= 76: return 2
    ...
JavaScript
function noteVonProzent(p) {
    if (p >= 89) return 1;
    if (p >= 76) return 2;
    ...
}
Merke: Das ursprüngliche if-elif-Muster ist in Python und JavaScript identisch. Die KI-Verbesserung mit der Grenzen-Liste zeigt pythonic Denken — weniger Wiederholung, mehr Lesbarkeit.

PyBuddy meets KI

PyBuddy bekommt eine Funktion, die strukturierte KI-Prompts generiert. Der Nutzer gibt ein Thema ein, PyBuddy erstellt einen perfekten Prompt dafür.

Python
# pybuddy/main.py
def ki_prompt(thema, zielgruppe="Anfänger", sprache="de"):
    """Generiert einen strukturierten KI-Prompt."""
    prompt = f"""
Erkläre mir das Thema '{thema}' in Python.
Zielgruppe: {zielgruppe} (15-19 Jahre)
Sprache: {sprache}
Format: Code-Beispiel + Erklärung
Anforderungen:
- Nutze ein praktisches Beispiel
- Kommentiere den Code für Anfänger
- Zeige typische Fehler und wie man sie vermeidet
- Maximal 30 Zeilen Code
"""
    return prompt.strip()

# Nutzung
thema = input(" Welches Thema willst du lernen? ")
prompt = ki_prompt(thema)
print("\n Dein KI-Prompt:")
print("=" * 40)
print(prompt)
print("=" * 40)
Ausgabe
Welches Thema willst du lernen? Schleifen Dein KI-Prompt: ======================================== Erkläre mir das Thema 'Schleifen' in Python. Zielgruppe: Anfänger (15-19 Jahre) ... ========================================

Warm-Up: KI-Refactor Challenge

Nimm deine Noten-Rechner-Funktion aus Kapitel 4. Schreibe einen Prompt, der die KI bittet, sie mit Input-Validierung, Docstring und Typ-Hinweisen zu verbessern.

Hinweis: # Alter Code (aus Kapitel 4) def note(p): if p >= 89: return 1 elif p >= 76: return 2 elif p >= 63: return 3 elif p >= 50: return 4 else: return 5 # KI-Prompt: prompt = '''Refactore diese Funktion mit: 1. Input-Validierung (0-100) 2. Docstring 3. Typ-Hinweise 4. PEP 8 Konformität 5. Test-Beispiele Code: def note(p): if p >= 89: return 1 ...''' print(prompt)

Lösung
# Alter Code (aus Kapitel 4)
def note(p):
    if p >= 89: return 1
    elif p >= 76: return 2
    elif p >= 63: return 3
    elif p >= 50: return 4
    else: return 5

# KI-Prompt:
prompt = '''Refactore diese Funktion mit:
1. Input-Validierung (0-100)
2. Docstring
3. Typ-Hinweise
4. PEP 8 Konformität
5. Test-Beispiele

Code:
def note(p):
    if p >= 89: return 1
    ...'''

print(prompt)

Challenge: Debugging-Übung

Schreibe absichtlich fehlerhaften Code (z.B. IndexError, TypeError). Dann schreibe einen KI-Prompt, der Fehlermeldung und Code enthält und um Erklärung bittet.

Hinweis: # Absichtlich fehlerhafter Code code = "\nspieler = ['Anna', 'Ben']\nprint(spieler[5]) # IndexError!\n" fehler = 'IndexError: list index out of range' prompt = f'''\nIch bekomme diesen Fehler: {fehler}\n\nMein Code:{code}\n\nErkläre mir:\n1. Warum passiert das?\n2. Wie finde ich die Zeile mit dem Fehler?\n3. Wie behebe ich ihn sicher?\n''' print(prompt)

Lösung
# Absichtlich fehlerhafter Code
code = "\nspieler = ['Anna', 'Ben']\nprint(spieler[5])  # IndexError!\n"

fehler = 'IndexError: list index out of range'

prompt = f'''\nIch bekomme diesen Fehler: {fehler}\n\nMein Code:{code}\n\nErkläre mir:\n1. Warum passiert das?\n2. Wie finde ich die Zeile mit dem Fehler?\n3. Wie behebe ich ihn sicher?\n'''

print(prompt)

PyBuddy-Checkpoint: KI-Integration

PyBuddy bekommt eine Funktion, die den Nutzer nach einem Thema fragt und einen strukturierten Prompt für KI-Tools generiert.

Hinweis: # pybuddy/main.py def ki_generator(): print(" PyBuddy KI-Assistent") thema = input("Thema: ") level = input("Level (Anfänger/Fortgeschritten/Pro): ") or "Anfänger" prompt = f"""\nErkläre mir '{thema}' in Python.\nMein Level: {level}\nFormat: Kurzes Code-Beispiel + Erklärung\nAnforderungen:\n- Praxisnah und verständlich\n- Maximal 20 Zeilen Code\n- Tipps für häufige Fehler\n""" print("\n Kopiere diesen Prompt in deine KI:") print("-" * 40) print(prompt) print("-" * 40) ki_generator()

Lösung
# pybuddy/main.py
def ki_generator():
    print(" PyBuddy KI-Assistent")
    thema = input("Thema: ")
    level = input("Level (Anfänger/Fortgeschritten/Pro): ") or "Anfänger"
    
    prompt = f"""\nErkläre mir '{thema}' in Python.\nMein Level: {level}\nFormat: Kurzes Code-Beispiel + Erklärung\nAnforderungen:\n- Praxisnah und verständlich\n- Maximal 20 Zeilen Code\n- Tipps für häufige Fehler\n"""
    
    print("\n Kopiere diesen Prompt in deine KI:")
    print("-" * 40)
    print(prompt)
    print("-" * 40)

ki_generator()
Didaktische Pause

In Portal 2 programmierst du mit visuellen Blöcken — die KI GLaDOS kommentiert deinen Code. KI-Assistenten sind längst Realität: GitHub Copilot, ChatGPT, Claude — sie alle helfen Entwicklern, schneller besseren Code zu schreiben. Du lernst gerade, diese Tools professionell einzusetzen!

Zusammenfassung

  • Gute Prompts = Kontext + Anforderung + Format + Einschränkungen
  • KI als Code-Reviewer: Bugs, Sicherheit, Best Practices prüfen
  • Debugging: Fehlermeldung + Code → KI für schnelle Hilfe
  • Refactoring mit KI: Unleserlichen Code in pythonic Code verwandeln
  • PyBuddy generiert jetzt strukturierte KI-Prompts