Glanz: aiMOOC über GPT aiMOOC Action erstellt

2026-06-30T11:06:00Z

aiMOOC über GPT aiMOOC Action erstellt

Neue Seite

{{T}}

{{BR}}
= Einleitung =

[[Datei:Claude AI logo.svg|500px|rahmenlos|center]]

'''Programmieren mit Claude''' bedeutet, [[Künstliche Intelligenz|KI]] als Lern-, Denk- und Entwicklungswerkzeug in der [[Softwareentwicklung]] einzusetzen. [[Claude (Sprachmodell)|Claude]] ist eine Familie großer [[Large Language Model|Sprachmodelle]] und ein KI-Assistent des Unternehmens [[Anthropic]]. Beim Programmieren kann Claude helfen, Code zu erklären, Entwürfe zu verbessern, Fehler zu finden, [[Test (Software)|Tests]] zu schreiben, [[Dokumentation]] zu erstellen, [[Refactoring]] vorzuschlagen oder ganze Arbeitsschritte in einer [[Entwicklungsumgebung]] zu begleiten.

Dieser aiMOOC zeigt Dir, wie Du Claude verantwortungsvoll und wirksam zum Programmieren einsetzt. Du lernst nicht nur einzelne Befehle, sondern einen professionellen Arbeitsprozess: Ziel klären, Kontext geben, Plan prüfen, kleine Änderungen umsetzen, Tests ausführen, Ergebnisse kritisch bewerten und Entscheidungen dokumentieren. Dabei bleibt wichtig: Claude ist ein Werkzeug. Die Verantwortung für Qualität, Sicherheit, Datenschutz, Lizenzen und fachliche Richtigkeit liegt weiterhin beim Menschen.

{{BR}}
== Was Du in diesem aiMOOC lernst ==

# [[Claude (Sprachmodell)|Claude]]: Du verstehst, was Claude als KI-Assistent leisten kann und wo Grenzen liegen.
# [[Prompt Engineering|Prompt Engineering]]: Du formulierst präzise Arbeitsaufträge, damit Claude brauchbare Ergebnisse liefert.
# [[Claude Code|Claude Code]]: Du lernst den Grundgedanken eines agentischen Coding-Werkzeugs kennen, das mit Dateien, Befehlen und Entwicklungswerkzeugen arbeiten kann.
# [[Softwaretest|Softwaretests]]: Du nutzt Tests, Builds und [[Linter]] als überprüfbare Qualitätskriterien.
# [[Versionsverwaltung|Versionsverwaltung]]: Du sicherst Änderungen mit [[Git]] ab und arbeitest in nachvollziehbaren Schritten.
# [[Datenschutz|Datenschutz]] und [[IT-Sicherheit|IT-Sicherheit]]: Du erkennst Risiken bei geheimen Daten, fremdem Code, Abhängigkeiten und automatisierten Befehlen.
# [[Reflexion]]: Du bewertest KI-generierten Code nicht nach Eindruck, sondern nach Funktion, Lesbarkeit, Wartbarkeit und Sicherheit.

{{BR}}
= Grundlagen: Was ist Claude? =

[[Claude (Sprachmodell)|Claude]] ist ein KI-System, das natürliche Sprache versteht und erzeugt. Für die Programmierung ist das besonders nützlich, weil Programmieren nicht nur aus Code besteht. Gute Software entsteht durch Verstehen von Anforderungen, Zerlegen komplexer Probleme, Lesen vorhandener Codebasen, Planen von Änderungen, Testen, Dokumentieren und Kommunizieren. Claude kann in vielen dieser Phasen unterstützen.

Claude arbeitet auf Basis von [[Token|Tokens]], also kleinen Texteinheiten. Der verfügbare [[Kontext]] ist begrenzt. Wenn Du zu viele Dateien, Logs, Diskussionen und Nebeninformationen in eine Sitzung lädst, kann die Qualität sinken. Deshalb ist professionelles Arbeiten mit Claude immer auch [[Kontextmanagement]]: Du gibst relevante Informationen, lässt unnötige Details weg und fasst Zwischenergebnisse zusammen.

{{BR}}
== Claude als Programmierpartner ==

[[Datei:Pair programming 1.jpg|500px|rahmenlos|center]]

Beim klassischen [[Pair Programming|Pair Programming]] arbeiten zwei Menschen gemeinsam an einem Problem. Eine Person schreibt Code, die andere denkt mit, fragt nach, erkennt Fehler und achtet auf Struktur. Beim Programmieren mit Claude entsteht eine ähnliche, aber nicht gleiche Situation: Claude kann Rollen übernehmen, zum Beispiel als Erklärer, Code-Reviewer, Tester, Architekturberater oder Debugging-Partner. Im Unterschied zu einem Menschen besitzt Claude jedoch kein echtes Verständnis, keine Verantwortung und keinen Zugriff auf die reale Wirkung Deines Programms, sofern Du ihm diese Informationen nicht überprüfbar gibst.

Ein sinnvoller Einsatz lautet daher nicht: „Schreib mir alles fertig.“ Besser ist: „Hilf mir, das Problem zu verstehen, mache einen Plan, ändere nur diese Datei, schreibe Tests, führe die Tests aus und erkläre mir die Risiken.“ So bleibt die Kontrolle bei Dir.

{{BR}}
== Große Sprachmodelle und Code ==

[[Datei:Artificial neural network.svg|500px|rahmenlos|center]]

Ein [[Large Language Model|Large Language Model]] erzeugt Antworten, indem es Muster in Sprache, Code und Kontext verarbeitet. Es kann häufig passende Lösungen vorschlagen, aber es kann sich irren, veraltete Annahmen verwenden oder unsichere Lösungen produzieren. Gerade beim Programmieren fallen Fehler manchmal nicht sofort auf: Ein Programm kann laufen und trotzdem Sicherheitslücken, falsche Randfälle oder schlechte Architektur enthalten.

Deshalb gilt beim Programmieren mit Claude: '''Vertrauen entsteht durch Überprüfung.''' Gute Prompts enthalten klare Prüfkriterien. Gute Ergebnisse werden mit Tests, Builds, Code-Reviews und Beispielausgaben belegt.

{{BR}}
= Werkzeuge rund um Claude =

{{BR}}
== Claude im Browser oder in der App ==

Claude kann im Browser oder in Apps genutzt werden, um Code zu erklären, Aufgaben zu planen, Fehlermeldungen zu analysieren oder Dokumentation zu schreiben. Diese Nutzung ist besonders geeignet, wenn Du keine direkte Verbindung zu Deinem lokalen Projekt herstellen möchtest. Du kannst einzelne Codeausschnitte einfügen, solltest aber keine geheimen Schlüssel, personenbezogenen Daten oder vertraulichen Projektinformationen weitergeben.

Typische Aufgaben sind:
# [[Codeanalyse|Codeanalyse]]: „Erkläre mir diese Funktion Schritt für Schritt.“
# [[Debugging|Debugging]]: „Hier ist die Fehlermeldung. Welche Ursachen sind wahrscheinlich?“
# [[Algorithmus|Algorithmus]]: „Entwirf einen Algorithmus und analysiere die Laufzeit.“
# [[Dokumentation|Dokumentation]]: „Schreibe eine verständliche README für dieses kleine Projekt.“
# [[Lernen|Lernen]]: „Stelle mir Verständnisfragen zu diesem Code.“

{{BR}}
== Claude Code als agentisches Coding-Werkzeug ==

'''Claude Code''' ist ein KI-gestütztes Werkzeug für die Programmierung, das in Entwicklungsumgebungen wie Terminal, [[Integrierte Entwicklungsumgebung|IDE]], Desktop-App oder Browser genutzt werden kann. Der zentrale Unterschied zu einem reinen Chat ist, dass ein agentisches Coding-Werkzeug nicht nur antwortet, sondern im Rahmen erteilter Berechtigungen Dateien lesen, Änderungen vorschlagen oder ausführen und Befehle starten kann.

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

Das macht Claude Code mächtig, aber auch riskanter als einen Chat. Wenn ein Werkzeug Dateien verändern oder Befehle ausführen kann, brauchst Du klare Grenzen. Du solltest verstehen, welche Ordner betroffen sind, welche Befehle erlaubt sind, wie Änderungen überprüft werden und wie Du den Zustand des Projekts wiederherstellen kannst.

{{BR}}
== Claude über eine API nutzen ==

Eine [[Programmierschnittstelle|API]] ermöglicht es, Claude in eigene Anwendungen einzubauen. Eine Anwendung kann zum Beispiel Texte analysieren, Code kommentieren, Benutzerfragen beantworten oder strukturierte Daten erzeugen. Dabei sendet Dein Programm Anfragen an die Claude-Plattform und erhält Antworten zurück. Ein typisches API-Muster besteht aus Modellname, Nachrichtenverlauf, maximaler Antwortlänge und optionalen Systemeinstellungen.

{{BR}}
=== Beispiel: API-Aufruf in Python ===

Das folgende Beispiel ist bewusst einfach. Prüfe vor echter Nutzung immer die aktuelle Dokumentation, die Kosten, die Modellnamen und die Datenschutzanforderungen.

<syntaxhighlight lang="python">
import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

message = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=500,
messages=[
{
"role": "user",
"content": "Erkläre in einfachen Worten, was eine Python-Funktion ist."
}
],
)

print(message.content[0].text)
</syntaxhighlight>

Wichtig ist: Der [[API-Key]] darf niemals im Quellcode veröffentlicht werden. Verwende Umgebungsvariablen, Geheimnisverwaltung oder sichere Konfigurationssysteme. Lade keine Schlüssel in ein öffentliches [[Repository]] hoch.

{{BR}}
= Professioneller Arbeitsprozess =

{{BR}}
== Erst verstehen, dann verändern ==

Ein häufiger Fehler beim KI-gestützten Programmieren ist zu frühes Implementieren. Wenn Claude sofort Code schreibt, ohne Anforderungen, Architektur und Randfälle zu kennen, entsteht oft eine Lösung, die oberflächlich passt, aber das eigentliche Problem verfehlt. Ein professioneller Ablauf trennt daher Analyse, Planung, Umsetzung und Prüfung.

# [[Analyse]]: Beschreibe das Ziel, zeige relevante Dateien und lasse Claude erklären, wie der vorhandene Code funktioniert.
# [[Planung]]: Bitte Claude um einen konkreten Änderungsplan mit betroffenen Dateien, Risiken und Teststrategie.
# [[Implementierung]]: Lasse kleine, überprüfbare Änderungen vornehmen.
# [[Test (Software)|Test]]: Führe Unit-Tests, Integrationstests, Build, Linter oder manuelle Prüfschritte aus.
# [[Code-Review|Review]]: Prüfe den Unterschied, lies den Code selbst und lasse Claude mögliche Schwachstellen suchen.
# [[Commit]]: Speichere nachvollziehbare Änderungen mit aussagekräftiger Nachricht in [[Git]].

{{BR}}
== Prompt-Muster für Programmieraufgaben ==

Gute Prompts sind klar, vollständig und überprüfbar. Sie enthalten nicht nur den Wunsch, sondern auch Kontext, Grenzen und Prüfkriterien.

<syntaxhighlight lang="text">
Ziel:
Implementiere eine Funktion, die E-Mail-Adressen nach einfachen Regeln validiert.

Kontext:
Die Funktion soll in src/validation.py liegen.
Bestehende Tests befinden sich in tests/test_validation.py.

Einschränkungen:
Nutze keine neue externe Bibliothek.
Ändere keine öffentliche API außer der neuen Funktion.
Behandle leere Strings, fehlendes @ und ungültige Domains.

Prüfung:
Schreibe passende Unit-Tests.
Führe die Tests aus.
Zeige mir am Ende den Testbefehl und das Ergebnis.
</syntaxhighlight>

Ein solcher Prompt macht aus einer vagen Bitte eine überprüfbare Aufgabe. Claude weiß, welche Datei wichtig ist, welche Grenzen gelten und wann die Aufgabe erledigt ist.

{{BR}}
== Vom vagen Prompt zum guten Prompt ==

{| class="wikitable"
! Vager Prompt
! Besserer Prompt
|-
| „Mach den Code besser.“
| „Analysiere src/cart.py auf Lesbarkeit und Fehleranfälligkeit. Schlage drei konkrete Refactorings vor, ohne Verhalten zu ändern. Warte auf meine Freigabe, bevor Du Code änderst.“
|-
| „Fix den Bug.“
| „Der Login schlägt nach abgelaufener Sitzung fehl. Untersuche den Authentifizierungsfluss in src/auth/. Schreibe zuerst einen Test, der den Fehler reproduziert, behebe dann die Ursache und führe die Tests aus.“
|-
| „Schreib Tests.“
| „Schreibe Unit-Tests für calculate_discount. Decke Normalfall, Grenzwerte, ungültige Eingaben und Rundungsfehler ab. Nutze das vorhandene Testmuster in tests/test_prices.py.“
|-
| „Erklär das.“
| „Erkläre diese Funktion für Lernende der Klasse 10. Beschreibe Eingaben, Verarbeitung, Ausgabe und mögliche Fehlerfälle. Verwende ein kleines Beispiel.“
|}

{{BR}}
= Qualitätssicherung =

{{BR}}
== Tests als Wahrheitssignal ==

Claude kann behaupten, dass eine Aufgabe gelöst ist. Entscheidend ist aber, ob überprüfbare Signale dies bestätigen. Gute Signale sind:
# [[Unit-Test|Unit-Tests]] für einzelne Funktionen.
# [[Integrationstest|Integrationstests]] für zusammengesetzte Abläufe.
# [[Build]] ohne Fehler.
# [[Linter]] und [[Formatierer]] für Stil und einfache Fehler.
# Beispielausgaben, Screenshots oder manuelle Prüfschritte bei Benutzeroberflächen.
# [[Code-Review]] durch Menschen oder eine zweite unabhängige KI-Prüfung.

Tests sind nicht nur Kontrolle. Sie helfen Claude auch beim Arbeiten. Wenn Claude einen Test ausführen und die Fehlermeldung lesen kann, entsteht eine Rückkopplungsschleife: ändern, testen, Fehler lesen, verbessern.

{{BR}}
== Versionsverwaltung mit Git ==

[[Git]] ist beim Programmieren mit Claude besonders wichtig. Wenn Claude Dateien ändern darf, brauchst Du einen sicheren Ausgangspunkt. Arbeite deshalb in einem sauberen Repository, nutze Branches und prüfe Diffs, bevor Du Änderungen übernimmst. Ein sinnvoller Ablauf ist:

# Vor Beginn: `git status` prüfen.
# Für die Aufgabe: neuen Branch erstellen.
# Während der Arbeit: kleine Änderungen ansehen.
# Vor dem Commit: Tests ausführen.
# Nach dem Commit: aussagekräftige Commit-Nachricht schreiben.
# Vor dem Merge: Review durchführen.

{{BR}}
== Code-Review mit Claude ==

Claude kann beim Review helfen, aber nicht das menschliche Review ersetzen. Besonders nützlich sind Fragen wie:

<syntaxhighlight lang="text">
Prüfe diesen Diff auf:
1. offensichtliche Bugs,
2. unbehandelte Randfälle,
3. Sicherheitsrisiken,
4. unnötige Komplexität,
5. fehlende Tests.

Gib nur konkrete Fundstellen an.
Unterscheide zwischen sicherem Fehler, möglichem Risiko und Stilfrage.
</syntaxhighlight>

So zwingst Du Claude, genauer zu unterscheiden. Ein Review, das nur „sieht gut aus“ sagt, ist wenig wert. Ein gutes Review nennt konkrete Stellen, Begründungen und mögliche Gegenbeispiele.

{{BR}}
= Sicherheit und Verantwortung =

{{BR}}
== Datenschutz und vertrauliche Informationen ==

Beim Programmieren werden oft sensible Daten sichtbar: [[API-Key|API-Keys]], Zugangsdaten, Kundendaten, interne URLs, Logdateien, Datenbankauszüge oder Geschäftslogik. Teile solche Informationen nicht unüberlegt mit externen KI-Diensten. Entferne oder anonymisiere sensible Teile, bevor Du sie in einen Prompt kopierst. In Unternehmen und Schulen gelten zusätzlich interne Regeln, Verträge und Datenschutzvorgaben.

{{BR}}
== Gefährliche Befehle vermeiden ==

Ein agentisches Werkzeug kann Befehle ausführen. Das ist hilfreich, wenn es Tests startet, Abhängigkeiten installiert oder Dateien durchsucht. Es kann aber gefährlich werden, wenn Befehle Daten löschen, Netzwerke ändern, fremde Skripte ausführen oder produktive Systeme betreffen. Prüfe Befehle, bevor Du sie erlaubst. Arbeite bei riskanten Aufgaben in einer [[Sandbox]], einem Testprojekt oder einem isolierten Container.

Beispiele für Vorsicht:
# Keine unbekannten Installationsskripte blind ausführen.
# Keine produktiven Datenbanken ohne Backup verändern.
# Keine geheimen Schlüssel in Logs oder Prompts einfügen.
# Keine Lizenztexte entfernen.
# Keine generierten Sicherheitsfunktionen ohne Prüfung produktiv verwenden.

{{BR}}
== Urheberrecht und Lizenzen ==

Claude kann Code vorschlagen, aber Du musst prüfen, ob Du den Code verwenden darfst. Besonders bei Projekten mit [[Open Source|Open-Source]]-Abhängigkeiten sind Lizenzbedingungen wichtig. Wenn Claude Code aus unbekannter Herkunft nachbildet oder eine Bibliothek vorschlägt, prüfe Lizenz, Wartungsstand, Sicherheit und Kompatibilität.

{{BR}}
= Didaktische Einsatzmöglichkeiten =

{{BR}}
== Lernen durch Erklären ==

Claude eignet sich gut, um Programmierkonzepte in mehreren Niveaus erklären zu lassen. Du kannst fragen: „Erkläre Rekursion zuerst für Anfänger, dann fachlich korrekt und danach mit einem Codebeispiel.“ Noch besser ist es, Claude nicht nur erklären zu lassen, sondern Lernfragen zu stellen. So entwickelst Du aktives Verständnis statt passives Abschreiben.

{{BR}}
== Lernen durch Fehlersuche ==

Eine gute Übung besteht darin, absichtlich fehlerhaften Code zu untersuchen. Claude kann Hinweise geben, aber Du solltest selbst Hypothesen formulieren. Frage zum Beispiel: „Welche drei Ursachen könnten diesen Fehler auslösen? Welche Beobachtung würde jede Hypothese bestätigen oder widerlegen?“ Dadurch lernst Du systematisches [[Debugging]].

{{BR}}
== Lernen durch Verbesserung ==

Beim [[Refactoring]] bleibt das Verhalten des Programms gleich, aber die Struktur wird besser. Claude kann helfen, lange Funktionen zu zerlegen, sprechendere Namen vorzuschlagen oder doppelte Logik zu entfernen. Wichtig ist, vorher Tests zu haben. Ohne Tests ist schwer zu beweisen, dass das Verhalten wirklich gleich geblieben ist.

{{BR}}
= Praktische Mini-Projekte =

{{BR}}
== Mini-Projekt 1: Ein kleines Konsolenprogramm verbessern ==

Wähle ein einfaches Programm, etwa einen Taschenrechner, eine To-do-Liste oder ein Vokabelquiz. Bitte Claude zunächst um eine Erklärung des vorhandenen Codes. Danach lässt Du einen Verbesserungsplan erstellen. Setze nur eine Verbesserung um, schreibe Tests und dokumentiere, was sich geändert hat.

{{BR}}
== Mini-Projekt 2: Fehlermeldungen verstehen ==

Sammle drei echte Fehlermeldungen aus einem Projekt. Gib Claude jeweils nur die Fehlermeldung, den relevanten Codeausschnitt und die erwartete Funktion. Vergleiche Claudes Vermutung mit Deiner eigenen Analyse. Notiere, welche Informationen für die Lösung entscheidend waren.

{{BR}}
== Mini-Projekt 3: README und Teststrategie ==

Lasse Claude eine README für ein kleines Projekt entwerfen. Prüfe, ob Installation, Nutzung, Beispiele, Tests und bekannte Grenzen verständlich beschrieben sind. Ergänze anschließend eine Teststrategie: Welche Funktionen müssen automatisch getestet werden, welche manuell, welche gar nicht?

{{BR}}
= Interaktive Aufgaben =

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

{{MC}}

'''Wofür eignet sich Claude beim Programmieren besonders gut?'''
(Zum Erklären, Planen, Prüfen und Verbessern von Code)
(!Zum garantierten Erzeugen fehlerfreier Programme)
(!Zum Ersetzen aller Tests)
(!Zum geheimen Speichern von API-Schlüsseln)

{{E}}
<br>

{{MC}}

'''Warum sollte man Claude beim Programmieren klare Prüfkriterien geben?'''
(Damit Ergebnisse mit Tests oder anderen Signalen überprüft werden können)
(!Damit Claude ohne Kontext beliebige Dateien verändert)
(!Damit keine Versionsverwaltung mehr nötig ist)
(!Damit Datenschutzregeln unwichtig werden)

{{E}}
<br>

{{MC}}

'''Was ist ein guter erster Schritt bei einer komplexen Coding-Aufgabe mit Claude?'''
(Den vorhandenen Code verstehen und einen Plan erstellen lassen)
(!Sofort alle Dateien automatisch ändern lassen)
(!Alle Tests löschen, damit keine Fehler erscheinen)
(!Den API-Key in den Prompt schreiben)

{{E}}
<br>

{{MC}}

'''Was bezeichnet Refactoring?'''
(Verbesserung der Code-Struktur ohne beabsichtigte Funktionsänderung)
(!Das Löschen aller Kommentare)
(!Das Veröffentlichen eines API-Schlüssels)
(!Das Ersetzen von Tests durch Vermutungen)

{{E}}
<br>

{{MC}}

'''Welche Information gehört in einen guten Programmierprompt?'''
(Ziel, Kontext, Grenzen und Prüfschritte)
(!Nur ein einzelnes Wort ohne Erklärung)
(!Private Zugangsdaten)
(!Ungeprüfte Befehle zum Löschen von Dateien)

{{E}}
<br>

{{MC}}

'''Warum ist Git beim Arbeiten mit Claude wichtig?'''
(Änderungen bleiben nachvollziehbar und können zurückgenommen werden)
(!Git verhindert automatisch jeden Programmierfehler)
(!Git ersetzt alle Tests)
(!Git macht Datenschutz überflüssig)

{{E}}
<br>

{{MC}}

'''Was ist ein API-Key?'''
(Ein geheimer Zugangsschlüssel für eine Programmierschnittstelle)
(!Eine öffentliche Überschrift im Quellcode)
(!Ein Testfall für Benutzeroberflächen)
(!Ein Dateiformat für Bilder)

{{E}}
<br>

{{MC}}

'''Was sollte man mit sensiblen Daten in Prompts tun?'''
(Sie vermeiden, entfernen oder anonymisieren)
(!Sie möglichst vollständig veröffentlichen)
(!Sie in öffentliche Repositories kopieren)
(!Sie als Kommentar in Beispielcode einbauen)

{{E}}
<br>

{{MC}}

'''Was ist ein Linter?'''
(Ein Werkzeug zur Prüfung von Stil und einfachen Codeproblemen)
(!Ein Programm zum Löschen von Versionsgeschichte)
(!Ein geheimer Schlüssel für Claude)
(!Eine Methode zum Umgehen von Tests)

{{E}}
<br>

{{MC}}

'''Welche Aussage beschreibt Claude Code am besten?'''
(Ein KI-gestütztes Coding-Werkzeug, das im Rahmen von Berechtigungen mit Projekten arbeiten kann)
(!Ein Ersatz für jedes menschliche Verständnis)
(!Ein reines Bildbearbeitungsprogramm)
(!Ein Versionsverwaltungssystem ohne Code)

{{E}}
<br>

{{BR}}
== Memory ==

<div class="memo-quiz">
{|
|-
| Claude || KI-Assistent von Anthropic
|-
| Prompt || präzise Anweisung
|-
| Kontextfenster || Arbeitsgedächtnis der Sitzung
|-
| CLAUDE.md || Projektregeln für den Agenten
|-
| Refactoring || Verbesserung der Code-Struktur
|-
| Unit-Test || automatischer Prüffall
|-
| Git || Versionsverwaltung
|}
{{E}}
<br>

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

<div class="lueckentext-quiz">

{| class="wikitable"
! Ordne die richtigen Begriffe zu.
! Thema
|-
| '''Prompt'''
| Aufgabenbeschreibung
|-
| '''Test'''
| Überprüfung
|-
| '''Repository'''
| Projektablage
|-
| '''Refactoring'''
| Strukturverbesserung
|-
| '''Commit'''
| gespeicherter Änderungsstand

|}
{{E}}

<br>

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

<div class="kreuzwort-quiz">
{|
|-
| Claude || Wie heißt der KI-Assistent von Anthropic?
|-
| Prompt || Wie nennt man eine Anweisung an ein KI-System?
|-
| Kontext || Was liefert dem Modell wichtige Hintergrundinformationen?
|-
| Debugging || Wie nennt man die systematische Fehlersuche im Programm?
|-
| Commit || Wie nennt man einen gespeicherten Änderungsstand in Git?
|-
| Sandbox || Wie nennt man eine isolierte Umgebung zum sicheren Ausprobieren?
|}
{{E}}
<br>

{{BR}}
== LearningApps ==

<iframe> https://learningapps.org/index.php?s=Programmieren+mit+Claude </iframe>

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

<quiz display=simple>
{'''Vervollständige den Text.'''<br>
|type="{}"}
Beim Programmieren mit Claude formulierst Du zuerst ein klares { Ziel }. Ein guter Prompt enthält neben der Aufgabe auch den relevanten { Kontext }. Damit Claude nicht nur behauptet, fertig zu sein, brauchst Du überprüfbare { Tests }. Sensible Daten wie Zugangsschlüssel dürfen nicht in einen { Prompt } kopiert werden. Mit Git kannst Du Änderungen als { Commit } sichern. Beim Refactoring soll die Struktur besser werden, ohne das Verhalten absichtlich zu { verändern }. Ein Linter erkennt Stilprobleme und einfache { Fehler }. Ein agentisches Coding-Werkzeug braucht klare { Berechtigungen }.
</quiz>

<br>

{{BR}}
= Offene Aufgaben =

{{BR}}
=== Leicht ===

# [[Code erklären]]: Wähle eine kurze Funktion aus einem Lernprojekt und lasse Claude sie in drei Schwierigkeitsstufen erklären. Prüfe anschließend, welche Erklärung fachlich am besten ist.
# [[Prompt verbessern]]: Schreibe einen vagen Prompt wie „Mach den Code besser“ und verwandle ihn in einen präzisen Prompt mit Ziel, Kontext, Grenzen und Prüfung.
# [[Fehlermeldung analysieren]]: Kopiere eine harmlose Fehlermeldung ohne private Daten und lasse Claude drei mögliche Ursachen nennen. Überprüfe jede Ursache im Code.
# [[Lernkarte erstellen]]: Erstelle zehn Karteikarten zu Begriffen wie Prompt, Token, Test, Commit, Refactoring und API.

{{BR}}
=== Standard ===

# [[Teststrategie entwickeln]]: Nimm ein kleines Programm und lasse Claude Vorschläge für Unit-Tests machen. Entscheide selbst, welche Tests sinnvoll sind, und begründe Deine Auswahl.
# [[Refactoring planen]]: Wähle eine unübersichtliche Funktion und bitte Claude um einen Refactoring-Plan. Setze nur eine Änderung um und prüfe mit Tests, ob das Verhalten gleich bleibt.
# [[README verbessern]]: Lasse Claude eine README für ein Projekt überarbeiten. Ergänze fehlende Informationen zu Installation, Nutzung, Tests und Grenzen des Programms.
# [[Code-Review durchführen]]: Gib Claude einen Diff oder einen Codeausschnitt und fordere ein Review nach Bugs, Randfällen, Sicherheit und Lesbarkeit an. Vergleiche Claudes Review mit Deinem eigenen.

{{BR}}
=== Schwer ===

# [[KI-gestützter Entwicklungsprozess]]: Entwirf einen vollständigen Workflow für ein Team, das Claude beim Programmieren nutzt. Berücksichtige Git-Branches, Tests, Reviews, Datenschutz und Freigaben.
# [[Sicherheitsanalyse]]: Untersuche ein kleines Webprojekt auf Risiken wie unsichere Eingaben, fehlende Validierung oder geheime Schlüssel. Nutze Claude als Hilfsmittel, aber formuliere die endgültige Bewertung selbst.
# [[API-Prototyp]]: Erstelle einen einfachen Prototyp, der über eine API eine Anfrage an Claude sendet. Verwende Umgebungsvariablen für den Schlüssel und dokumentiere Datenschutz- und Kostenrisiken.
# [[Vergleichsstudie]]: Vergleiche eine Aufgabe, die Du allein löst, mit derselben Aufgabe unter Nutzung von Claude. Analysiere Zeitaufwand, Fehler, Lerngewinn und Qualität des Ergebnisses.

{{:Offene Aufgabe - MOOC erstellen}}

{{BR}}
= Lernkontrolle =

# [[Transferaufgabe Promptdesign]]: Du bekommst die Aufgabe, in einem vorhandenen Projekt eine neue Suchfunktion einzubauen. Entwickle einen Prompt, der Claude zuerst analysieren, dann planen und erst nach Freigabe implementieren lässt.
# [[Fallanalyse Datenschutz]]: In einem Log stehen E-Mail-Adressen, Session-IDs und Fehlermeldungen. Entscheide, welche Informationen Du Claude geben darfst, welche anonymisiert werden müssen und welche gar nicht in den Prompt gehören.
# [[Qualitätsbewertung]]: Claude liefert Code, der scheinbar funktioniert, aber keine Tests enthält. Entwickle ein Prüfverfahren, mit dem Du Funktion, Randfälle, Lesbarkeit und Sicherheit bewertest.
# [[Rollenvergleich]]: Vergleiche Claude als Erklärer, Claude als Code-Reviewer und Claude als agentisches Coding-Werkzeug. Erkläre, welche Rolle in welcher Situation sinnvoll ist.
# [[Fehlerdiagnose]]: Ein KI-generierter Fix beseitigt eine Fehlermeldung, aber verändert unerwartet das Verhalten. Beschreibe, wie Du mit Git, Tests und Review die Ursache findest.
# [[Teamregel erstellen]]: Formuliere fünf verbindliche Regeln für eine Lerngruppe oder ein Entwicklungsteam, das Claude beim Programmieren nutzen möchte.

<br>
<br>

{{BR}}
= Lernnachweis =

Für einen überzeugenden [[Lernnachweis]] zum Thema '''Programmieren mit Claude''' solltest Du zeigen, dass Du Claude nicht nur bedienen, sondern reflektiert einsetzen kannst.

# [[Projektportfolio]]: Dokumentiere ein kleines Programmierprojekt mit Ausgangslage, Ziel, Prompts, Zwischenergebnissen und Endstand.
# [[Prompt-Protokoll]]: Lege dar, welche Prompts gut funktioniert haben, welche nicht und wie Du sie verbessert hast.
# [[Codequalität]]: Zeige den finalen Code, erkläre wichtige Entscheidungen und belege die Funktion durch Tests.
# [[Sicherheitsreflexion]]: Beschreibe, wie Du API-Keys, personenbezogene Daten und riskante Befehle geschützt hast.
# [[Versionsverlauf]]: Weise mit Git-Commits nach, dass Du in nachvollziehbaren Schritten gearbeitet hast.
# [[Kritische Bewertung]]: Erkläre, welche Vorschläge von Claude Du übernommen, verändert oder verworfen hast und warum.
# [[Präsentation]]: Stelle Dein Vorgehen so vor, dass andere daraus Regeln für den sinnvollen KI-Einsatz beim Programmieren ableiten können.

<br>
<br>

{{BR}}
= OERs zum Thema =

<iframe> https://de.m.wikipedia.org/wiki/Claude_(Sprachmodell) </iframe>

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

{{BR}}
== Weiterführende Dokumentationen und Medien ==

# [[Claude Code]]: Die offizielle Dokumentation erklärt Installation, Arbeitsweise, Berechtigungen, Workflows und Best Practices.
# [[Prompt Engineering]]: Die Dokumentation zu Claude beschreibt, wie klare Anweisungen, Beispiele, Rollen, strukturierte Prompts und Prüfkriterien die Ergebnisse verbessern.
# [[Programmierschnittstelle|API]]: Die Claude API ermöglicht es, Claude in eigene Anwendungen einzubauen; dabei müssen Kosten, Datenschutz und Schlüsselverwaltung beachtet werden.
# [[Wikimedia Commons]]: Freie Medien wie Logos, Programmierbilder und Grafiken zu neuronalen Netzen können Lernmaterialien veranschaulichen.

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

{{BR}}
= Links =

{| align=center
{{:D-Tab}}
'''[[Programmieren mit Claude]]'''
# [[Claude (Sprachmodell)|Claude]]
# [[Anthropic]]
# [[Künstliche Intelligenz]]
# [[Large Language Model]]
# [[Prompt Engineering]]
# [[Claude Code]]
# [[Softwareentwicklung]]
# [[Debugging]]
# [[Refactoring]]
# [[Test (Software)|Softwaretest]]
# [[Git]]
# [[Code-Review]]
# [[Programmierschnittstelle|API]]
# [[Datenschutz]]
# [[IT-Sicherheit]]
|}

[[Kategorie:Informatik]]
[[Kategorie:Programmieren]]
[[Kategorie:Künstliche Intelligenz]]
[[Kategorie:Medienbildung]]
[[Kategorie:Softwareentwicklung]]
[[Kategorie:Berufliche Bildung]]
[[Kategorie:Studium]]
[[Kategorie:Sekundarstufe II]]
[[Kategorie:Klasse 9-10]]

{{BR}}
= aiMOOC-Projekte =
[[Kategorie:AI_MOOC]] [[Kategorie:GPT aiMOOC]]
{{MT}}

Programmieren mit Claude - Versionsgeschichte

Glanz: aiMOOC über GPT aiMOOC Action erstellt