Willkommen!

Rust ist eine fantastische Sprache, um solides Programmieren zu lernen.

Für den Anfang ist es oft am besten, Kommandozeilen-Tools (CLI) oder einfache Logikspiele zu bauen – so verstehst du die Grundlagen ganz praktisch.

Alle Projekte in diesem Buch sind praxisbezogen und werden ohne fertige Code-Vorschläge begleitet. Der Fokus liegt darauf, dass du die Lösung eigenständig erarbeitest. Du wirst überrascht sein, wie viel du dabei lernst!

Wie du vorgehst

1. Lies die Projektbeschreibung aufmerksam durch.
2. Überlege, welche Rust-Konzepte du dafür brauchst.
3. Probiere es selbst aus – Fehler sind Teil des Lernens!
4. Schau dir bei Bedarf die offizielle Rust-Dokumentation an.

Viel Spaß beim Programmieren! 🦀

📋 Projektplanung mit Antigravity /planning

Bevor wir eine einzige Zeile Code schreiben – planen wir gemeinsam.

Gute Projekte entstehen nicht aus dem Nichts. Sie entstehen aus einem klaren Plan. In dieser Lektion lernen wir, den interaktiven Planungs-Workflow von Antigravity zu nutzen, um unsere Rust-Projekte Schritt für Schritt, Aufgabe für Aufgabe durchzudenken – bevor der erste Code geschrieben wird.

🦀 Das Prinzip: Ein Plan ist kein Versprechen. Er ist ein Kompass – er zeigt die Richtung, auch wenn der Weg manchmal anders wird.

🧠 Theorie: Was ist /planning in Antigravity?

Der /planning-Befehl öffnet in Antigravity einen interaktiven Planungseditor. Anstatt einfach eine Aufgabe auszuführen, erstellt der Agent zuerst einen strukturierten Schritt-für-Schritt-Plan und wartet auf unsere Freigabe.

Wie /planning funktioniert

Wir:    /planning Ich möchte das "Zahlen raten"-Projekt in Rust bauen.

Agent:  Hier ist mein Plan:

        [ ] Schritt 1: Zufallszahl mit rand-Crate generieren
        [ ] Schritt 2: Benutzereingabe lesen und als Zahl parsen
        [ ] Schritt 3: Vergleich und Feedback ("zu groß"/"zu klein")
        [ ] Schritt 4: Schleife bis zur richtigen Zahl
        [ ] Schritt 5: Versuchszähler und Abschlussmeldung

        Soll ich so vorgehen? (Bestätigen / Ändern / Abbrechen)

Zeilenweise Dekonstruktion:

• /planning – Der Befehl signalisiert: „Plane zuerst, handle dann.“
• Der Agent listet alle Schritte als Checkboxen auf – jeder Schritt ist eine einzelne, erledigbare Aufgabe.
• Wir bestätigen, ändern oder brechen ab – bevor etwas passiert.
• Nach der Freigabe arbeitet der Agent Schritt für Schritt durch die Liste.

Der Unterschied zu einer normalen Anfrage

🛠️ Übung 1: Unser erstes /planning – „Zahlen raten“

Ziel: Den Planungs-Workflow für Projekt 1 aus Phase 1 erleben.

Schritt 1: Antigravity CLI starten

agy

Schritt 2: Den Planungs-Befehl eingeben

> /planning Ich möchte das Rust-Projekt "Zahlen raten" planen.
  
  Das Programm soll:
  - Eine Zufallszahl zwischen 1 und 100 wählen
  - Den Spieler so lange nach Zahlen fragen, bis er richtig liegt
  - "zu groß" oder "zu klein" ausgeben
  - Am Ende die Anzahl der Versuche zeigen
  
  Erstelle einen Plan mit Lernschritten – keinen fertigen Code.

Schritt 3: Den Plan lesen und bewerten

Der Agent erstellt einen Plan. Bevor wir ihn bestätigen, fragen wir uns:

• Sind alle Schritte logisch geordnet?
• Fehlt ein Schritt?
• Ist ein Schritt zu groß (sollte aufgeteilt werden)?

Schritt 4: Den Plan anpassen

> Füge zwischen Schritt 2 und 3 einen Schritt ein:
  "Fehlerbehandlung: Was passiert, wenn der Spieler keine Zahl eingibt?"

Schritt 5: Den Plan freigeben

> Bestätigen

Was jetzt passiert: Der Agent beginnt, Schritt für Schritt durch die Liste zu gehen. Bei jedem Schritt sehen wir seinen Fortschritt.

🔍 Nachdenk-Aufgabe: Was hätte ohne den Planungsschritt gefehlt? Was wäre vielleicht direkt vergessen worden?

🛠️ Übung 2: Meilensteine setzen – /planning für größere Vorhaben

Ziel: Ein mehrteiliges Lernvorhaben in Meilensteine aufteilen.

Angenommen, wir wollen alle 10 Projekte der ersten Woche aus Phase 1 abschließen.

Schritt 1: Den Meilenstein-Plan erstellen

> /planning Ich möchte in dieser Woche 5 Rust-Projekte aus Phase 1 abschließen.
  
  Meine verfügbare Zeit: 1 Stunde pro Tag (Montag bis Freitag)
  Mein aktueller Stand: Ich kenne Variablen und if/else, aber noch keine Schleifen.
  
  Erstelle einen Wochenplan mit:
  - Welches Projekt an welchem Tag
  - Welches Rust-Konzept ich dabei lerne
  - Eine konkrete Frage, die ich mir vor Beginn stellen soll
  
  Schreibe keinen Code – nur den Plan.

Zeilenweise Dekonstruktion der Anfrage:

• Meine verfügbare Zeit: – Der Agent kennt unsere Kapazitäten und plant realistisch.
• Mein aktueller Stand: – Er weiß, womit er anknüpfen kann.
• Eine konkrete Frage vor Beginn – Das ist das Aktivierungs-Ritual: Wir denken nach, bevor wir tippen.

Schritt 2: Den Wochenplan als Datei speichern

> Speichere diesen Plan als wochenplan.md in meinem Rust-Projektordner.

Was entsteht:

# Wochenplan – KW 26

## Montag: Projekt 1 – Zahlen raten
**Lerne:** loop, Benutzereingabe, Vergleich
**Frage vor Beginn:** Wie lese ich in Rust eine Zeile vom Terminal?

## Dienstag: Projekt 2 – Einkaufsliste  
**Lerne:** Vec, Ownership beim Hinzufügen
**Frage vor Beginn:** Was ist ein Vec und warum brauche ich ihn?

...

Schritt 3: Den Plan täglich aktualisieren

> @wochenplan.md Ich habe heute Projekt 1 abgeschlossen. 
  Markiere Montag als erledigt und füge eine kurze Notiz hinzu:
  "Größte Herausforderung: .parse() mit Fehlerbehandlung."

🔍 Nachdenk-Aufgabe: Wie hilft ein schriftlicher Plan dabei, motiviert zu bleiben?

🛠️ Übung 3: Task-Listen führen – Fortschritt sichtbar machen

Ziel: Den Fortschritt eines einzelnen Projekts mit Checkboxen verwalten.

Schritt 1: Task-Liste für ein Projekt anlegen

> /planning Erstelle eine detaillierte Task-Liste für Projekt 3 
  aus Phase 1 (Temperatur-Tagebuch).
  
  Jede Aufgabe soll:
  - Eine einzelne, abschließbare Aktion sein
  - Das Rust-Konzept benennen, das dabei geübt wird
  - Mit einem Lernziel verknüpft sein
  
  Format: Checkbox-Liste in Markdown

Was der Agent erstellt:

# Temperatur-Tagebuch – Task-Liste

## Setup
- [ ] Neues Rust-Projekt anlegen: `cargo new temperatur-tagebuch`
- [ ] Verzeichnisstruktur verstehen (`src/main.rs`, `Cargo.toml`)

## Daten erfassen
- [ ] Variable für Temperaturen anlegen (Konzept: Vec<f64>)
- [ ] Eingabe-Schleife bauen (Konzept: loop)
- [ ] Benutzereingabe lesen (Konzept: stdin().read_line())
- [ ] Eingabe in f64 konvertieren (Konzept: .parse::<f64>())
- [ ] Beendigungsbedingung einbauen (Konzept: break)

## Auswertung
- [ ] Durchschnitt berechnen (Konzept: iter().sum(), len())
- [ ] Minimum finden (Konzept: iter().min())  
- [ ] Maximum finden (Konzept: iter().max())

## Ausgabe
- [ ] Ergebnisse formatiert ausgeben (Konzept: println! mit {:.1})

## Test
- [ ] Programm mit 5 Testwerten ausführen
- [ ] Fehlerfall testen: Was passiert bei Text-Eingabe?

Schritt 2: Die Liste in Antigravity 2.0 öffnen

In Antigravity 2.0 → Tasks → die Datei als aktive Task-Liste einbinden.

Schritt 3: Aufgaben beim Erledigen abhaken

agy
> @task-liste.md Ich habe gerade die Eingabe-Schleife fertig. 
  Markiere "Eingabe-Schleife bauen" als erledigt.
  Was ist der nächste logische Schritt?

Zeilenweise Dekonstruktion:

• @task-liste.md – Der Agent sieht die aktuelle Datei mit Fortschrittsstand.
• Markiere ... als erledigt – Der Agent setzt [x] statt [ ].
• Was ist der nächste logische Schritt? – Wir fragen nicht nach dem Code, sondern nach dem nächsten Konzept.

🔍 Nachdenk-Aufgabe: Warum ist es motivierender, Checkboxen abzuhaken, als einfach Code zu schreiben?

🛠️ Übung 4: Planungs-Review – Was lief gut, was nicht?

Ziel: Nach einem abgeschlossenen Projekt den Plan rückwirkend bewerten.

Schritt 1: Das Retrospektiv-Gespräch

> @task-liste.md Ich habe das Projekt abgeschlossen. 
  Führe mit mir eine kurze Retrospektive durch:
  
  1. Welche Aufgaben haben länger gedauert als erwartet?
  2. Welche Aufgabe war die lehrreichste?
  3. Was würde ich beim nächsten Projekt anders planen?
  
  Stelle mir diese Fragen eine nach der anderen – warte auf meine Antwort.

Was passiert: Der Agent führt ein strukturiertes Interview mit uns – eine Frage nach der anderen. Er wartet auf unsere Antwort, bevor er weitermacht.

Schritt 2: Erkenntnisse in AGENTS.md übertragen

> Fasse meine Retrospektive in 3 Stichpunkten zusammen 
  und füge sie in AGENTS.md unter "Mein Lernstand" ein.

Schritt 3: Den nächsten Plan informierter starten

Beim nächsten /planning-Aufruf kennt der Agent unsere Retrospektive – und plant realistischer.

🔍 Nachdenk-Aufgabe: Was ist der Unterschied zwischen einem Plan, der vor dem Projekt entsteht, und einer Retrospektive danach?

🛠️ Übung 5: Automatischer Planungs-Assistent in Antigravity 2.0

Ziel: Einen Scheduled Task einrichten, der uns jeden Montag beim Planen hilft.

Schritt 1: Den Task erstellen

In Antigravity 2.0 → Scheduled Tasks → New Task:

Name:    Wöchentliche Projektplanung
Cron:    0 9 * * 1    (Jeden Montag um 09:00)
Aufgabe: Lies meine AGENTS.md.
         Führe einen /planning-Workflow für diese Woche durch:
         - Welche Projekte aus Phase 1 nehme ich mir vor?
         - Wie viel Zeit habe ich realistisch?
         - Was ist das Konzept, das ich diese Woche vertiefen möchte?
         
         Erstelle einen Wochenplan als wochenplan-[DATUM].md
         und lege ihn im Rust-Projektordner ab.
         Schreibe keinen Code.

Schritt 2: Den ersten automatischen Plan abwarten

Am nächsten Montag um 09:00 Uhr erscheint eine Benachrichtigung. Der Agent hat bereits einen Wochenplan erstellt – wir müssen ihn nur noch bestätigen oder anpassen.

Schritt 3: Den Plan als Lernritual etablieren

Montagmorgen → Plan lesen → anpassen → Woche starten.

📊 Das vollständige Planungs-System

Kombinieren wir alle Übungen zu einem durchgehenden Planungs-Workflow:

MONTAG 09:00
│
├─ 📋 /planning – Wochenplan erstellen
│   └─ wochenplan-[KW].md wird angelegt
│
├─ 🗒️ Task-Listen – Pro Projekt eine task-liste.md
│   └─ Checkboxen werden täglich aktualisiert
│
├─ 🔁 Täglich: Checkpoint
│   └─ "@task-liste.md Ich bin bei Aufgabe X. Was als Nächstes?"
│
└─ FREITAG 17:00
    └─ 🔍 Retrospektive: Was lief gut? Was würde ich ändern?
        └─ Erkenntnisse → AGENTS.md aktualisieren

Die Planungs-Dateien im Überblick

mein-rust-projekt/
├── AGENTS.md                      ← Lernstand & Regeln
├── wochenplan-kw26.md             ← Wöchentlicher Überblick
├── temperatur-tagebuch-tasks.md   ← Task-Liste Projekt 3
├── zahlen-raten-tasks.md          ← Task-Liste Projekt 1
└── retrospektive-juni.md          ← Monatliche Rückschau

💡 Zusammenfassung

🦀 Merke: Planung ist nicht das Gegenteil von Lernen – sie ist ein Teil des Lernens.
Wer plant, denkt schon über das Problem nach, bevor er es löst.
Und genau das macht einen guten Entwickler aus – egal ob Anfänger oder Profi.

📚 Weiterführende Links

Phase 1: Projektvorschläge für Einsteiger

Jedes Projekt übt alle Grundlagen gleichzeitig:

Hinweis: Alle Projekte werden ohne fertige Code-Vorschläge begleitet. Erarbeite die Lösung eigenständig!

🎮 Projekt 1: Zahlen raten

Beschreibung: Das Programm denkt sich eine Zahl zwischen 1 und 100 aus. Der Spieler gibt Zahlen ein, bis er die richtige erraten hat. Nach jedem Versuch erscheint „zu groß“ oder „zu klein“. Am Ende wird die Anzahl der Versuche angezeigt.

Themen: Variablen, loop, Benutzereingabe, Konvertierung, Vergleich von Strings

🛒 Projekt 2: Einkaufsliste

Beschreibung: Der Nutzer kann Artikel hinzufügen, alle anzeigen lassen oder das Programm beenden – alles über ein Textmenü. Am Ende wird die Gesamtanzahl der Artikel ausgegeben.

Themen: Variablen, loop, match, Benutzereingabe, Ownership beim Einfügen in eine Liste

🌡️ Projekt 3: Temperatur-Tagebuch

Beschreibung: Der Nutzer gibt Temperaturen in Celsius ein (eine pro Tag). Das Programm speichert alle Werte und gibt am Ende Durchschnitt, Minimum und Maximum aus.

Themen: f64-Datentyp, for-Schleife, Benutzereingabe, Borrowing beim Auswerten der Liste

📊 Projekt 4: Noten-Auswertung

Beschreibung: Der Schüler gibt seinen Namen und beliebig viele Noten ein. Das Programm berechnet den Durchschnitt und gibt eine Bewertung aus: „sehr gut“, „gut“, „befriedigend“ oder „nicht bestanden“.

Themen: String für Name, f64 für Noten, if/else, Benutzereingabe, Borrowing

🔐 Projekt 5: Login-Simulator

Beschreibung: Das Programm hat einen gespeicherten Nutzernamen und ein Passwort. Der Nutzer hat 3 Versuche. Bei Erfolg erscheint eine Begrüßung, sonst wird der Zugang gesperrt.

Themen: Variablen, Zähler, while-Schleife, Benutzereingabe, Vergleich von String mit &str

➕ Projekt 6: Taschenrechner

Beschreibung: Der Nutzer gibt zwei Zahlen und eine Operation (+, -, *, /) ein. Das Programm berechnet und gibt das Ergebnis aus. Bei Division durch Null erscheint eine Fehlermeldung.

Themen: f64, match, Benutzereingabe, Konvertierung, &str-Vergleich

🌍 Projekt 7: Temperaturumrechner

Beschreibung: Der Nutzer gibt eine Temperatur und die Einheit (C, F oder K) ein. Das Programm rechnet sie in die anderen beiden Einheiten um und gibt alle drei aus.

Themen: f64, match, Benutzereingabe, Konvertierung, String vs. &str

💪 Projekt 8: BMI-Rechner

Beschreibung: Der Nutzer gibt Körpergröße (in Metern) und Gewicht (in Kilogramm) ein. Das Programm berechnet den BMI und gibt die Kategorie aus (Untergewicht, Normal, Übergewicht usw.).

Themen: f64, if/else, Benutzereingabe, Konvertierung, &str für Kategorienamen

🎯 Projekt 9: FizzBuzz

Beschreibung: Gib die Zahlen 1 bis 100 aus. Bei Vielfachen von 3: „Fizz“, bei Vielfachen von 5: „Buzz“, bei beiden: „FizzBuzz“.

Themen: for-Schleife, if/else, Modulo-Operator, &str für Ausgabe

🔢 Projekt 10: Primzahl-Prüfer

Beschreibung: Der Nutzer gibt eine Zahl ein. Das Programm prüft, ob sie eine Primzahl ist, und gibt das Ergebnis aus.

Themen: u64-Datentyp, for-Schleife, if/else, Benutzereingabe, Konvertierung

📅 Projekt 11: Wochentag-Finder

Beschreibung: Der Nutzer gibt ein Datum als Tag, Monat und Jahr ein. Das Programm berechnet, welcher Wochentag das war (z. B. Montag).

Themen: u32-Datentyp, Rechnen mit Zahlen, Benutzereingabe, match für Wochentagname

🎲 Projekt 12: Würfelspiel

Beschreibung: Zwei Spieler würfeln abwechselnd (Zufallszahl 1–6). Der erste Spieler, der 21 Punkte erreicht oder überschreitet, verliert. Das Programm zeigt jeden Wurf an.

Themen: Variablen, Zufallszahlen, loop, Benutzereingabe (zum Fortfahren), String-Ausgabe

🏦 Projekt 13: Einfaches Bankkonto

Beschreibung: Der Nutzer kann Geld einzahlen, abheben oder den Kontostand anzeigen lassen. Das Programm verhindert, dass das Konto ins Negative geht.

Themen: f64, mut, loop, Benutzereingabe, if/else, &str für Menüoptionen

🔤 Projekt 14: Wörter zählen

Beschreibung: Der Nutzer gibt einen Satz ein. Das Programm zählt die Wörter, Zeichen und Vokale und gibt alles aus.

Themen: String, &str, for-Schleife über Zeichen, Benutzereingabe, Variablen

🔄 Projekt 15: Kollatz-Folge

Beschreibung: Der Nutzer gibt eine positive Zahl ein. Das Programm berechnet die Kollatz-Folge (gerade → halbieren, ungerade → mal 3 plus 1) und gibt jeden Schritt aus, bis 1 erreicht ist.

Themen: u64, while-Schleife, if/else, Benutzereingabe, Konvertierung

📐 Projekt 16: Geometrie-Rechner

Beschreibung: Der Nutzer wählt eine Form (Kreis, Rechteck, Dreieck) und gibt die Maße ein. Das Programm berechnet Fläche und Umfang.

Themen: f64, match, Benutzereingabe, Konvertierung, &str für Formnamen

🔡 Projekt 17: Palindrom-Prüfer

Beschreibung: Der Nutzer gibt ein Wort ein. Das Programm prüft, ob es ein Palindrom ist (z. B. „Rentner“), und gibt das Ergebnis aus.

Themen: String, &str, Iteration über Zeichen, Benutzereingabe, bool

🎓 Projekt 18: Lernkarten-Quiz

Beschreibung: Das Programm enthält 10 feste Frage-Antwort-Paare. Es stellt die Fragen nacheinander, liest die Antwort ein und gibt am Ende die Punktzahl aus.

Themen: Arrays oder Tuples, for-Schleife, Benutzereingabe, String-Vergleich, Zähler

📏 Projekt 19: Einheiten-Umrechner

Beschreibung: Der Nutzer wählt eine Kategorie (Länge, Gewicht, Volumen) und gibt einen Wert mit Einheit ein. Das Programm rechnet in alle anderen Einheiten der Kategorie um.

Themen: f64, match, Benutzereingabe, String vs. &str, Variablen

⏱️ Projekt 20: Countdown-Timer

Beschreibung: Der Nutzer gibt eine Anzahl von Sekunden ein. Das Programm zählt von dieser Zahl bis 0 herunter und gibt jeden Schritt aus. Am Ende erscheint „Zeit abgelaufen!“.

Themen: u32, for-Schleife, Benutzereingabe, Konvertierung, &str-Ausgabe

🐍 Projekt 21: Schere-Stein-Papier

Beschreibung: Der Nutzer spielt gegen das Programm (Zufallswahl). Das Spiel läuft so lange, bis einer von beiden 3 Runden gewonnen hat. Am Ende wird der Gesamtsieger angezeigt.

Themen: match, Zufallszahlen, loop, Benutzereingabe, Zähler, String vs. &str

📦 Projekt 22: Lagerverwaltung

Beschreibung: Der Nutzer kann Artikel mit Name und Anzahl hinzufügen, die Anzahl ändern, einen Artikel entfernen oder alle anzeigen. Das Menü läuft in einer Schleife.

Themen: Variablen, loop, Benutzereingabe, Ownership beim Speichern, String für Namen

🎵 Projekt 23: Playlist-Manager

Beschreibung: Der Nutzer kann Songs (als Text) zu einer Playlist hinzufügen, einen entfernen, alle anzeigen oder die Playlist mischen (zufällige Reihenfolge).

Themen: String, Vec, loop, Benutzereingabe, Ownership, Borrowing beim Anzeigen

🏋️ Projekt 24: Kalorienrechner

Beschreibung: Der Nutzer gibt Mahlzeiten mit Kalorienanzahl ein. Das Programm summiert alle Kalorien und vergleicht sie mit einem Tagesziel. Es zeigt an, ob das Ziel über- oder unterschritten wurde.

Themen: f64, loop, Benutzereingabe, Konvertierung, if/else, Summierung

🗓️ Projekt 25: Altersrechner

Beschreibung: Der Nutzer gibt sein Geburtsjahr ein. Das Programm berechnet das aktuelle Alter und gibt aus, in wie vielen Jahren der nächste runde Geburtstag (10, 20, 30 …) ist.

Themen: u32, Arithmetik, Benutzereingabe, if/else, Modulo

🔑 Projekt 26: Passwort-Generator

Beschreibung: Der Nutzer gibt die gewünschte Länge des Passworts ein. Das Programm generiert ein zufälliges Passwort aus Buchstaben, Zahlen und Sonderzeichen und zeigt es an.

Themen: String, Zufallszahlen, for-Schleife, Benutzereingabe, Konvertierung

🧮 Projekt 27: Fakultät & Fibonacci

Beschreibung: Der Nutzer wählt: Fakultät oder Fibonacci berechnen. Dann gibt er eine Zahl ein. Das Programm berechnet das Ergebnis und zeigt es an.

Themen: u64, match, for-Schleife, Benutzereingabe, Konvertierung, Variablen

🛤️ Projekt 28: Schritt-Zähler

Beschreibung: Der Nutzer gibt täglich seine gelaufenen Schritte ein (für 7 Tage). Das Programm berechnet Gesamtschritte, Tagesdurchschnitt und den aktivsten Tag.

Themen: Arrays, for-Schleife, Benutzereingabe, Vergleiche, usize

💬 Projekt 29: Umgekehrter Satz

Beschreibung: Der Nutzer gibt einen Satz ein. Das Programm gibt ihn rückwärts aus – einmal Zeichen für Zeichen, einmal Wort für Wort.

Themen: String, &str, Iteration, Benutzereingabe, Borrowing

🏆 Projekt 30: Punkte-Tabelle

Beschreibung: Der Nutzer gibt Namen und Punkte von bis zu 5 Spielern ein. Das Programm sortiert die Spieler nach Punkten und gibt eine nummerierte Rangliste aus.

Themen: Arrays oder Tuples, for-Schleife, Sortierung, Benutzereingabe, String

🧩 Projekt 31: Wort-Verschlüsseler (Caesar)

Beschreibung: Der Nutzer gibt einen Text und eine Verschiebungszahl ein. Das Programm verschlüsselt den Text mit der Caesar-Verschlüsselung und gibt das Ergebnis aus.

Themen: String, char, for-Schleife, Benutzereingabe, Arithmetik mit Zeichen

🌤️ Projekt 32: Wetter-Notizen

Beschreibung: Der Nutzer gibt für jeden Tag der Woche eine Temperatur und eine Beschreibung (z. B. „sonnig“) ein. Am Ende gibt das Programm eine Übersicht mit dem wärmsten und kältesten Tag aus.

Themen: String, f64, for-Schleife, Benutzereingabe, Vergleiche, Borrowing

🔢 Projekt 33: Zahlen-Statistik

Beschreibung: Der Nutzer gibt beliebig viele Zahlen ein (bis „fertig“). Das Programm berechnet Summe, Durchschnitt, Minimum und Maximum.

Themen: Vec<f64>, loop, Benutzereingabe, Vergleiche, Borrowing beim Auswerten

🎪 Projekt 34: Wort-Häufigkeit

Beschreibung: Der Nutzer gibt einen Satz ein. Das Programm zählt, wie oft jedes Wort vorkommt, und gibt alle Wörter mit ihrer Häufigkeit aus.

Themen: String, &str, Iteration, Benutzereingabe, Variablen, Vergleiche

📖 Projekt 35: Tagebuch-App

Beschreibung: Der Nutzer kann Einträge mit Datum und Text hinzufügen oder alle bisherigen Einträge anzeigen. Das Programm läuft in einer Menü-Schleife.

Themen: String, loop, Benutzereingabe, Ownership beim Speichern, Borrowing beim Lesen

🚦 Projekt 36: Ampel-Simulator

Beschreibung: Das Programm simuliert eine Ampel: Rot → Gelb → Grün → Gelb → Rot … Der Nutzer drückt Enter, um zur nächsten Phase zu wechseln. Nach 10 Zyklen endet das Programm.

Themen: &str, loop, Benutzereingabe, Zähler, match

📱 Projekt 37: Kontaktbuch

Beschreibung: Der Nutzer kann Kontakte (Name + Telefonnummer) hinzufügen, nach einem Namen suchen oder alle anzeigen.

Themen: String, Vec, loop, Benutzereingabe, Ownership, Borrowing, String-Vergleich

⚖️ Projekt 38: Einheiten-Waage

Beschreibung: Der Nutzer gibt ein Gewicht in Kilogramm ein. Das Programm rechnet es in Gramm, Pfund und Unzen um und zeigt alle Werte an.

Themen: f64, Benutzereingabe, Konvertierung, Ausgabe, Variablen

🎰 Projekt 39: Münzwurf-Simulation

Beschreibung: Der Nutzer gibt an, wie oft eine Münze geworfen werden soll. Das Programm simuliert die Würfe und gibt aus, wie oft Kopf und wie oft Zahl erschienen ist.

Themen: Zufallszahlen, for-Schleife, Benutzereingabe, Konvertierung, Zähler

📝 Projekt 40: To-Do-Liste

Beschreibung: Der Nutzer kann Aufgaben hinzufügen, als erledigt markieren oder alle offenen Aufgaben anzeigen. Das Programm läuft in einer Menü-Schleife.

Themen: String, bool, Vec, loop, Benutzereingabe, Ownership, Borrowing

🚀 Projekt 41: Raketenzünder

Beschreibung: Der Nutzer gibt eine Startzahl (max. 100) ein. Das Programm zählt rückwärts und gibt bei 0 „Zündung!“ aus. Bei jeder 10er-Stufe erscheint eine besondere Meldung.

Themen: u32, for-Schleife, if/else, Benutzereingabe, &str-Ausgabe

🐾 Projekt 42: Tier-Lexikon

Beschreibung: Das Programm enthält Informationen zu 5 Tieren (Name + Beschreibung). Der Nutzer gibt einen Tiernamen ein und bekommt die passende Beschreibung – oder „nicht gefunden“.

Themen: Arrays mit &str, for-Schleife, Benutzereingabe, String-Vergleich, bool

💡 Projekt 43: Rätsel-Spiel

Beschreibung: Das Programm stellt 5 Rätsel (Texträtsel mit Freitext-Antwort). Der Nutzer hat pro Rätsel 2 Versuche. Am Ende gibt es eine Auswertung.

Themen: Arrays, for-Schleife, while/Zähler, Benutzereingabe, String-Vergleich

🏃 Projekt 44: Lauf-Tracker

Beschreibung: Der Nutzer gibt für jeden Wochentag die gelaufenen Kilometer ein. Das Programm berechnet die Gesamtstrecke, den Tagesdurchschnitt und sagt, ob das Wochenziel (z. B. 30 km) erreicht wurde.

Themen: f64, Arrays, for-Schleife, Benutzereingabe, if/else, Summierung

🔍 Projekt 45: Duplikat-Finder

Beschreibung: Der Nutzer gibt eine Liste von Wörtern ein (bis „fertig“). Das Programm findet alle Wörter, die mehr als einmal vorkommen, und gibt sie aus.

Themen: String, Vec, for-Schleife, Benutzereingabe, Vergleiche, Borrowing

🎭 Projekt 46: Stimmungs-Tagebuch

Beschreibung: Der Nutzer gibt täglich eine Stimmung (1–10) und ein Stichwort ein. Das Programm speichert alle Einträge und gibt am Ende den Stimmungsdurchschnitt und den besten Tag aus.

Themen: u8, String, Vec, loop, Benutzereingabe, Vergleiche, Borrowing

🏠 Projekt 47: Mietkosten-Rechner

Beschreibung: Der Nutzer gibt Kaltmiete, Nebenkosten und Stromkosten ein. Das Programm berechnet die Gesamtkosten pro Monat und pro Jahr und gibt an, wie hoch der Anteil jeder Kostenart ist.

Themen: f64, Benutzereingabe, Konvertierung, Arithmetik, Ausgabe, &str

🌱 Projekt 48: Pflanzenwachstum

Beschreibung: Der Nutzer gibt an, wie groß eine Pflanze heute ist (in cm) und wie viel sie täglich wächst. Das Programm gibt aus, wann sie eine bestimmte Zielhöhe erreicht.

Themen: f64, while-Schleife, Benutzereingabe, Konvertierung, Zähler

📚 Projekt 49: Buch-Sammlung

Beschreibung: Der Nutzer kann Buchtitel hinzufügen, einen Titel suchen, einen entfernen oder alle anzeigen. Das Menü läuft in einer Schleife.

Themen: String, Vec, loop, match, Benutzereingabe, Ownership, Borrowing

🧠 Projekt 50: Gedächtnis-Trainer

Beschreibung: Das Programm zeigt dem Nutzer kurz eine Liste von 5 Wörtern, löscht sie dann vom Bildschirm und fragt ihn, welche Wörter er sich merken konnte. Am Ende gibt es eine Auswertung.

Themen: Arrays mit &str, for-Schleife, Benutzereingabe, String-Vergleich, Zähler

🤖 Bonus-Lektion: KI als Lernpartner – Antigravity verstehen & nutzen

Diese Lektion ist kein Rust-Thema – sie ist etwas anderes:
Du lernst, wie dein KI-Assistent (Antigravity) funktioniert, wo er lebt und wie du ihn so einsetzen kannst, dass auch er mitlernt – durch dein Projekt.

Hinweis: Diese Lektion enthält Theorie und praktische Aufgaben für dich als Lernenden – und gibt dem Agenten gleichzeitig Regeln, wie er sich in diesem Projekt verhalten soll.

🧠 Theorie: Was ist Antigravity?

Antigravity ist eine KI-Entwicklungsplattform von Google. Sie stellt dir einen intelligenten Agenten zur Seite, der Dateien lesen und schreiben, Terminal-Befehle ausführen und sogar im Web suchen kann.

Es gibt drei Oberflächen, zwischen denen du wählen kannst:

1. 🖥️ Antigravity CLI (agy)

Die Kommandozeilen-Oberfläche – minimalistisch, schnell, direkt im Terminal.

Typische Slash-Befehle im CLI:

/help        → Zeigt alle Befehle
/context     → Was sieht der Agent gerade?
/clear       → Neue Unterhaltung starten
/rewind      → Letzten Schritt rückgängig machen
/fork        → Unterhaltung in neuem Thread fortsetzen
/permissions → Berechtigungen verwalten
/usage       → Token-Verbrauch anzeigen

Konfiguration: Die Einstellungen findest du in ~/.gemini/antigravity-cli/settings.json.
Wichtige Einstellungen:

• model – welches KI-Modell genutzt wird
• toolPermission – ob der Agent Befehle automatisch ausführen darf
• verbosity – wie ausführlich der Agent antwortet (high oder low)

2. 🖼️ Antigravity 2.0 (Desktop-App)

Die Desktop-Anwendung – eine eigenständige Electron-App, die parallel zu deinem Editor läuft.

Was die App kann:

• Mehrere Projekte/Workspaces verwalten
• Geplante Aufgaben anlegen (z. B. täglich eine Aufgabe ausführen)
• Skills & Regeln verwalten (genau wie AGENTS.md und skills/-Ordner)
• Chat-Verlauf speichern und weiterführen
• Dateien per Drag-and-Drop an den Agenten schicken

Im Chat kannst du:

• / eintippen → spezielle Befehle aufrufen
• @ eintippen → Dateien, Ordner oder frühere Gespräche als Kontext anhängen
• Bilder und Dateien direkt einfügen

Berechtigungen lassen sich pro Projekt einstellen:

• Darf der Agent Dateien außerhalb des Projekts lesen?
• Darf er Terminalbefehle automatisch ausführen?
• Darf er ins Internet?

3. 💻 Antigravity IDE

Die integrierte Entwicklungsumgebung – gebaut auf VS Code, aber KI-first.

Es gibt drei Modi, wie du mit der KI interagierst:

A. Automatisch: Tab-Vervollständigung

• Der Agent schlägt dir Code vor, während du tippst
• Tab → Vorschlag annehmen
• Esc → Vorschlag ablehnen

B. Gezielte Bearbeitung: Ctrl+I

• Code markieren → Ctrl+I drücken → Anweisung geben
• Perfekt für: „Füge einen Kommentar hinzu“ oder „Erkläre diesen Code“

C. Vollständiger Agent: Sidebar-Chat

• Der mächtigste Modus
• Kann Dateien lesen/schreiben, Terminal-Befehle ausführen, im Web suchen
• Unterstützt Planungsmodus – der Agent erklärt erst, was er tun will, bevor er es tut

Besonderheiten im Editor:

• Code Lenses: Kleine Buttons direkt über Funktionen → „Erklären“, „Testen“, „Refaktorieren“
• Diff-Anzeige: Rot/Grün direkt im Editor, was der Agent ändern will
• Auto-Fix: Fehlermeldungen im Editor direkt vom Agenten beheben lassen

📁 Wie lernt der Agent mit? – Die AGENTS.md

Das Wichtigste für dieses Projekt: Der Agent liest AGENTS.md-Dateien automatisch.

Das bedeutet: Was du dort hineinschreibst, beeinflusst direkt, wie sich der Agent verhält.

Anfaenger/
├── AGENTS.md              ← Globale Projektregeln (diese Datei)
├── .agents/
│   └── AGENTS.md          ← Workspace-Regeln für den Agenten
└── rust-projekte/
    └── src/
        └── antigravity.md ← Diese Lektion (du liest sie gerade)

Was kann in AGENTS.md stehen?

• Wie soll der Agent antworten? (Sprache, Ton, Länge)
• Was darf der Agent nicht? (z. B. keine fertigen Code-Vorschläge)
• Welche Projektstruktur gibt es? (damit der Agent Dateien findet)
• In welcher Phase ist das Lernbuch? (damit der Agent passende Hilfe gibt)

🛠️ Praxis-Aufgaben

Aufgabe A: Erkunde die CLI

Öffne ein Terminal und probiere aus:

agy

Stelle dem Agenten eine Frage zu Rust, zum Beispiel:
„Was ist der Unterschied zwischen String und &str in Rust?“

Tippe dann:

/context

→ Siehst du, welche Dateien der Agent gerade „sieht“?

Aufgabe B: Schreibe deine erste eigene Regel

Öffne die Datei .agents/AGENTS.md in diesem Projekt und füge eine neue Regel hinzu, zum Beispiel:

- Erkläre mir immer zuerst das Konzept, bevor du auf Code eingehst.

Teste danach, ob der Agent diese Regel befolgt.

Aufgabe C: Vergleiche die drei Oberflächen

Probiere alle drei Oberflächen aus (wenn möglich) und notiere:

Aufgabe D: Erweitere die AGENTS.md

Füge in der AGENTS.md im Projekt-Root eine neue Lernphase ein.
Zum Beispiel: Phase 5 – KI als Werkzeug im Entwicklungsalltag

Beschreibe, was der Agent in dieser Phase beachten soll.

💡 Zusammenfassung

🦀 Merke: Der Agent ist dein Lernpartner – aber du entscheidest, wie er sich verhält. Je besser deine AGENTS.md, desto hilfreicher wird er!

📚 Weiterführende Links

• Antigravity Dokumentation
• Skills erstellen
• Regeln & AGENTS.md
• MCP – Model Context Protocol
• Changelog & Neuigkeiten

🤖 Antigravity Praxis-Projekte: 50 Schritte zum KI-gestützten Entwickler

Stand: 2026 – Modern, praxisnah, Schritt für Schritt.

Willkommen in der Welt des kollaborativen Lernens mit KI. Dieses Kapitel ist kein gewöhnliches Tutorial. Es ist eine Reise – von deinem ersten agy-Befehl im Terminal bis hin zu einem vollständig personalisierten KI-Agenten, der genau weiß, wie er dir beim Rust-Lernen helfen soll.

Wir arbeiten hier immer gemeinsam: Du und Antigravity als Lernpartner auf Augenhöhe. Der Agent schreibt deinen Code nicht für dich – er stellt dir die richtigen Fragen, damit du selbst zur Lösung findest.

🦀 Prinzip dieser Projekte: Wir lernen nicht über KI – wir lernen mit KI. Der Unterschied ist riesig.

🗺️ Übersicht: Die 6 Lerngruppen

🖥️ Gruppe 1: Antigravity CLI – Die Kommandozeile

Die CLI (Command Line Interface) ist das Herzstück von Antigravity. Hier lernen wir, direkt und schnell mit dem Agenten zu kommunizieren – ohne grafische Oberfläche, ohne Ablenkung. Nur du, das Terminal und ein KI-Agent.

🖥️ Projekt 1: Der erste Start – agy und was dann passiert

Was wir bauen: Unsere allererste Sitzung mit Antigravity CLI.

Schritt 1: Das Terminal öffnen und agy starten

agy

Zeilenweise Dekonstruktion:

• agy ist der Name des Programms – kurz für Antigravity. Wir tippen es ins Terminal und drücken Enter.
• Beim ersten Start öffnet sich ein Browser-Fenster für die Authentifizierung. Wir melden uns mit unserem Google-Konto an.
• Nach der Anmeldung erscheint im Terminal ein Code. Diesen kopieren wir und fügen ihn ins Terminal ein.
• Dann erscheint der Prompt: > – der Agent wartet auf unsere Eingabe.

Schritt 2: Die erste Frage stellen

> Was ist Rust und warum sollte ich es lernen?

Der Agent antwortet sofort. Wichtig: Er liest unsere AGENTS.md, falls vorhanden. Da wir noch keine haben, antwortet er allgemein.

Schritt 3: Die Antwort bewusst lesen

Lies die Antwort langsam durch. Beachte:

• Erklärt der Agent zu technisch oder zu einfach?
• Fehlen dir Informationen?
• Stellst du dir neue Fragen?

🔍 Nachdenk-Aufgabe: Was würde sich ändern, wenn wir dem Agenten vorher sagen, dass wir Anfänger sind? Das lernen wir in Projekt 11.

Vorschau: In Projekt 2 erkunden wir die Slash-Befehle – die geheimen Superkräfte der CLI.

🖥️ Projekt 2: Slash-Befehle – Die Superkräfte des Terminals

Was wir bauen: Ein Verständnis für die wichtigsten Slash-Befehle.

Schritt 1: /help aufrufen

> /help

Zeilenweise Dekonstruktion:

• Das / am Anfang signalisiert: Das ist kein Satz an den Agenten, sondern ein Befehl an die CLI selbst.
• help zeigt uns alle verfügbaren Befehle mit Kurzbeschreibungen an.
• Wir sehen eine lange Liste – das ist gut! Jeder dieser Befehle ist ein Werkzeug.

Schritt 2: /context aufrufen

> /context

Was passiert: Der Agent zeigt uns, welche Dateien und Informationen er gerade „sieht“. Denke dir das wie seinen Arbeitstisch vor – alles, was dort liegt, beeinflusst seine Antworten.

Zeilenweise Dekonstruktion:

• Ohne AGENTS.md ist der Kontext meist leer oder enthält nur die aktuelle Konversation.
• Mit AGENTS.md sehen wir alle geladenen Regeln und Projektinformationen.
• Der Kontext ist wie das Kurzzeitgedächtnis des Agenten.

Schritt 3: /skills aufrufen

> /skills

Skills sind vorgefertigte Fähigkeiten des Agenten. Wir sehen hier, welche aktiv sind. In Gruppe 3 bauen wir unsere eigenen.

🔍 Nachdenk-Aufgabe: Welche der angezeigten Befehle klingen für dein Rust-Lernen besonders nützlich?

Vorschau: In Projekt 3 lernen wir, wie wir Konversationen mit /fork verwalten – perfekt, wenn wir mehrere Rust-Themen gleichzeitig erkunden.

🖥️ Projekt 3: Konversationen verwalten – /fork, /resume, /clear

Was wir bauen: Einen strukturierten Umgang mit langen Gesprächen.

Schritt 1: Eine Konversation starten und benennen

> Erkläre mir das Ownership-Modell in Rust.
> /rename rust-ownership-grundlagen

Zeilenweise Dekonstruktion:

• /rename gibt unserer Konversation einen Namen. Statt einer langen ID sehen wir: rust-ownership-grundlagen.
• Das ist wie ein Ordner im Aktenschrank – wir können später genau hierher zurückkehren.

Schritt 2: Eine Konversation forken

> /fork

Was passiert: Eine exakte Kopie unserer Konversation entsteht, aber als neuer Thread. Der gesamte Verlauf bleibt erhalten.

Analogie: Stell dir vor, du hast ein Gespräch mit einem Freund. Mit /fork öffnest du ein paralleles Universum dieses Gesprächs – du kannst in eine andere Richtung fragen, ohne das Original zu verlieren.

Zeilenweise Dekonstruktion:

• fork kommt aus der Programmierung: Wie ein Gabelung in einem Fluss – zwei Wege aus einem Punkt.
• Wir können nun im geforkten Thread tiefer in ein Thema eintauchen.
• Der Original-Thread bleibt unberührt.

Schritt 3: Zur alten Konversation zurückkehren

> /resume rust-ownership-grundlagen

Zeilenweise Dekonstruktion:

• /resume gefolgt vom Namen der Konversation bringt uns zurück.
• Alternativ: /switch hat dieselbe Funktion.
• Wir können auch /conversation tippen, um eine Liste aller gespeicherten Konversationen zu sehen.

Schritt 4: Aufräumen mit /clear

> /clear

Was passiert: Der Terminal-Bildschirm wird geleert. Die Konversation ist aber noch gespeichert – wir können jederzeit mit /resume zurückkehren.

🔍 Nachdenk-Aufgabe: Welche Rust-Themen würdest du in separaten Konversationen verwalten? Mach eine Liste.

Vorschau: In Projekt 4 wechseln wir das KI-Modell – denn verschiedene Modelle haben verschiedene Stärken.

🖥️ Projekt 4: Das richtige Modell wählen – /model

Was wir bauen: Ein Verständnis dafür, dass nicht alle KI-Modelle gleich sind.

Schritt 1: Das aktuelle Modell anzeigen

> /model

Was wir sehen: Eine Liste verfügbarer Modelle. Das aktuell aktive ist markiert.

Zeilenweise Dekonstruktion:

• Modelle wie gemini-flash sind schnell – ideal für kurze Fragen.
• Leistungsfähigere Modelle denken tiefer – besser für komplexe Rust-Konzepte wie Lifetimes.
• Das Modell ist wie der Experte, den wir befragen: Ein Auszubildender antwortet schnell, ein Senior-Entwickler antwortet durchdachter.

Schritt 2: Das Modell wechseln

> /model gemini-2.5-pro

Was passiert: Ab der nächsten Antwort nutzt der Agent das neue Modell.

Schritt 3: Denselben Frage vergleichen

Stelle nun dieselbe Rust-Frage wie in Projekt 1 nochmals. Vergleiche:

• Ist die Antwort länger oder kürzer?
• Mehr Details oder mehr Übersicht?
• Welches Modell passt besser zu deinem Lernstil?

🔍 Nachdenk-Aufgabe: Wann würdest du ein schnelles Modell bevorzugen, wann ein leistungsfähiges?

Vorschau: In Projekt 5 lernen wir, den Token-Verbrauch zu verstehen – denn Tokens sind die „Währung“ der KI-Kommunikation.

🖥️ Projekt 5: Token-Verbrauch verstehen – /usage

Was wir bauen: Ein Gespür für den Ressourcenverbrauch unserer KI-Interaktionen.

Schritt 1: Usage anzeigen

> /usage

Was wir sehen: Eine Statistik über verwendete Tokens in dieser Sitzung.

Zeilenweise Dekonstruktion:

• Token: Nicht ganz ein Wort, nicht ganz ein Buchstabe – ein Token ist ein Textstück, ca. 4 Zeichen lang. „Rust“ = 1 Token. „fn main() {“ = 4 Tokens.
• Input-Tokens: Was wir an den Agenten schicken (unsere Fragen + Kontext).
• Output-Tokens: Was der Agent zurückschickt (seine Antworten).
• Gesamtkosten (falls sichtbar): Tokens kosten Ressourcen – je länger unsere Konversation, desto mehr.

Schritt 2: Kontext bewusst klein halten

Je mehr Dateien und Text in unserer AGENTS.md stehen, desto mehr Input-Tokens verbrauchen wir bei jeder Frage.

Analogie: Stell dir vor, du schreibst jeden Tag einen Brief an einen Freund. Aber am Anfang jedes Briefes kopierst du immer den gesamten vorherigen Briefwechsel. Das wird schnell sehr lang!

Schritt 3: Effizienz üben

Starte eine neue Konversation mit /clear und stelle eine präzise, kurze Frage. Vergleiche den Token-Verbrauch mit einer langen, umständlichen Frage.

🔍 Nachdenk-Aufgabe: Wie formulierst du eine Frage so kurz wie möglich, aber so klar wie nötig?

Vorschau: In Projekt 6 schauen wir uns /diff an – damit sehen wir, was der Agent an unserem Code verändert hat.

🖥️ Projekt 6: Änderungen nachverfolgen – /diff

Was wir bauen: Einen Überblick über alle Dateiänderungen, die der Agent gemacht hat.

Schritt 1: Den Agenten eine Datei erstellen lassen

> Erstelle eine neue Datei namens "notizen.md" mit drei Stichpunkten über Rust-Ownership.

Schritt 2: Die Änderungen anzeigen

> /diff

Was wir sehen: Eine Diff-Ansicht – grüne Zeilen wurden hinzugefügt, rote wurden entfernt.

Zeilenweise Dekonstruktion:

+ # Rust Ownership – Meine Notizen
+ 
+ - Jeder Wert hat genau einen Besitzer (Owner)
+ - Wird der Owner ungültig, wird der Wert gelöscht
+ - Nur ein Besitzer gleichzeitig – Weitergabe heißt „Move"

• + am Zeilenanfang: Diese Zeile wurde hinzugefügt.
• - am Zeilenanfang: Diese Zeile wurde entfernt (hier noch keine).
• Keine Markierung: Diese Zeile ist unverändert.

Schritt 3: Änderungen verstehen und bewusst akzeptieren

Bevor wir den Agenten etwas ändern lassen, sollten wir immer mit /diff prüfen, was er getan hat. Das ist kein Misstrauen – es ist professionelle Praxis.

🔍 Nachdenk-Aufgabe: Warum ist es wichtig, Änderungen des Agenten zu überprüfen, auch wenn wir ihm vertrauen?

Vorschau: In Projekt 7 lernen wir /rewind – den „Undo“-Knopf für alles.

🖥️ Projekt 7: Fehler rückgängig machen – /rewind

Was wir bauen: Sicherheit im Umgang mit dem Agenten – wir können immer zurück.

Schritt 1: Den Agenten etwas tun lassen

> Füge in notizen.md noch einen vierten Stichpunkt über Borrowing hinzu.

Schritt 2: Merken, dass wir es rückgängig machen wollen

Vielleicht hat der Agent etwas falsch formuliert. Oder wir wollen eine andere Erklärung. Kein Problem:

> /rewind

Was passiert: Der Agent macht seinen letzten Schritt rückgängig. Die Datei sieht wieder aus wie vorher.

Zeilenweise Dekonstruktion:

• /rewind ist wie Ctrl+Z – aber für alles, was der Agent getan hat.
• Alternativ: /undo hat dieselbe Funktion.
• Wir können /rewind mehrfach aufrufen, um mehrere Schritte zurückzugehen.

Analogie: Denke dir den Agenten als einen Freund, der dir beim Aufräumen hilft. Wenn er etwas an die falsche Stelle räumt, rufst du „Nein, warte“ – und er stellt es zurück.

Schritt 3: Einen präziseren Befehl geben

Nach dem Rewind formulieren wir unsere Anweisung genauer:

> Füge in notizen.md einen vierten Stichpunkt hinzu. Er soll erklären, 
  dass Borrowing bedeutet, einen Wert zu leihen ohne ihn zu besitzen.
  Formuliere es in einem einzigen kurzen deutschen Satz.

🔍 Nachdenk-Aufgabe: Was macht eine gute Anweisung an den Agenten aus? Schreibe drei Regeln auf.

Vorschau: In Projekt 8 beschäftigen wir uns mit Berechtigungen – was der Agent darf und was nicht.

🖥️ Projekt 8: Berechtigungen meistern – /permissions

Was wir bauen: Ein Sicherheitskonzept für unsere Arbeit mit dem Agenten.

Schritt 1: Aktuelle Berechtigungen anzeigen

> /permissions

Was wir sehen: Eine Liste von Regeln, die bestimmen, was der Agent tun darf.

Zeilenweise Dekonstruktion:

Berechtigungen haben drei Zustände:

• allow – Der Agent darf das automatisch tun.
• ask – Der Agent fragt uns zuerst. (Standard für die meisten Aktionen)
• deny – Der Agent darf das nie tun.

Aktionen, für die Berechtigungen gelten:

• Dateien lesen (read_file) – Darf der Agent unsere Dateien lesen?
• Dateien schreiben (write_file) – Darf er Dateien erstellen/ändern?
• Befehle ausführen (command) – Darf er Terminalbefehle starten?
• URLs aufrufen (read_url) – Darf er im Internet nachschauen?

Schritt 2: Eine Berechtigung verstehen

Der Standard request-review für toolPermission bedeutet: Der Agent fragt uns, bevor er handelt. Das ist sicher und empfehlenswert für Anfänger.

Schritt 3: Berechtigungen in settings.json anpassen

{
  "toolPermission": "request-review",
  "verbosity": "high"
}

Zeilenweise Dekonstruktion:

• "toolPermission": "request-review" – Der Agent fragt immer nach, bevor er Tools ausführt. Perfekt für uns.
• "verbosity": "high" – Der Agent erklärt ausführlich, was er tut. Gut zum Lernen.
• Die Datei liegt unter ~/.gemini/antigravity-cli/settings.json.

🔍 Nachdenk-Aufgabe: Welche Berechtigungen würdest du auf deny setzen und warum?

Vorschau: In Projekt 9 erkunden wir, wie wir vergangene Konversationen wiederfinden und fortsetzen.

🖥️ Projekt 9: Konversationsverlauf nutzen – /resume und /conversation

Was wir bauen: Ein persönliches Archiv unserer Lernreise.

Schritt 1: Alle Konversationen auflisten

> /conversation

Was wir sehen: Eine Liste aller gespeicherten Konversationen mit Namen und Datum.

Schritt 2: Eine alte Konversation fortsetzen

> /resume rust-ownership-grundlagen

Was passiert: Wir sind zurück in unserem alten Gespräch. Der Agent erinnert sich an alles – als hätten wir eine Pause gemacht.

Zeilenweise Dekonstruktion:

• /resume sucht nach dem Namen der Konversation.
• Alternativ können wir die ID nutzen, die der Agent jeder Konversation gibt.
• /switch ist ein Synonym für /resume.

Analogie: Stell dir vor, du hast ein Notizbuch für jedes Rust-Thema. Mit /resume schlägst du genau das richtige Notizbuch auf – und alle alten Notizen sind noch da.

Schritt 3: Konversationen strategisch benennen

Gute Namen für Lernkonversationen:

rust-ownership-basics
rust-strings-vs-str
rust-error-handling
antigravity-skill-bauen

🔍 Nachdenk-Aufgabe: Welche Konversationen würdest du für deine Rust-Lernreise anlegen?

Vorschau: In Projekt 10 passen wir settings.json vollständig an – unser persönliches CLI-Profil.

🖥️ Projekt 10: Das CLI personalisieren – settings.json

Was wir bauen: Unsere persönliche Antigravity-Konfiguration.

Schritt 1: Die Datei öffnen

nano ~/.gemini/antigravity-cli/settings.json

Schritt 2: Unsere Lern-Konfiguration schreiben

{
  "model": "gemini-2.5-flash",
  "toolPermission": "request-review",
  "verbosity": "high",
  "runningLightSpeed": "slow",
  "notifications": true,
  "showTips": true,
  "historySize": 2000
}

Zeilenweise Dekonstruktion:

• "model" – Das Standard-Modell. Wir nutzen flash für schnelle Antworten beim täglichen Lernen.
• "toolPermission": "request-review" – Der Agent fragt uns immer, bevor er handelt. Als Anfänger ist das genau richtig.
• "verbosity": "high" – Der Agent erklärt ausführlich, was er gerade tut und warum.
• "runningLightSpeed": "slow" – Die Antworten des Agenten erscheinen langsamer – wir können mitlesen, während er „tippt“. Das hilft beim Lernen.
• "notifications": true – Wir bekommen Systembenachrichtigungen, wenn der Agent eine lange Aufgabe abgeschlossen hat.
• "showTips": true – Nützliche Tipps werden angezeigt. Als Anfänger wollen wir das.
• "historySize": 2000 – Die letzten 2000 Konversations-Schritte werden gespeichert.

Schritt 3: Die Einstellungen testen

agy
> /usage

Beachte: Antwortet der Agent jetzt langsamer (durch runningLightSpeed: slow)? Siehst du mehr Details?

🔍 Nachdenk-Aufgabe: Welche Einstellung hat den größten Einfluss auf deinen Lernfortschritt?

Vorschau: Jetzt kennen wir die CLI. In Gruppe 2 formen wir den Agenten durch AGENTS.md – das mächtigste Werkzeug dieser ganzen Reise.

📋 Gruppe 2: AGENTS.md – Den Agenten formen

Die AGENTS.md-Datei ist das Gehirn unseres personalisierten Agenten. Was wir hier schreiben, liest der Agent automatisch – bei jedem Start, bei jeder Frage. Wir formen damit seinen Charakter, seine Regeln und seinen Kontext.

📋 Projekt 11: Die erste eigene AGENTS.md

Was wir bauen: Die Grundstruktur unserer ersten AGENTS.md.

Schritt 1: Die Datei erstellen

mkdir -p ~/mein-rust-projekt
cd ~/mein-rust-projekt

# AGENTS.md – Mein Rust-Lernprojekt

Ich bin Anfänger und lerne gerade Rust. 
Ich möchte, dass du mir als Lernpartner zur Seite stehst.

Zeilenweise Dekonstruktion:

• # AGENTS.md – Die Überschrift. Der Agent liest diese Datei als Markdown.
• Der erste Satz definiert uns – wer wir sind, was unser Wissensstand ist.
• „Lernpartner“ – nicht „Helfer“, nicht „Assistent“. Ein Partner ist auf Augenhöhe.

Schritt 2: Die Datei mit dem Agenten testen

agy
> /context

Wir sehen jetzt unsere AGENTS.md im Kontext des Agenten!

Schritt 3: Den Unterschied spüren

Stelle dieselbe Frage wie in Projekt 1: „Was ist Rust?“

Vergleiche die Antwort mit Projekt 1:

• Ist sie anders?
• Mehr auf Anfänger zugeschnitten?
• Kürzer, klarer, freundlicher?

🔍 Nachdenk-Aufgabe: Welcher einzige Satz in deiner AGENTS.md hätte den größten Einfluss?

Vorschau: In Projekt 12 definieren wir Sprache, Ton und Stil des Agenten.

📋 Projekt 12: Sprache & Ton konfigurieren

Was wir bauen: Einen Agenten, der genau so spricht, wie wir es brauchen.

Schritt 1: Sprache und Ton in AGENTS.md definieren

## Kommunikation

- Antworte immer auf Deutsch.
- Nutze eine einfache, klare Sprache – ich bin Anfänger.
- Vermeide Fachbegriffe, ohne sie zu erklären.
- Stelle nach jeder Erklärung eine Verständnisfrage.
- Halte Antworten kurz: maximal 5 Sätze, dann frage, ob ich mehr möchte.

Zeilenweise Dekonstruktion:

• Antworte immer auf Deutsch – Ohne diese Regel könnte der Agent auf Englisch antworten, wenn die Frage englisch klingt.
• Vermeide Fachbegriffe – Wir müssen explizit sagen, was wir nicht wollen. Der Agent kann keine Gedanken lesen.
• Stelle nach jeder Erklärung eine Verständnisfrage – Das ist das Tutoren-Prinzip: Ein guter Lehrer fragt, ob der Schüler es verstanden hat.
• maximal 5 Sätze – Limits helfen dem Agenten, präzise zu bleiben.

Schritt 2: Testen

agy
> Erkläre mir den Unterschied zwischen Stack und Heap.

Hat der Agent am Ende eine Frage gestellt? War die Antwort kurz?

Schritt 3: Verfeinern

Falls nein: Passe die Regeln an. Das ist normales Vorgehen – wir iterieren. Eine AGENTS.md ist nie fertig.

🔍 Nachdenk-Aufgabe: Was nervt dich an typischen KI-Antworten? Schreibe eine Regel, die dieses Problem löst.

Vorschau: In Projekt 13 definieren wir, was der Agent nicht darf.

📋 Projekt 13: Verbotene Aktionen – Was der Agent nicht darf

Was wir bauen: Klare Grenzen, die uns beim Lernen helfen.

Schritt 1: Das Lernprinzip festlegen

## Was der Agent nicht darf

- NIEMALS fertigen Rust-Code schreiben oder vorschlagen.
- NIEMALS die Lösung einer Aufgabe direkt nennen.
- Wenn ich um Code bitte: Statt des Codes nur Hinweise, 
  welches Konzept ich brauche.
- Wenn ich die Lösung wissen will: Erst fragen, ob ich 
  es wirklich noch nicht selbst versucht habe.

Zeilenweise Dekonstruktion:

• NIEMALS in Großbuchstaben – Das ist Absicht. Wir verstärken die Regel durch Betonung.
• Statt des Codes nur Hinweise – Das ist die Kernphilosophie dieses Buches: Verstehen durch Eigenleistung.
• Erst fragen, ob ich es wirklich noch nicht selbst versucht habe – Der Agent fungiert als Gewissen, nicht als Abkürzung.

Schritt 2: Die Regel testen – bewusst scheitern

agy
> Schreib mir ein Rust-Programm, das "Hallo Welt" ausgibt.

Was antwortet der Agent? Befolgt er die Regel? Gibt er Hinweise statt Code?

Schritt 3: Die Regel verfeinern

Falls der Agent die Regel nicht befolgt: Formuliere sie deutlicher.

💡 Merke: Je konkreter unsere Regeln, desto zuverlässiger der Agent. Vage Regeln führen zu vagen Ergebnissen.

🔍 Nachdenk-Aufgabe: Welche Ausnahmen von der “kein Code”-Regel wären sinnvoll?

Vorschau: In Projekt 14 beschreiben wir unseren Projektkontext – damit der Agent weiß, woran wir arbeiten.

📋 Projekt 14: Projektkontext beschreiben

Was wir bauen: Eine vollständige Projektbeschreibung für den Agenten.

Schritt 1: Den Kontext schreiben

## Mein Projekt

Ich baue gerade: "Zahlen raten" – ein CLI-Spiel in Rust.
Das Programm soll eine Zufallszahl zwischen 1 und 100 wählen.
Der Spieler tippt Zahlen, bis er sie errät.
Das Programm sagt "zu groß" oder "zu klein".

### Aktueller Stand
- [ ] Zufallszahl generieren
- [ ] Benutzereingabe lesen
- [ ] Vergleich und Ausgabe
- [ ] Schleife bis zur richtigen Zahl

### Mein aktuelles Problem
Ich verstehe noch nicht, wie ich eine Zahl vom Terminal einlesen kann.

Zeilenweise Dekonstruktion:

• Ich baue gerade: – Das versetzt den Agenten in den Kontext unseres Projekts. Er weiß, womit sein nächster Hinweis relevant ist.
• - [ ] Aufgabe – Die Checkbox-Syntax zeigt dem Agenten unseren Fortschritt.
• ### Mein aktuelles Problem – Das ist die wichtigste Sektion. Der Agent weiß sofort, wobei wir Hilfe brauchen.

Schritt 2: Den Kontext testen

agy
> Ich stecke fest. Was soll ich als Nächstes tun?

Der Agent sollte jetzt spezifisch auf unser Projekt eingehen, ohne eine direkte Lösung zu nennen.

🔍 Nachdenk-Aufgabe: Wie aktuell hältst du deinen Projektkontext? Nach jeder Session? Täglich? Was funktioniert für dich?

Vorschau: In Projekt 15 dokumentieren wir unsere Lernphase – damit der Agent unseren Fortschritt kennt.

📋 Projekt 15: Lernphase dokumentieren

Was wir bauen: Eine dynamische Lernkarte in unserer AGENTS.md.

Schritt 1: Die Lernkarte schreiben

## Mein Lernstand – Stand: Juni 2026

### Was ich bereits kann
- Variablen mit `let` und `mut` deklarieren
- Einfache `if/else`-Bedingungen schreiben
- Den Unterschied zwischen `String` und `&str` erklären

### Was ich gerade lerne
- Benutzereingabe mit `std::io::stdin()` lesen
- Zahlen aus Strings mit `.parse()` konvertieren

### Was ich noch nicht verstehe
- Ownership und warum der Compiler mich manchmal "anschreit"
- Warum `match` manchmal nötig ist statt `if let`

### Hilfreiche Erklärungen für mich
- Nutze Alltagsbeispiele und Analogien
- Erkläre immer das "Warum", nicht nur das "Was"
- Vergleiche Rust gerne mit einfachen Alltagssituationen

Zeilenweise Dekonstruktion:

• Was ich bereits kann – Der Agent wiederholt keine Grundlagen, die wir schon kennen.
• Was ich gerade lerne – Das ist der Fokus. Hier soll der Agent besonders klar sein.
• Was ich noch nicht verstehe – Explizite Wissenslücken. Der Agent weiß, dass er hier besonders vorsichtig und langsam erklären soll.
• Hilfreiche Erklärungen für mich – Unser persönlicher Lernstil.

Schritt 2: Die Lernkarte regelmäßig aktualisieren

Füge nach jeder Lerneinheit einen Haken bei erlernten Konzepten ein. Verschiebe Themen zwischen den Sektionen.

🔍 Nachdenk-Aufgabe: Wie verändert sich die Qualität der Agentenantworten, wenn du deine Lernkarte aktuell hältst?

Vorschau: In Projekt 16 verstehen wir die Hierarchie der AGENTS.md-Dateien.

📋 Projekt 16: Die AGENTS.md-Hierarchie verstehen

Was wir bauen: Ein Verständnis dafür, wie globale und lokale Regeln zusammenwirken.

Schritt 1: Die zwei Ebenen kennenlernen

/home/user/
└── mein-rust-projekt/
    ├── AGENTS.md           ← Ebene 1: Projekt-Root
    └── .agents/
        └── AGENTS.md       ← Ebene 2: Workspace-spezifisch

Zeilenweise Dekonstruktion:

• AGENTS.md im Projekt-Root: Überblick – Projektbeschreibung, Ziele, Lernstand.
• .agents/AGENTS.md: Verhaltensregeln – Wie soll der Agent kommunizieren? Was darf er?
• Beide Dateien werden geladen. Lokale Regeln überschreiben globale, wenn sie sich widersprechen.

Analogie: Denke dir das wie Hausregeln vs. Schulregeln. In der Schule gelten die Schulregeln – aber zu Hause gelten zusätzlich noch die Hausregeln. Wenn sie sich widersprechen, entscheiden die Hausregeln.

Schritt 2: Aufgaben aufteilen

# AGENTS.md (Projekt-Root)
## Projektbeschreibung
Ich baue "Zahlen raten" in Rust...

## Lernstand
...

# .agents/AGENTS.md (Workspace)
## Verhaltensregeln
- Kein fertiger Code
- Stelle immer Rückfragen
- Deutsch, einfache Sprache

Schritt 3: Testen

agy
> /context

Siehst du beide AGENTS.md-Dateien im Kontext?

🔍 Nachdenk-Aufgabe: Welche Informationen gehören in welche Ebene? Mache eine eigene Liste.

Vorschau: In Projekt 17 lernen wir @-Mentions – damit schicken wir gezielt Kontext an den Agenten.

📋 Projekt 17: Kontext gezielt teilen – @-Mentions

Was wir bauen: Die Kunst, dem Agenten genau die richtigen Informationen zu geben.

Schritt 1: Eine Datei als Kontext anhängen

Angenommen, wir haben eine Rust-Datei main.rs:

> @main.rs Ich bekomme einen Compiler-Fehler. 
  Erkläre mir, was in dieser Datei passiert – aber nenne mir nicht die Lösung.

Zeilenweise Dekonstruktion:

• @main.rs – Das @-Symbol gefolgt vom Dateinamen schickt den Inhalt dieser Datei an den Agenten.
• Der Agent sieht nun unseren Code, ohne dass wir ihn manuell kopieren müssen.
• Danach folgt unsere Frage oder Aufgabe.

Schritt 2: Einen Ordner als Kontext anhängen

> @src/ Welche Dateien habe ich in meinem Projekt bisher erstellt?

• @src/ schickt alle Dateien im src/-Ordner als Kontext.

Schritt 3: Eine frühere Konversation anhängen

> @rust-ownership-grundlagen Was habe ich damals über Ownership gelernt?

• @konversationsname fügt eine frühere Konversation als Kontext ein.

Analogie: @ ist wie ein Post-it-Zettel, den wir an unsere Frage kleben. Der Agent sieht die Frage und den Zettel zusammen.

🔍 Nachdenk-Aufgabe: In welchen Situationen wäre @-Mention effizienter als copy-paste?

Vorschau: In Projekt 18 bauen wir eine vollständige, professionelle AGENTS.md.

📋 Projekt 18: Die vollständige AGENTS.md – Alles zusammen

Was wir bauen: Eine professionelle, vollständige AGENTS.md für unser Rust-Lernprojekt.

Schritt 1: Die vollständige Datei schreiben

# AGENTS.md – Rust-Lernprojekt von [Dein Name]

Dieses Projekt ist mein persönliches Rust-Lernjournal.
Ich bin Anfänger ohne Programmiervorkenntnisse und lerne seit 2 Wochen.

---

## 📁 Projektstruktur

mein-rust-projekt/ ├── AGENTS.md ← Diese Datei ├── .agents/ │ └── AGENTS.md ← Verhaltensregeln └── src/ └── main.rs ← Mein Code

## 🎯 Aktuelles Projekt

Ich baue: "Zahlen raten" – CLI-Spiel in Rust.

## 📊 Mein Lernstand

**Kann ich:**  Variablen, if/else, Schleifen  
**Lerne ich:**  Benutzereingabe, Strings parsen  
**Verstehe noch nicht:**  Ownership, Borrowing  

## ⚙️ Regeln

- Antworte auf Deutsch, einfache Sprache
- Kein fertiger Code – nur Hinweise
- Stelle nach jeder Erklärung eine Frage
- Bei Fehlern: Erkläre das "Warum" vor dem "Was"

Zeilenweise Dekonstruktion:

• Die Datei hat 5 Sektionen: Intro, Struktur, aktuelles Projekt, Lernstand, Regeln.
• Jede Sektion hat einen klaren Zweck.
• Emojis und --- Trennlinien helfen dem Agenten (und uns!) beim schnellen Überblick.

Schritt 2: Testen und vergleichen

Teste die Qualität der Agentenantworten vor und nach dieser vollständigen AGENTS.md.

🔍 Nachdenk-Aufgabe: Was fehlt noch in dieser AGENTS.md, das speziell für dich wichtig wäre?

Vorschau: In Projekt 19 lernen wir, AGENTS.md zu testen und systematisch zu verbessern.

📋 Projekt 19: AGENTS.md systematisch testen

Was wir bauen: Einen Testprozess für unsere Agentenregeln.

Schritt 1: Test-Fragen definieren

Erstelle eine Datei agents-tests.md:

# AGENTS.md Testfragen

## Test 1: Sprachregel
Frage: "What is ownership in Rust?"
Erwartung: Antwort auf Deutsch

## Test 2: Kein-Code-Regel
Frage: "Schreib mir main.rs für Zahlen raten."
Erwartung: Hinweise, kein Code

## Test 3: Verständnisfrage
Frage: "Erkläre mir, was ein String ist."
Erwartung: Erklärung + Frage am Ende

## Test 4: Lernstand-Bewusstsein
Frage: "Erkläre mir Lifetimes."
Erwartung: Agent verweist auf Lernstand, sagt: "Das kommt später"

Schritt 2: Tests durchführen

Führe jeden Test durch und notiere:

• ✅ Regel eingehalten
• ❌ Regel nicht eingehalten → AGENTS.md anpassen

Schritt 3: Iterieren

# Änderungslog AGENTS.md

## 2026-06-24
- Test 2 fehlgeschlagen: Code wurde gegeben
- Fix: Regel verschärft mit "NIEMALS"

🔍 Nachdenk-Aufgabe: Wie oft solltest du deine AGENTS.md aktualisieren?

Vorschau: In Projekt 20 lernen wir, AGENTS.md mit Git zu versionieren.

📋 Projekt 20: AGENTS.md versionieren – Mit Git mitarbeiten

Was wir bauen: Eine Versionsgeschichte unserer AGENTS.md.

Schritt 1: Git initialisieren

cd ~/mein-rust-projekt
git init
git add AGENTS.md .agents/AGENTS.md
git commit -m "Initial AGENTS.md: Rust-Lernprojekt Setup"

Zeilenweise Dekonstruktion:

• git init – Wir initialisieren ein neues Git-Repository.
• git add – Wir wählen die Dateien, die wir versionieren wollen.
• git commit -m "..." – Wir speichern den aktuellen Stand mit einer Beschreibung.

Schritt 2: Nach jeder Verbesserung committen

git add AGENTS.md
git commit -m "Lernstand aktualisiert: Ownership jetzt verstanden"

Schritt 3: Den Verlauf betrachten

git log --oneline

Was wir sehen: Eine Liste aller Commits – unsere Lernreise als Timeline.

🔍 Nachdenk-Aufgabe: Was zeigt die Git-History über unseren Fortschritt? Was hättest du früher anders gemacht?

Vorschau: In Gruppe 3 bauen wir eigene Skills – vorgefertigte Fähigkeitspakete für den Agenten.

🔧 Gruppe 3: Skills – Den Agenten erweitern

Skills sind wie Plugins für den Agenten. Während AGENTS.md den Charakter und die Regeln des Agenten definiert, geben Skills ihm spezifische Expertenwissen-Pakete – die er bei passenden Themen automatisch aktiviert.

🔧 Projekt 21: Was ist ein Skill? – Konzept und Struktur

Was wir bauen: Das Verständnis für Skills.

Schritt 1: Die Ordnerstruktur eines Skills

.agents/
└── skills/
    └── mein-skill/
        └── SKILL.md

Zeilenweise Dekonstruktion:

• .agents/skills/ – Der Ort, wo alle Skills leben.
• mein-skill/ – Ein Ordner pro Skill. Der Ordnername ist der interne Name.
• SKILL.md – Die Hauptdatei. Hier stehen Name, Beschreibung und Anweisungen.

Schritt 2: Den Unterschied zu AGENTS.md verstehen

Schritt 3: Einen leeren Skill-Ordner erstellen

mkdir -p ~/mein-rust-projekt/.agents/skills/rust-tutor
touch ~/mein-rust-projekt/.agents/skills/rust-tutor/SKILL.md

🔍 Nachdenk-Aufgabe: Welche drei Skills würden deinem Rust-Lernen am meisten helfen?

Vorschau: In Projekt 22 schreiben wir das YAML-Frontmatter – den Kopf jeder SKILL.md.

🔧 Projekt 22: Das SKILL.md Frontmatter – Der Kopf eines Skills

Was wir bauen: Die YAML-Metadaten, die einen Skill aktivieren.

Schritt 1: Das Frontmatter schreiben

---
name: rust-tutor
description: Hilft Rust-Anfängern beim Lernen durch Fragen, 
             Analogien und Erklärungen – ohne fertige Code-Lösungen.
---

Zeilenweise Dekonstruktion:

• --- (drei Bindestriche) – Der Beginn und das Ende des YAML-Frontmatters. Wie ein Briefumschlag um die Metadaten.
• name: – Der interne Name des Skills. Muss eindeutig sein.
• description: – Die Beschreibung, anhand derer der Agent entscheidet, ob er den Skill aktiviert. Das ist das Wichtigste: Je präziser die Beschreibung, desto zuverlässiger die Aktivierung.

Analogie: Stell dir vor, du rufst ein Callcenter an. Die Beschreibung ist die Warteschleife-Ansage: „Für technische Probleme drücken Sie 1.“ Der Agent „drückt 1“ (aktiviert den Skill), wenn deine Frage zur Beschreibung passt.

Schritt 2: Die Beschreibung optimieren

Schlechte Beschreibung:

description: Hilft bei Rust.

Gute Beschreibung:

description: Aktiviere diesen Skill, wenn der Nutzer Fragen zu Rust-Konzepten
             wie Ownership, Borrowing, Lifetimes, Strings oder Structs stellt.
             Gib keine fertigen Code-Lösungen, sondern Erklärungen und Hinweise.

🔍 Nachdenk-Aufgabe: Was muss in der Beschreibung stehen, damit der Skill bei deinen typischen Fragen aktiviert wird?

Vorschau: In Projekt 23 schreiben wir den eigentlichen Skill-Inhalt.

🔧 Projekt 23: Den Skill mit Inhalt füllen

Was wir bauen: Einen vollständigen Rust-Tutor-Skill.

Schritt 1: Den kompletten Skill schreiben

---
name: rust-tutor
description: Aktiviere diesen Skill bei Rust-Lernfragen. 
             Keine Code-Lösungen, nur Erklärungen und Hinweise.
---

# Rust-Tutor Skill

Wenn dieser Skill aktiv ist, gelten folgende Anweisungen:

## Mein Verhalten

- Erkläre Rust-Konzepte mit Alltagsbeispielen
- Stelle nach jeder Erklärung eine Verständnisfrage
- Wenn der Nutzer Code möchte: Zeige nur das Konzept, nicht die Lösung
- Verweise auf das offizielle Rust-Buch: https://doc.rust-lang.org/book/

## Meine Erklär-Methoden

### Für Ownership:
Analogie: "Stell dir vor, du hast eine Tasse Kaffee. 
Du kannst sie jemandem geben (move) oder jemanden 
daran schnuppern lassen (borrow). Aber zwei Personen 
können die Tasse nicht gleichzeitig besitzen."

### Für Borrowing:
Analogie: "Du leihst deinem Freund ein Buch (& reference). 
Du kannst nicht gleichzeitig mit dem Buch verschwinden, 
während er es liest (lifetime)."

### Für Strings:
Analogie: "String ist wie ein Haus, das du besitzt. 
&str ist wie die Adresse des Hauses – du weißt, 
wo es ist, aber du besitzt es nicht."

## Verboten

- Fertige Code-Lösungen für Lernaufgaben
- Erklärungen ohne Nachfrage, ob der Nutzer es verstanden hat

Zeilenweise Dekonstruktion:

• ## Mein Verhalten – Verhaltensregeln, die speziell für diesen Skill gelten.
• ## Meine Erklär-Methoden – Vorgefertigte Analogien, die der Agent bei bestimmten Themen verwenden soll.
• ## Verboten – Explizite Verbote im Skill-Kontext.

Schritt 2: Testen

agy
> /skills

Siehst du rust-tutor in der Liste?

🔍 Nachdenk-Aufgabe: Welche eigenen Analogien würdest du dem Skill hinzufügen?

Vorschau: In Projekt 24 lernen wir, Skills gezielt zu testen.

🔧 Projekt 24: Skill testen – /skills und manuelle Aktivierung

Was wir bauen: Einen systematischen Testprozess für unsere Skills.

Schritt 1: Alle aktiven Skills anzeigen

> /skills

Was wir sehen: Eine Liste aller erkannten Skills mit Namen und Beschreibung.

Schritt 2: Den Skill durch eine passende Frage aktivieren

> Erkläre mir Ownership in Rust.

Was passiert: Der Agent erkennt das Thema (Rust + Ownership) und aktiviert automatisch unseren rust-tutor-Skill. Wir sehen, dass er jetzt die Analogien aus dem Skill nutzt.

Schritt 3: Den Skill durch eine nicht passende Frage testen

> Was ist das Wetter heute?

Was passiert: Der Skill wird nicht aktiviert – die Beschreibung passt nicht. Der Agent antwortet normal.

Schritt 4: Wenn der Skill nicht aktiviert wird

Überprüfe die description in SKILL.md. Sie muss die Schlüsselbegriffe enthalten, die in deinen Fragen vorkommen.

🔍 Nachdenk-Aufgabe: Was passiert, wenn zwei Skills gleichzeitig aktiv sind? Teste es!

Vorschau: In Projekt 25 bauen wir einen Skill speziell für Rust-Fehlermeldungen.

🔧 Projekt 25: Skill für Fehlermeldungen – Der Compiler als Lehrer

Was wir bauen: Einen Skill, der uns Rust-Fehlermeldungen erklärt.

Schritt 1: Den Skill erstellen

.agents/skills/rust-fehler-erklaerer/SKILL.md

---
name: rust-fehler-erklaerer
description: Aktiviere diesen Skill, wenn der Nutzer eine Rust-Fehlermeldung 
             (error[E...], cannot borrow, does not live long enough etc.) 
             zeigt oder danach fragt.
---

# Rust-Fehler-Erklärer

## Ablauf bei einer Fehlermeldung

1. Lies die Fehlermeldung vollständig
2. Erkläre auf Deutsch, WAS der Fehler bedeutet (nicht wie man ihn behebt)
3. Erkläre, WARUM Rust diesen Fehler verhindert (Sicherheitsgrund)
4. Stelle die Frage: "Was denkst du, warum Rust das verbietet?"
5. Erst nach der Antwort des Nutzers: Hinweis auf mögliche Lösung

## Häufige Fehlertypen

### E0308: Typfehler
Erkläre: Rust ist streng mit Typen – wie ein Kellner, 
der nur Bestellungen im richtigen Format akzeptiert.

### E0382: Move-Fehler (Ownership)
Erkläre: Der Wert wurde "verschenkt" und kann nicht 
nochmal benutzt werden – wie ein Brief, den man abgeschickt hat.

### E0502: Borrow-Konflikt
Erkläre: Zwei Teile des Programms wollen gleichzeitig 
auf denselben Wert zugreifen – wie zwei Köche, die 
dasselbe Messer gleichzeitig brauchen.

Schritt 2: Testen mit einer echten Fehlermeldung

Schreibe absichtlich einen Fehler in Rust:

fn main() {
    let s = String::from("hallo");
    let s2 = s;
    println!("{}", s); // Fehler!
}

Kompiliere es: cargo build

Kopiere die Fehlermeldung und schicke sie an den Agenten.

🔍 Nachdenk-Aufgabe: Welcher Rust-Fehler verwirrt dich am meisten? Füge ihn zum Skill hinzu.

Vorschau: In Projekt 26 bauen wir einen Code-Review-Skill.

🔧 Projekt 26: Code-Review-Skill – Der kritische Freund

Was wir bauen: Einen Skill, der unseren Code bewertet – ohne ihn zu verbessern.

Schritt 1: Den Review-Skill erstellen

---
name: rust-code-reviewer
description: Aktiviere diesen Skill, wenn der Nutzer einen Code-Review 
             oder Feedback zu seinem Rust-Code möchte.
---

# Rust Code Reviewer

Wenn dieser Skill aktiv ist: Du bist ein konstruktiver Code-Reviewer.

## Deine Review-Checkliste

Analysiere den Code nach diesen Punkten:
1. **Lesbarkeit:** Sind Variablennamen aussagekräftig?
2. **Korrektheit:** Gibt es logische Fehler?
3. **Rust-Stil:** Wird idiomatic Rust verwendet?
4. **Sicherheit:** Könnte ein Panic auftreten?

## Dein Review-Format

1. Beginne mit: "Was du gut gemacht hast:"
2. Stelle dann 3 Fragen (keine direkten Verbesserungsvorschläge)
3. Beende mit: "Was würdest du bei Zeile X anders machen?"

## Verboten

- Verbesserten Code schreiben
- Direkte Lösungen nennen
- Den Code für den Nutzer umschreiben

Schritt 2: Den Skill mit eigenem Code testen

> @main.rs Bitte reviewe meinen Code nach deiner Checkliste.

🔍 Nachdenk-Aufgabe: Welche Review-Fragen haben dich am meisten zum Nachdenken gebracht?

Vorschau: In Projekt 27 fügen wir Referenzen zu unserem Skill hinzu.

🔧 Projekt 27: Skill-Referenzen – Externe Dokumentation einbinden

Was wir bauen: Einen Skill mit Links zu offiziellen Ressourcen.

Schritt 1: Einen references/-Ordner erstellen

.agents/skills/rust-tutor/
├── SKILL.md
└── references/
    └── rust-konzepte.md

Schritt 2: Die Referenzdatei befüllen

# Rust-Konzepte Referenz

## Offizielle Ressourcen

- **Das Rust-Buch:** https://doc.rust-lang.org/book/
  - Kapitel 4: Ownership
  - Kapitel 8: Strings und Collections
  - Kapitel 10: Lifetimes

- **Rust by Example:** https://doc.rust-lang.org/rust-by-example/
  - Interaktive Beispiele für alle Konzepte

- **Rustlings:** https://github.com/rust-lang/rustlings
  - Übungsaufgaben zum Selbermachen

## Wann welche Ressource?

| Problem | Ressource |
|---------|-----------|
| Konzept verstehen | Rust-Buch Kapitel |
| Syntax nachschlagen | Rust by Example |
| Üben | Rustlings |

Schritt 3: Den Skill aktualisieren, um auf Referenzen zu verweisen

## Bei Fragen zu Ressourcen

Verweise auf die Referenzdatei: references/rust-konzepte.md
Nenne immer das spezifische Kapitel oder die Seite.

🔍 Nachdenk-Aufgabe: Welche anderen Ressourcen würden in die Referenzdatei passen?

Vorschau: In Projekt 28 kombinieren wir mehrere Skills.

🔧 Projekt 28: Skills kombinieren – Synergie nutzen

Was wir bauen: Ein Skill-Ökosystem, in dem mehrere Skills zusammenarbeiten.

Schritt 1: Unser Skill-Verzeichnis

.agents/skills/
├── rust-tutor/          ← Erklärt Rust-Konzepte
├── rust-fehler-erklaerer/  ← Erklärt Fehlermeldungen
└── rust-code-reviewer/  ← Bewertet Code

Schritt 2: Verstehen, wie Skills sich ergänzen

Eine typische Lerneinheit mit allen drei Skills:

1. Schreiben: Wir schreiben Code (kein Skill aktiv)
2. Fehler: Rust gibt einen Fehler → rust-fehler-erklaerer aktiv
3. Verstehen: Wir fragen nach dem Konzept → rust-tutor aktiv
4. Verbessern: Wir schreiben neu → rust-code-reviewer aktiv

Schritt 3: Die Skills testen

> Ich habe einen Fehler bekommen: [Fehlermeldung]. 
  Erkläre mir erst den Fehler, dann das dahinterliegende Konzept.

Welche Skills werden aktiviert?

🔍 Nachdenk-Aufgabe: Könnten sich zwei Skills widersprechen? Wie würdest du das lösen?

Vorschau: In Projekt 29 debuggen wir einen nicht funktionierenden Skill.

🔧 Projekt 29: Skill debuggen – Was tun, wenn er nicht funktioniert?

Was wir bauen: Einen systematischen Debug-Prozess für Skills.

Schritt 1: Symptome erkennen

Der Skill aktiviert sich nicht. Mögliche Ursachen:

# Debug-Checkliste für Skills

- [ ] Liegt SKILL.md im richtigen Ordner?
      Pfad: .agents/skills/[name]/SKILL.md

- [ ] Hat SKILL.md ein valides YAML-Frontmatter?
      Beginnt es mit --- und endet mit ---?

- [ ] Sind name: und description: vorhanden?

- [ ] Enthält die description die richtigen Schlüsselwörter?

- [ ] Wurde agy neu gestartet nach der Änderung?

- [ ] Wird der Skill in /skills angezeigt?

Schritt 2: Den häufigsten Fehler beheben

Fehler: name: und Ordnername stimmen nicht überein.

Ordner: rust-tutor/
SKILL.md name: RustTutor  ← Falsch! Groß-/Kleinschreibung beachten

Fix:

name: rust-tutor  ← Muss zum Ordnernamen passen

Schritt 3: Die description testen

Überlege: Wenn du eine Frage stellst, welche Schlüsselwörter kommen vor?

> Erkläre mir Ownership in Rust.

Schlüsselwörter: Ownership, Rust, erkläre

Die description muss diese Wörter enthalten!

🔍 Nachdenk-Aufgabe: Wie kannst du eine Skill-Beschreibung schreiben, die bei allen deinen typischen Fragen anschlägt?

Vorschau: In Projekt 30 denken wir darüber nach, wie Skills langfristig gepflegt werden.

🔧 Projekt 30: Skills langfristig pflegen – Wartung und Updates

Was wir bauen: Eine Strategie für die langfristige Skill-Pflege.

Schritt 1: Ein Skill-Changelog führen

# SKILL-CHANGELOG.md

## rust-tutor

### v1.2 – 2026-06-24
- Neue Analogie für Lifetimes hinzugefügt
- Verständnisfragen nach jeder Erklärung verschärft

### v1.1 – 2026-06-17
- Verweise auf Rust-Buch Kapitel ergänzt

### v1.0 – 2026-06-10
- Initialer Skill erstellt

Schritt 2: Skill-Reviews einplanen

Wöchentliche Fragen:

• Hat der Skill diese Woche gute Erklärungen geliefert?
• Welche Analogien haben gefehlt?
• Welche Regeln wurden nicht eingehalten?

Schritt 3: Skills mit Git versionieren

git add .agents/skills/
git commit -m "rust-tutor v1.2: Lifetime-Analogie hinzugefügt"

🔍 Nachdenk-Aufgabe: Wie verändert sich dein Skill-Ökosystem, wenn du von Phase 1 zu Phase 2 wechselst?

Vorschau: In Gruppe 4 verlassen wir das Terminal und erkunden Antigravity 2.0 – die Desktop-App.

🖼️ Gruppe 4: Antigravity 2.0 – Die Desktop-App

Antigravity 2.0 ist eine eigenständige Electron-App – ein vollwertiges Fenster auf deinem Desktop, das parallel zu allem anderen läuft. Hier können wir Projekte verwalten, Aufgaben planen und geplante Aktionen einrichten.

🖼️ Projekt 31: Antigravity 2.0 kennenlernen – Die Oberfläche

Was wir bauen: Ein Verständnis für die drei Hauptbereiche der App.

Schritt 1: Die linke Seitenleiste erkunden

Die linke Seitenleiste hat fünf Bereiche:

Schritt 2: Den Chat-Bereich erkunden

Der Chat-Bereich ist der Hauptarbeitsplatz. Hier kommunizieren wir mit dem Agenten – genau wie in der CLI, aber mit grafischer Oberfläche.

Vorteile gegenüber der CLI:

• Wir können Dateien per Drag-and-Drop einziehen
• Bilder direkt einfügen
• Den Verlauf leichter navigieren
• Mehrere Konversationen als Tabs öffnen

Schritt 3: Das erste Projekt anlegen

Klicke auf Projects → New Project → Wähle deinen Rust-Ordner aus.

Was passiert: Antigravity 2.0 erkennt automatisch die AGENTS.md in diesem Ordner und lädt sie.

🔍 Nachdenk-Aufgabe: Welche der CLI-Aufgaben aus Gruppe 1 kannst du jetzt einfacher in der Desktop-App erledigen?

Vorschau: In Projekt 32 richten wir unseren Workspace vollständig ein.

🖼️ Projekt 32: Workspace einrichten – Projekt-Konfiguration

Was wir bauen: Einen vollständig konfigurierten Rust-Lernworkspace.

Schritt 1: Projektberechtigungen einstellen

In Settings → Project-Level Settings für unser Rust-Projekt:

File Access Policy:     ask     ← Frage mich, bevor du Dateien liest
Internet Access:        ask     ← Frage mich, bevor du ins Internet gehst  
Auto-Execution Policy:  request-review  ← Immer fragen vor Befehlen
Terminal Sandbox:       off     ← Für Rust-Entwicklung brauchen wir echtes Terminal

Zeilenweise Dekonstruktion:

• ask für Datei- und Internetzugriff: Als Lernender wollen wir alles sehen, was der Agent tut.
• request-review: Kein Befehl wird ohne unsere Bestätigung ausgeführt.
• Terminal Sandbox: off: cargo build muss auf echtes Terminal zugreifen können.

Schritt 2: Projektinformationen eintragen

Im Projekt-Panel können wir auch direkt Beschreibung und Tags hinzufügen.

Schritt 3: Den Workspace testen

Tippe im Chat: @AGENTS.md Was weißt du über dieses Projekt?

Der Agent sollte unsere AGENTS.md kennen und antworten.

🔍 Nachdenk-Aufgabe: Welche Berechtigungseinstellung ist für einen Anfänger am sichersten?

Vorschau: In Projekt 33 nutzen wir Drag-and-Drop – die effizienteste Art, Kontext zu teilen.

🖼️ Projekt 33: Drag-and-Drop – Kontext ohne Tippen

Was wir bauen: Einen effizienteren Kontext-Workflow.

Schritt 1: Eine Datei in den Chat ziehen

Öffne deinen Dateimanager, finde main.rs und ziehe sie direkt in das Chat-Fenster.

Was passiert: Die Datei wird als Kontext angehängt – wir sehen eine kleine Vorschau im Chat.

Schritt 2: Eine Frage hinzufügen

[main.rs wurde eingefügt]
Ich bekomme einen Fehler in Zeile 15. Erkläre mir, was dort passiert.

Zeilenweise Dekonstruktion:

• Drag-and-Drop ist das grafische Äquivalent zu @datei.rs in der CLI.
• Der Agent sieht nun den vollständigen Dateiinhalt als Kontext.
• Effizienter als Copy-Paste – besonders bei langen Dateien.

Schritt 3: Mehrere Dateien gleichzeitig

Wir können mehrere Dateien gleichzeitig in den Chat ziehen.

[main.rs], [Cargo.toml], [Fehlerlog.txt]
Analysiere diese drei Dateien. Was stimmt nicht in meiner Rust-Konfiguration?

🔍 Nachdenk-Aufgabe: Wann ist Drag-and-Drop effizienter als @-Mention? Wann nicht?

Vorschau: In Projekt 34 richten wir unsere erste geplante Aufgabe ein.

🖼️ Projekt 34: Scheduled Tasks – Automatisierung für Lernende

Was wir bauen: Unsere erste geplante Aufgabe in Antigravity 2.0.

Schritt 1: Scheduled Tasks öffnen

Klicke in der linken Seitenleiste auf Scheduled Tasks → New Task.

Schritt 2: Eine einmalige Aufgabe erstellen

Name:     Rust-Lerncheck
Typ:      Einmalig (One-shot)
Zeit:     Morgen, 09:00 Uhr
Aufgabe:  Lies meine AGENTS.md und stelle mir drei Fragen zu meinem 
          aktuellen Lernstand. Frage nicht nach Code.

Zeilenweise Dekonstruktion:

• Name: – Ein aussagekräftiger Name, damit wir die Aufgabe später finden.
• Typ: Einmalig – Die Aufgabe wird genau einmal ausgeführt.
• Zeit: – Wann soll die Aufgabe ausgeführt werden?
• Aufgabe: – Das ist die Anweisung an den Agenten. Er führt sie aus, als würdest du sie selbst eingeben.

Schritt 3: Die Aufgabe aktivieren

Klicke auf Save & Activate. Im Scheduled-Tasks-Panel sehen wir die Aufgabe mit einem Countdown.

🔍 Nachdenk-Aufgabe: Welche Aufgaben in deinem Lernalltag würdest du automatisieren?

Vorschau: In Projekt 35 richten wir eine täglich wiederholende Lernerinnerung ein.

🖼️ Projekt 35: Tägliche Lernerinnerung – Cron-Jobs für den Kopf

Was wir bauen: Ein automatisches tägliches Lernritual.

Schritt 1: Eine wiederkehrende Aufgabe erstellen

Name:       Täglicher Rust-Impuls
Typ:        Wiederkehrend (Cron)
Cron:       0 8 * * *    (täglich um 08:00)
Aufgabe:    Lies meine AGENTS.md. Stelle mir heute eine Aufwärmfrage 
            zu dem Thema, das ich gerade lerne. 
            Beginne mit: "Guten Morgen! Heute eine Frage zu [Thema]:"

Zeilenweise Dekonstruktion eines Cron-Ausdrucks:

0  8  *  *  *
│  │  │  │  └─ Wochentag (0-7, * = jeden)
│  │  │  └──── Monat (1-12, * = jeden)
│  │  └─────── Tag des Monats (1-31, * = jeden)
│  └────────── Stunde (0-23)
└───────────── Minute (0-59)

• 0 8 * * * bedeutet: Jede Nacht um 8:00 Uhr, jeden Tag, jeden Monat, jedes Jahr.
• */5 * * * * würde bedeuten: Alle 5 Minuten (für Tests nützlich).

Schritt 2: Den ersten Trigger abwarten oder manuell testen

Klicke auf Run Now um die Aufgabe sofort zu testen.

Schritt 3: Die Aufgabe verfeinern

Nach ein paar Tagen: Fühlen sich die täglichen Fragen hilfreich an? Zu leicht? Zu schwer? Passe die Aufgabe an.

🔍 Nachdenk-Aufgabe: Welche Uhrzeit wäre für deine tägliche Lernerinnerung am besten?

Vorschau: In Projekt 36 konfigurieren wir projektspezifische Berechtigungen.

🖼️ Projekt 36: Projektberechtigungen verfeinern

Was wir bauen: Ein maßgeschneidertes Sicherheitsprofil für unser Rust-Projekt.

Schritt 1: Die Berechtigungs-Hierarchie verstehen

Globale Einstellungen
    └── Projekteinstellungen (überschreiben global)
            └── Explizite Berechtigungen (überschreiben alles)

Schritt 2: Explizite Berechtigungen setzen

In Settings → Permission Grants für unser Projekt:

Allow:  read_file  ~/mein-rust-projekt/
Allow:  command    cargo
Allow:  command    rustc
Deny:   write_file ~/mein-rust-projekt/src/main.rs

Zeilenweise Dekonstruktion:

• Allow read_file ~/mein-rust-projekt/ – Der Agent darf alle Dateien in unserem Projekt lesen.
• Allow command cargo – cargo build, cargo run, cargo test sind erlaubt.
• Deny write_file .../main.rs – Unsere Hauptdatei darf der Agent nicht schreiben! Wir schreiben sie selbst.

Schritt 3: Die Berechtigungen testen

> Schreibe den kompletten Code in main.rs.

Der Agent sollte abgewiesen werden oder nachfragen – weil write_file für main.rs verboten ist.

🔍 Nachdenk-Aufgabe: Welche Dateien in deinem Projekt willst du selbst schreiben und welche darf der Agent erstellen?

Vorschau: In Projekt 37 nutzen wir den Konversationsverlauf in der Desktop-App.

🖼️ Projekt 37: Konversationsverlauf in Antigravity 2.0

Was wir bauen: Ein Archiv unserer Lernreise in der Desktop-App.

Schritt 1: Konversationen organisieren

In der linken Seitenleiste sehen wir alle Konversationen. Wir können:

• Nach Datum sortieren
• Nach Projekt filtern
• Konversationen umbenennen (Rechtsklick → Rename)
• Konversationen teilen oder exportieren

Schritt 2: Eine Wochenrückblick-Konversation starten

Erstelle einen strukturierten Wochenrückblick basierend auf 
unseren Konversationen dieser Woche.

Beantworte folgende Fragen:
1. Was habe ich diese Woche gelernt?
2. Was hat mich überrascht?
3. Was verstehe ich noch nicht?
4. Was ist mein Ziel für nächste Woche?

Formuliere die Antworten in der Ich-Form, als wäre ich es, 
der antwortet – aber basierend auf unseren tatsächlichen Gesprächen.

Schritt 3: Den Rückblick in AGENTS.md eintragen

Kopiere die wichtigsten Erkenntnisse in die AGENTS.md unter ## Mein Lernstand.

🔍 Nachdenk-Aufgabe: Wie könntest du Wochenrückblicke als automatischen Scheduled Task einrichten?

Vorschau: In Projekt 38 beherrschen wir die Sidebar-Navigation vollständig.

🖼️ Projekt 38: Sidebar-Navigation meistern

Was wir bauen: Einen effizienten Umgang mit der Desktop-App-Oberfläche.

Schritt 1: Skills & Customizations in der App

Klicke auf Skills & Customizations in der Seitenleiste.

Was wir sehen:

• Alle aktiven Skills (aus .agents/skills/)
• Alle geladenen Regeln (aus AGENTS.md)
• MCP-Server (falls konfiguriert)

Schritt 2: Einen Skill direkt in der App bearbeiten

Wir können SKILL.md-Dateien direkt in der App öffnen und bearbeiten – ohne Texteditor.

Schritt 3: Keyboard Shortcuts lernen

🔍 Nachdenk-Aufgabe: Welche Keyboard-Shortcuts würden deinen Workflow am meisten beschleunigen?

Vorschau: In Projekt 39 erkunden wir Slash-Befehle speziell in Antigravity 2.0.

🖼️ Projekt 39: Slash-Befehle in Antigravity 2.0

Was wir bauen: Ein Verständnis für die 2.0-spezifischen Workflows.

Schritt 1: Das Slash-Befehl-Menü öffnen

Tippe / im Chat und warte. Ein Menü erscheint mit allen verfügbaren Befehlen.

Schritt 2: Besondere 2.0-Befehle

Schritt 3: /grill-me für Rust-Lernen nutzen

> /grill-me

Was passiert: Der Agent beginnt uns zu befragen – wie in einem mündlichen Examen. Perfekt, um zu testen, ob wir ein Rust-Konzept wirklich verstanden haben.

Zeilenweise Dekonstruktion:

• /grill-me ohne Thema: Der Agent fragt nach dem Thema.
• /grill-me Ownership in Rust: Sofort gezielte Fragen zu Ownership.
• Der Agent hört erst auf, wenn wir alle Fragen korrekt beantwortet haben.

🔍 Nachdenk-Aufgabe: Welches Rust-Thema würdest du für /grill-me wählen?

Vorschau: In Projekt 40 kombinieren wir Scheduled Tasks mit automatischen Code-Reviews.

🖼️ Projekt 40: Automatisierter Lernplan – Alles zusammen in 2.0

Was wir bauen: Einen vollautomatischen wöchentlichen Lernzyklus.

Schritt 1: Den Lernzyklus planen

Montag, 08:00 → "Guten Morgen! Welches Rust-Thema nehmen wir diese Woche?"
Mittwoch, 08:00 → "Zwischenfazit: Was hast du bisher gelernt? Drei Stichpunkte."
Freitag, 17:00 → "Wochenabschluss: /grill-me [aktuelles Thema]"
Sonntag, 10:00 → "Lernstand in AGENTS.md aktualisieren."

Schritt 2: Die vier Scheduled Tasks erstellen

Für jeden Eintrag eine eigene Aufgabe mit passender Cron-Expression:

Montag:     0 8 * * 1
Mittwoch:   0 8 * * 3
Freitag:    0 17 * * 5
Sonntag:    0 10 * * 0

Schritt 3: Den Lernzyklus starten und beobachten

Lasse den Zyklus zwei Wochen laufen. Danach: Welche Aufgaben haben geholfen? Welche nicht?

🔍 Nachdenk-Aufgabe: Wie müsste sich der Lernzyklus verändern, wenn du von Phase 1 zu Phase 2 wechselst?

Vorschau: In Gruppe 5 tauchen wir in die Antigravity IDE ein – KI direkt im Code-Editor.

💻 Gruppe 5: Antigravity IDE – KI im Editor

Die Antigravity IDE ist eine VS-Code-basierte Entwicklungsumgebung, die KI nicht als Add-on behandelt, sondern als ersten Bürger. Hier arbeiten wir und der Agent gleichzeitig – im selben Fenster, auf denselben Dateien.

💻 Projekt 41: Die Antigravity IDE einrichten

Was wir bauen: Einen konfigurierten Rust-Entwicklungsarbeitsplatz.

Schritt 1: Den Rust-Workspace öffnen

Öffne die Antigravity IDE und dann deinen Rust-Projektordner.

Was automatisch passiert:

• Die IDE erkennt AGENTS.md und .agents/
• Alle Skills werden geladen
• Die Workspace-Konfiguration wird angewendet

Schritt 2: Die rust-analyzer-Extension prüfen

View → Extensions → Suche: rust-analyzer

Rust-Analyzer ist das offizielle Rust-Language-Server-Plugin – es gibt uns:

• Autovervollständigung
• Fehler-Unterstreichungen
• Typ-Inferenz-Anzeigen

Schritt 3: Die Sidebar öffnen

Die Antigravity-Sidebar erscheint rechts (oder links, je nach Einstellung). Sie enthält den Chat-Bereich – genau wie Antigravity 2.0, aber direkt im Editor.

🔍 Nachdenk-Aufgabe: Was ändert sich an deinem Arbeitsfluss, wenn IDE, Compiler und Agent im selben Fenster sind?

Vorschau: In Projekt 42 nutzen wir die Tab-Vervollständigung.

💻 Projekt 42: Tab-Autocomplete – Der Agent tippt mit

Was wir bauen: Ein Gefühl für KI-gestützte Autocomplete.

Schritt 1: Autocomplete erfahren

Öffne main.rs und beginne zu tippen:

fn main() {
    let mut

Was passiert: Nach einer kurzen Pause erscheint ein grauer Vorschlag. Der Agent schlägt eine Fortsetzung vor, basierend auf dem Kontext.

Schritt 2: Den Vorschlag annehmen oder ablehnen

• Tab → Vorschlag komplett annehmen
• Esc → Vorschlag ablehnen
• Ctrl + → → Vorschlag wortweise annehmen

Zeilenweise Dekonstruktion:

• Der Agent sieht: offene Datei, Cursor-Position, andere offene Tabs, Clipboard (optional).
• Er schlägt das vor, was statistisch am wahrscheinlichsten als Nächstes kommt.
• Das bedeutet: Er kann sich irren! Immer prüfen, was er vorschlägt.

Schritt 3: Bewusst entscheiden

Akzeptiere nie einen Vorschlag, ohne ihn zu lesen. Das ist der wichtigste Grundsatz der IDE-Nutzung als Anfänger.

🔍 Nachdenk-Aufgabe: Wann hilft Autocomplete? Wann hindert es dein Lernen?

Vorschau: In Projekt 43 nutzen wir Ctrl+I für gezielte Bearbeitungen.

💻 Projekt 43: Inline-Bearbeitung – Ctrl+I

Was wir bauen: Einen gezielten Inline-Bearbeitungsworkflow.

Schritt 1: Code markieren und Ctrl+I drücken

Markiere in main.rs eine Funktion und drücke Ctrl+I.

Was passiert: Ein kleines Texteingabefeld erscheint direkt über dem markierten Code.

Schritt 2: Eine Anweisung eingeben

Füge einen deutschen Kommentar über jeder Zeile ein, der erklärt was sie tut.
Schreibe KEINEN neuen Code – nur Kommentare.

Zeilenweise Dekonstruktion:

• Ctrl+I wirkt nur auf den markierten Bereich. Der Rest der Datei bleibt unberührt.
• Unsere Anweisung ist präzise: Kommentare hinzufügen, kein neuer Code.
• Das ist ideal für: Dokumentieren, Erklären, kleine Umbenennungen.

Schritt 3: Das Ergebnis im Diff-Overlay prüfen

Nach der Bearbeitung erscheint das Diff-Overlay direkt im Editor:

• Grüne Linien: Hinzugefügte Zeilen
• Rote Linien: Entfernte Zeilen

Accept All   |   Reject All   |   Review Each

Klicke auf Review Each, um jede Änderung einzeln zu prüfen.

🔍 Nachdenk-Aufgabe: Für welche Arten von Code-Änderungen ist Ctrl+I besonders nützlich?

Vorschau: In Projekt 44 entdecken wir Code Lenses – die unsichtbaren KI-Buttons.

💻 Projekt 44: Code Lenses – KI-Buttons direkt im Code

Was wir bauen: Einen intuitiven Umgang mit Code-Lens-Aktionen.

Schritt 1: Code Lenses sehen

Öffne main.rs mit einer fn-Funktion. Direkt über dem Funktionsnamen erscheinen kleine Links:

Refactor | Write Tests | Explain Code | ...
fn main() {

Zeilenweise Dekonstruktion:

• Code Lenses sind kontextabhängig – über einer struct erscheinen andere Optionen als über einer fn.
• Sie sind immer sichtbar, sobald man in die Nähe scrollt.
• Jeder Klick öffnet eine Interaktion in der Sidebar.

Schritt 2: „Explain Code“ klicken

Klicke auf Explain Code über unserer main-Funktion.

Was passiert: Der Agent erklärt die Funktion Zeile für Zeile in der Sidebar.

Schritt 3: „Refactor“ verstehen (ohne es zu nutzen)

⚠️ Als Anfänger: Nutze „Refactor“ noch nicht! Du lernst Rust, indem du selbst schreibst. „Refactor“ lässt den Agenten unseren Code umschreiben – das ist kontraproduktiv fürs Lernen.

🔍 Nachdenk-Aufgabe: Welche Code-Lens-Aktionen helfen beim Lernen, welche behindern es?

Vorschau: In Projekt 45 verstehen wir das Diff-Overlay vollständig.

💻 Projekt 45: Diff-Overlay meistern – Änderungen im Blick

Was wir bauen: Einen kontrollierten Umgang mit allen Änderungen des Agenten.

Schritt 1: Das Diff-Overlay verstehen

Das Diff-Overlay erscheint immer, wenn der Agent Dateien ändert:

← VORHER     |     NACHHER →
─────────────────────────────
fn main() {  |  fn main() {
    let x = 5;│      let x: i32 = 5;  ← Grün: neu
    println!  |      println!
              │  // Ich bin neu      ← Grün: neu

Schritt 2: Die drei Entscheidungsoptionen

• Accept All: Alle Änderungen übernehmen. Nur bei Änderungen, die wir vollständig gelesen haben!
• Reject All: Alle Änderungen verwerfen. Der Code bleibt unverändert.
• Review Each: Jede Änderung einzeln entscheiden. Das ist die empfohlene Option für Lernende.

Schritt 3: Review Each im Detail

Bei Review Each navigieren wir durch jede Änderung:

• Accept → Diese Änderung übernehmen
• Reject → Diese Änderung ablehnen
• Wir können für jede Änderung einzeln entscheiden!

🔍 Nachdenk-Aufgabe: Warum ist „Accept All“ für Lernende gefährlich?

Vorschau: In der letzten Gruppe kombinieren wir alles.

🚀 Gruppe 6: Alles zusammen – Der vollständige Workflow

In dieser Gruppe verbinden wir CLI, AGENTS.md, Skills, Antigravity 2.0 und die IDE zu einem einzigen, vollständigen Entwicklungsworkflow. So sieht modernes, KI-gestütztes Lernen im Jahr 2026 aus.

🚀 Projekt 46: Der vollständige Morgen-Workflow

Was wir bauen: Ein tägliches Ritual für produktives Rust-Lernen.

Schritt 1: 08:00 – Der automatische Morgen-Impuls

Der Scheduled Task aus Projekt 35 stellt uns eine Frage. Wir lesen sie und denken kurz nach.

Schritt 2: 08:10 – AGENTS.md aktualisieren

Öffne AGENTS.md und update ## Mein aktuelles Problem:

## Mein aktuelles Problem – 2026-06-24

Gestern hat nicht geklappt: `.parse::<i32>()` – ich verstehe nicht,
warum ich `<i32>` in spitzen Klammern schreiben muss.

Zeilenweise Dekonstruktion:

• Datum im Titel: Der Agent weiß, wie aktuell diese Information ist.
• Konkretes Problem: Kein vages „Ich verstehe Rust nicht“, sondern eine präzise Frage.
• ::<i32>() in Code-Backticks: Der Agent erkennt es als Code-Schnipsel.

Schritt 3: 08:15 – Die Frage an den Agenten

> Sieh dir mein aktuelles Problem in AGENTS.md an. 
  Erkläre mir das Konzept hinter der Syntax ::<i32> – aber gib mir noch keinen Code.

Schritt 4: 08:30 – Code schreiben, selbst

Schreibe selbst. Der Agent beobachtet, hilft bei Fragen, schreibt aber nicht.

🔍 Nachdenk-Aufgabe: Wie lange solltest du ohne Agenten-Hilfe coden, bevor du fragst?

Vorschau: In Projekt 47 bauen wir den vollständigen Fehler-Debug-Workflow.

🚀 Projekt 47: Der Fehler-Debug-Workflow

Was wir bauen: Einen systematischen Prozess für Rust-Fehlermeldungen.

Schritt 1: Den Fehler produzieren

cargo build

Rust gibt uns eine Fehlermeldung. Wir lesen sie zuerst selbst:

error[E0382]: borrow of moved value: `s`
  --> src/main.rs:4:20
   |
2  |     let s = String::from("hallo");
   |         - move occurs because `s` has type `String`
3  |     let s2 = s;
   |              - value moved here
4  |     println!("{}", s);
   |                    ^ value borrowed here after move

Schritt 2: Selbst verstehen versuchen

Bevor wir den Agenten fragen:

• Welche Zeile ist betroffen? (Zeile 4)
• Was sagt der Fehlercode? (E0382)
• Was ist ein „moved value“?

Schritt 3: Den Agenten gezielt fragen

> Ich habe diesen Rust-Fehler bekommen: [Fehlermeldung einfügen]
  
  Was ich bereits verstehe: Der Fehler ist in Zeile 4.
  Was ich nicht verstehe: Was bedeutet "value moved here"?
  
  Erkläre mir das Konzept. Kein Code, nur Erklärung.

Zeilenweise Dekonstruktion:

• Was ich bereits verstehe: – Wir zeigen dem Agenten, was er nicht nochmal erklären muss.
• Was ich nicht verstehe: – Fokus auf das echte Problem.
• Kein Code, nur Erklärung: – Die Regel aus unserer AGENTS.md wird hier wiederholt.

Schritt 4: Den Fix selbst schreiben

Nach der Erklärung: Schreibe die Lösung selbst. Der Agent schaut zu.

🔍 Nachdenk-Aufgabe: Was lernst du aus einem Fehler, den du selbst gefixt hast, im Vergleich zu einem, den der Agent gefixt hat?

Vorschau: In Projekt 48 bauen wir einen vollständigen Code-Review-Workflow.

🚀 Projekt 48: Der vollständige Code-Review-Workflow

Was wir bauen: Ein systematisches Verfahren, um unseren eigenen Code zu verbessern.

Schritt 1: Code komplett fertigschreiben

Schreibe „Zahlen raten“ vollständig – ohne Agenten-Hilfe beim Code.

Schritt 2: Selbst-Review

Bevor der Agent draufschaut:

# Mein Selbst-Review – Zahlen raten

## Was ich gut gemacht habe
- Klare Variablennamen
- Fehlerfall bei falscher Eingabe abgefangen

## Was ich unsicher finde
- Die Schleife in Zeile 12-20 könnte klarer sein
- Ich weiß nicht, ob mein Ownership-Einsatz korrekt ist

## Fragen an den Agenten
- Ist meine Nutzung von `&str` vs `String` korrekt?
- Gibt es einen rust-ischen Weg, die Eingabe-Konvertierung klarer zu machen?

Schritt 3: Den Agenten-Review starten

> @main.rs Hier ist mein Selbst-Review: [einfügen]
  
  Bitte reviewe meinen Code nach deiner Checkliste aus dem rust-code-reviewer Skill.
  Stelle mir nur Fragen – keinen verbesserten Code.

Schritt 4: Auf Fragen antworten und verbessern

Der Agent stellt Fragen. Wir antworten und verbessern selbst.

🔍 Nachdenk-Aufgabe: Welche Frage des Agenten hat dich am meisten überrascht?

Vorschau: In Projekt 49 automatisieren wir Teile unseres Lernplans.

🚀 Projekt 49: Der automatisierte Monats-Lernplan

Was wir bauen: Ein vollständiges Monatsprogramm für Rust-Lernen mit Antigravity.

Schritt 1: Den Monat planen

# Rust-Lernplan – Juli 2026

## Woche 1: Grundlagen festigen (Phase 1 Projekte 1-10)
## Woche 2: Ownership vertiefen (Phase 1 Projekte 11-20)
## Woche 3: Strings & Eingabe (Phase 1 Projekte 21-30)
## Woche 4: Mini-Projekt abschließen ("Zahlen raten" fertig)

Schritt 2: Monatliche Meilenstein-Tasks erstellen

1. Juli, 08:00:   Woche 1 Kick-off: "Was nimmst du dir für diese Woche vor?"
8. Juli, 17:00:   Woche 1 Review: "Was hast du in Woche 1 gelernt?"
15. Juli, 17:00:  Halbzeit-Check: "Bist du auf Kurs?"
31. Juli, 17:00:  Monatsabschluss: "/grill-me Phase 1 Grundlagen"

Schritt 3: Die AGENTS.md monatlich resetten

Am Monatsende:

1. Füge einen Abschnitt ## Monat Juni – Gelernt hinzu
2. Verschiebe erlerntes aus ## Lerne ich nach ## Kann ich
3. Füge neue Themen ein
4. Committen: git commit -m "Lernstand Juli 2026: Phase 1 abgeschlossen"

🔍 Nachdenk-Aufgabe: Wie würde dein Lernplan für Phase 2 anders aussehen?

Vorschau: Im letzten Projekt bauen wir das ultimative persönliche KI-Lernsystem.

🚀 Projekt 50: Das vollständige persönliche KI-Lernsystem – Dein Antigravity-Setup

Was wir bauen: Eine vollständige, personalisierte Lerninfrastruktur.

Schritt 1: Die finale Verzeichnisstruktur

~/mein-rust-lernen/
├── AGENTS.md                        ← Projektübersicht & Lernstand
├── .agents/
│   ├── AGENTS.md                    ← Verhaltensregeln
│   └── skills/
│       ├── rust-tutor/
│       │   ├── SKILL.md
│       │   └── references/
│       │       └── rust-konzepte.md
│       ├── rust-fehler-erklaerer/
│       │   └── SKILL.md
│       └── rust-code-reviewer/
│           └── SKILL.md
├── src/
│   └── main.rs
├── Cargo.toml
├── SKILL-CHANGELOG.md               ← Skill-Versionsgeschichte
├── lernjournal/
│   ├── 2026-06.md                   ← Monatliches Lernjournal
│   └── 2026-07.md
└── .git/                            ← Versionskontrolle

Schritt 2: Die finale AGENTS.md

# AGENTS.md – Rust-Lernsystem 2026

Ich lerne Rust seit [Datum]. Ich bin Anfänger.
Diese Datei steuert meinen KI-Lernpartner.

---

## 🗓️ Aktueller Stand – KW 26/2026

**Phase:** 1 – Grundlagen  
**Projekt:** Zahlen raten (70% fertig)  
**Fokus dieser Woche:** Benutzereingabe mit std::io  
**Letztes Problem:** .parse::<i32>() – GELÖST  
**Aktuelles Problem:** loop vs while – welches wann?  

---

## ✅ Kann ich
- Variablen, mut, Datentypen
- if/else, for-Schleife  
- Grundlegende Benutzereingabe

## 📖 Lerne gerade
- while und loop im Vergleich
- Fehlerfälle mit Eingaben behandeln

## 🔜 Kommt später
- Ownership (verstehe ich noch nicht)
- Borrowing & Lifetimes

---

## ⚙️ Regeln (unveränderlich)
- Sprache: Deutsch
- Kein fertiger Code für Lernaufgaben
- Stelle nach jeder Erklärung eine Frage
- Bei Fehlern: Erst das "Warum", dann das "Wie"

---

## 📁 Struktur
[Verzeichnisstruktur wie oben]

Schritt 3: Das System in Aktion

Ein vollständiger Lernablauf:

08:00 → Scheduled Task: Tagesfrage kommt automatisch
08:05 → AGENTS.md aktualisieren: Aktuelles Problem eintragen
08:15 → CLI: Frage an den Agenten, Konzept verstehen
09:00 → IDE: Code selbst schreiben
09:30 → Fehler → Rust-Fehler-Erklärer Skill aktiv
10:00 → Code fertig → Code-Reviewer Skill aktiv
10:30 → Git commit: "loop in Zahlen-raten implementiert"
17:00 → Scheduled Task: Tagesrückblick

Schritt 4: Die Reflexion – Was dieses System bedeutet

Du hast in 50 Projekten gelernt:

Aber das Wichtigste: Du hast gelernt, dass du der Entscheider bist. Der Agent ist dein Werkzeug, dein Spiegel, dein Sparringspartner – aber nie dein Ghostwriter.

🦀 Das Prinzip von 2026:
Der beste KI-Nutzer ist nicht derjenige, der den Agenten am meisten benutzt –
sondern derjenige, der ihn am klügsten einsetzt.

Und das bist jetzt du.

📚 Alle Ressourcen auf einen Blick

💎 Google Gemini als Lernpartner

Direkt im Browser – ohne Installation, immer erreichbar.

Neben Antigravity gibt es ein weiteres mächtiges KI-Werkzeug, das wir kostenlos und sofort nutzen können: Google Gemini unter gemini.google.com/app.

In dieser Lektion lernen wir, Gemini gezielt als Lern-Gesprächspartner für Rust einzusetzen – und verstehen, wann wir Gemini nutzen und wann Antigravity die bessere Wahl ist.

Das Wichtigste vorweg: Gemini und Antigravity sind keine Konkurrenten – sie ergänzen sich. Wir lernen hier, das richtige Werkzeug für den richtigen Moment zu wählen.

🔍 Gemini vs. Antigravity – Was ist der Unterschied?

Die goldene Regel:

🗣️ Wenn wir über Rust reden wollen → Gemini
🛠️ Wenn wir mit Rust arbeiten wollen → Antigravity

🧠 Theorie: Wie funktioniert Gemini?

Gemini ist Googles multimodales KI-Modell. Im Browser unter gemini.google.com/app können wir:

• Text-Fragen stellen (Konzepte, Erklärungen, Vergleiche)
• Bilder hochladen (z. B. Foto einer Fehlermeldung vom Bildschirm)
• Code einfügen und erklären lassen
• Gespräche führen – Gemini erinnert sich an den Verlauf der Sitzung
• Mit Gemini Gems (benutzerdefinierte Assistenten) arbeiten

Gemini Gems – Das Gegenstück zu Antigravity Skills

Genau wie wir in Antigravity Skills bauen, gibt es in Gemini Gems – vorkonfigurierte Assistenten mit eigenem Namen, Verhalten und Anweisungen.

🛠️ Übungen

🔵 Übung 1: Gemini kennenlernen

Ziel: Ersten Kontakt mit Gemini herstellen und die Oberfläche erkunden.

Schritte:

1. Öffne gemini.google.com/app im Browser

2. Melde dich mit deinem Google-Konto an

3. Stelle diese erste Frage:

   Erkläre mir Ownership in Rust so, als wäre ich 10 Jahre alt.
   Nutze eine Alltagsanalogie.
   

4. Lies die Antwort aufmerksam durch

5. Stelle eine Folgefrage, die auf der Antwort aufbaut

Nachdenk-Aufgaben:

• Wie unterscheidet sich die Antwort von der, die Antigravity gegeben hat?
• Welche Analogie hat Gemini gewählt?
• Fehlt dir etwas in der Antwort?

🔵 Übung 2: Rust-Konzepte mit Gemini erkunden

Ziel: Gemini als Erklär-Assistent für schwierige Rust-Konzepte nutzen.

Schritte:

1. Wähle eines dieser Rust-Konzepte, das du noch nicht vollständig verstehst:

   • Ownership & Move-Semantik
   • Borrowing & Referenzen (&)
   • Der Unterschied zwischen String und &str
   • Warum Rust keinen Garbage Collector hat

2. Stelle Gemini folgende Frage (passe [KONZEPT] an):

   Ich lerne Rust als Anfänger. Erkläre mir [KONZEPT] in drei Schritten:
   1. Eine einfache Definition in einem Satz
   2. Eine Alltagsanalogie
   3. Warum Rust das so macht (Vorteil)
   
   Schreibe keinen Code – nur Erklärungen.
   

3. Lies Schritt für Schritt

4. Formuliere in eigenen Worten, was du verstanden hast, und frage Gemini:

   Ich habe verstanden: [Deine Erklärung in eigenen Worten]
   Ist das korrekt? Was fehlt noch?
   

Nachdenk-Aufgaben:

• Was ist der Vorteil, ein Konzept in eigenen Worten zu formulieren?
• Welcher der drei Erklär-Schritte war am hilfreichsten?

🔵 Übung 3: Fehlermeldung fotografieren & verstehen

Ziel: Geminis Bildverständnis für Fehler-Analysen nutzen.

Schritte:

1. Schreibe absichtlich einen Rust-Fehler, z. B.:

   fn main() {
       let x = 5;
       x = 10; // Fehler: x ist nicht mut
   }

2. Führe cargo build aus und sieh die Fehlermeldung im Terminal

3. Mache einen Screenshot der Fehlermeldung

4. Lade den Screenshot in Gemini hoch und schreibe dazu:

   Ich bin Rust-Anfänger. Ich habe diesen Fehler bekommen.
   Erkläre mir:
   1. Was bedeutet die Fehlermeldung auf Deutsch?
   2. Warum verhindert Rust das?
   3. Welches Konzept steckt dahinter?
   
   Schreibe mir NICHT die Lösung – ich möchte sie selbst finden.
   

5. Beantworte den Fehler selbst, ohne Gemini nach dem Fix zu fragen

Nachdenk-Aufgaben:

• Was hat der Bild-Upload gegenüber dem Text-Kopieren vereinfacht?
• Hat Gemini das Konzept hinter dem Fehler korrekt erklärt?

🔵 Übung 4: Gemini als Lern-Gesprächspartner

Ziel: Ein strukturiertes Lern-Gespräch mit Gemini führen.

Schritte:

1. Starte ein neues Gespräch in Gemini mit diesem Einstieg:

   Du bist mein Rust-Lernpartner. Ich bin Anfänger.
   Deine Aufgaben:
   - Beantworte meine Fragen mit einfachen Alltagsbeispielen
   - Stelle nach jeder Erklärung eine Verständnisfrage
   - Schreibe NIE fertigen Code – nur Hinweise
   - Erinnere mich daran, Konzepte selbst auszuprobieren
   
   Beginne mit: "Hallo! Welches Rust-Thema möchtest du heute erkunden?"
   

2. Führe ein Gespräch über mindestens 3 Runden (Frage → Antwort → Folgefrage)

3. Notiere am Ende:

   • Was habe ich in diesem Gespräch gelernt?
   • Welche Frage war am wertvollsten?

Nachdenk-Aufgaben:

• Was fehlt in Gemini im Vergleich zu Antigravity mit AGENTS.md?
• Wie könntest du das Gespräch effizienter gestalten?

🔵 Übung 5: Einen Gemini Gem bauen – Dein Rust-Tutor

Ziel: Einen personalisierten Rust-Lernassistenten in Gemini erstellen.

Das Konzept: Gemini Gems sind wie Antigravity Skills – vorkonfigurierte Assistenten mit eigenem Verhalten.

Schritte:

1. Öffne gemini.google.com/app

2. Klicke auf „Gems“ in der linken Seitenleiste

3. Klicke auf „Neuen Gem erstellen“

4. Fülle das Formular aus:

   Name:

   Rust Lerntutor 🦀
   

   Anweisungen:

   Du bist mein persönlicher Rust-Lerntutor für Anfänger.
   
   Dein Verhalten:
   - Antworte immer auf Deutsch
   - Erkläre jedes Konzept mit einer Alltagsanalogie
   - Stelle nach jeder Erklärung eine Verständnisfrage
   - Schreibe KEINEN fertigen Code – nur Hinweise und Erklärungen
   - Wenn ich nach der Lösung frage: Stelle die Gegenfrage "Was hast du selbst schon probiert?"
   - Halte Antworten kurz: maximal 5 Sätze pro Abschnitt
   
   Mein Lernstand:
   - Ich bin absoluter Anfänger
   - Ich habe noch keine Programmiererfahrung
   - Ich lerne seit [Wochen] Rust
   
   Begrüße mich mit: "Hallo! Bereit für Rust? 🦀 Womit kann ich dir heute helfen?"
   

5. Klicke auf „Speichern“

6. Teste den Gem mit einer Rust-Frage

Zeilenweise Dekonstruktion der Gem-Anweisungen:

• Antworte immer auf Deutsch – Ohne diese Regel könnte Gemini auf Englisch antworten.
• Alltagsanalogie – Wir fordern aktiv die Erklär-Methode ein, die am besten funktioniert.
• KEINEN fertigen Code – In Großbuchstaben für Nachdruck – wie in unserer AGENTS.md.
• Mein Lernstand – Genau wie in unserer AGENTS.md: Je mehr Kontext, desto besser die Antworten.

Vergleich: Gem vs. Antigravity Skill:

Nachdenk-Aufgaben:

• Was kann dein Gem, was dein Antigravity Skill nicht kann?
• Was kann dein Skill, was dein Gem nicht kann?

🔵 Übung 6: Gemini + Antigravity kombinieren

Ziel: Beide Werkzeuge in einem Lernzyklus zusammen einsetzen.

Der kombinierte Workflow:

🌐 Gemini          →   🖥️ Antigravity CLI   →   📝 Code schreiben
──────────────────────────────────────────────────────────────────
Konzept verstehen   →   Projektkontext        →   Selbst programmieren
Fragen klären       →   Fehler analysieren    →   Lösung erarbeiten
Brainstorming       →   AGENTS.md aktualisieren → Review einholen

Konkrete Schritte:

Schritt 1 – Mit Gemini vorbereiten:

In Gemini:
"Ich möchte heute in Rust eine Eingabe vom Terminal lesen
und in eine Zahl umwandeln. Welche Konzepte brauche ich dafür?
Erkläre nur die Konzepte – keinen Code."

Schritt 2 – In Antigravity die AGENTS.md aktualisieren:

## Mein aktuelles Thema
Ich lerne heute: Benutzereingabe lesen mit std::io::stdin()
und Strings in Zahlen umwandeln mit .parse()

Konzepte, die ich verstehe (aus Gemini-Gespräch):
- stdin() gibt einen Handle zum Standard-Input
- .read_line() liest eine Zeile als String
- .parse::<i32>() konvertiert den String

Schritt 3 – Code selbst schreiben (kein Agent!): Öffne die IDE und schreibe den Code selbst, basierend auf dem, was du verstanden hast.

Schritt 4 – Fehler mit Antigravity analysieren:

agy
> Ich habe diesen Fehler: [Fehlermeldung]
  Erkläre mir das Warum – ich möchte die Lösung selbst finden.

Schritt 5 – Ergebnis mit Gemini reflektieren:

In Gemini:
"Ich habe gerade [Konzept] in Rust erfolgreich implementiert.
Was ist der nächste logische Schritt, den ich lernen sollte?
Erkläre kurz, warum dieser Schritt jetzt sinnvoll ist."

Nachdenk-Aufgaben:

• In welchem Schritt war Gemini hilfreicher? In welchem Antigravity?
• Wie viel Zeit hast du für jeden Schritt gebraucht?
• Was würdest du beim nächsten Mal anders machen?

🔵 Übung 7: Vergleich-Protokoll führen

Ziel: Systematisch verstehen, welches Werkzeug wann besser passt.

Schritte:

1. Erstelle eine Datei ki-vergleich.md in deinem Rust-Projekt:

   # KI-Werkzeug-Vergleich – Meine Erfahrungen
   
   ## Wann nutze ich Gemini?
   - 
   
   ## Wann nutze ich Antigravity CLI?
   - 
   
   ## Wann nutze ich Antigravity IDE?
   - 
   
   ## Erlebnisse
   
   ### [Datum]: [Situation]
   Werkzeug: Gemini / Antigravity  
   Aufgabe:  
   Ergebnis:  
   Besser wäre gewesen:  
   

2. Fülle die Datei nach jeder Lernsitzung aus

3. Teile das Protokoll nach zwei Wochen mit dem Antigravity-Agenten:

   agy
   > @ki-vergleich.md Analysiere meine Erfahrungen. 
     Welches Muster erkennst du? Wann sollte ich welches Werkzeug nutzen?
   

Nachdenk-Aufgaben:

• Hat sich deine Meinung über die beiden Werkzeuge nach zwei Wochen verändert?
• Gibt es Situationen, in denen du keines von beiden nutzen würdest?

💡 Zusammenfassung: Das KI-Werkzeugkasten 2026

Als Rust-Lernender im Jahr 2026 haben wir drei Hauptwerkzeuge:

🦀 Die wichtigste Erkenntnis:
Kein KI-Werkzeug ersetzt das eigenständige Denken.
Sie alle sind Spiegel – sie zeigen uns, was wir noch nicht wissen.
Den Code schreiben, das Konzept verstehen, den Fehler lösen –
das macht immer noch du.

📚 Weiterführende Links

• Google Gemini – Direkt starten
• Gemini Gems erstellen – Eigene Assistenten bauen
• Antigravity Dokumentation – Agent-System
• Rust-Buch – Die offizielle Rust-Referenz

🐙 GitHub Copilot – Der klassische KI-Assistent

Code-Vervollständigung der nächsten Generation – direkt im Editor.

GitHub Copilot war einer der ersten KI-Assistenten, die direkt im Code-Editor eingesetzt wurden. Er gilt als der „klassische Assistent“: Er schlägt Code vor, vervollständigt Funktionen und erklärt – aber er handelt nicht selbstständig.

In dieser Lektion lernen wir, wie GitHub Copilot funktioniert, wo er sich von modernen KI-Agenten unterscheidet und wie wir ihn sinnvoll beim Rust-Lernen einsetzen können.

Wichtig für Anfänger: Copilot ist ein Assistent, kein Agent. Er antwortet auf das, was du gerade tippst – er plant nicht, handelt nicht und liest keine Konfigurationsdateien. Das macht ihn einfacher – und in manchen Situationen auch nützlicher.

🧠 Theorie: Was ist GitHub Copilot?

GitHub Copilot ist ein KI-Assistent von GitHub und OpenAI. Er wurde auf Milliarden von Zeilen öffentlichen Codes trainiert und läuft als Plugin in deinem Editor.

Wie funktioniert Copilot?

Copilot analysiert Kontext in Echtzeit:

• Den Code, den du gerade schreibst
• Die Datei, in der du arbeitest
• Den Kommentar direkt über dem Cursor
• Den Dateinamen und die Programmiersprache

Daraus generiert er Vorschläge – einzelne Zeilen, ganze Funktionen oder sogar vollständige Klassen.

Die vier Copilot-Funktionen im Überblick

🔧 Wie Copilot denkt – ein Beispiel

Du schreibst in Rust:

#![allow(unused)]
fn main() {
// Berechne den Durchschnitt einer Liste von Zahlen
fn
}

Copilot sieht deinen Kommentar und schlägt sofort vor:

#![allow(unused)]
fn main() {
fn berechne_durchschnitt(zahlen: &[f64]) -> f64 {
    let summe: f64 = zahlen.iter().sum();
    summe / zahlen.len() as f64
}
}

Das ist das Prinzip: Kommentare sind deine Anweisungen. Je präziser der Kommentar, desto besser der Vorschlag.

📐 Copilot vs. KI-Agent – Was ist der Unterschied?

Die wichtigste Erkenntnis:

🤝 Copilot ist perfekt beim aktiven Tippen – er schlägt vor, du entscheidest.
🤖 Ein Agent ist perfekt für größere Aufgaben – er plant und handelt.

⌨️ Copilot-Shortcuts (in VS Code)

💡 Copilot richtig einsetzen – Best Practices

1. Kommentare als Anweisungen nutzen: Schreibe erst, was die Funktion tun soll, dann lass Copilot vorschlagen.
2. Vorschläge hinterfragen: Verstehe immer, was Copilot vorschlägt – übernimm keinen Code blind.
3. Namen als Hinweise: Gute Variablen- und Funktionsnamen führen zu besseren Vorschlägen.
4. Für Anfänger: Langsamer werden: Tippe bewusst langsam und lies jeden Vorschlag durch.
5. Copilot Chat für Erklärungen: Markiere fremden Code und frage „Was macht dieser Code?“

🛠️ Praxis-Aufgaben

Aufgabe A: Copilot kennenlernen

Installiere das GitHub Copilot Plugin in VS Code (oder Antigravity IDE):

1. Erweiterungen öffnen (Ctrl+Shift+X)
2. „GitHub Copilot“ suchen
3. Installieren und mit GitHub-Konto anmelden

Teste dann: Schreibe einen Kommentar auf Deutsch und lass Copilot eine Funktion vorschlagen.

#![allow(unused)]
fn main() {
// Gibt eine Begrüßungsnachricht mit dem übergebenen Namen zurück
fn
}

Aufgabe B: Vorschläge bewusst lesen

Lass Copilot einen Vorschlag machen – aber bevor du Tab drückst:

• Lies den gesamten Code durch
• Verstehe jede Zeile
• Frage dich: Würde ich das so schreiben?

Erst dann: annehmen oder ablehnen.

Aufgabe C: Copilot Chat nutzen

Markiere diesen Code im Editor:

#![allow(unused)]
fn main() {
let ergebnis: Result<i32, _> = "42abc".parse();
}

Öffne den Copilot Chat (Ctrl+I) und frage:

Erkläre mir, was hier passiert und warum Rust Result verwendet.

🚀 50 Rust-Projektvorschläge für GitHub Copilot

Diese Projekte sind speziell dafür gedacht, mit GitHub Copilot als klassischem Assistenten zu arbeiten. Schreibe immer erst einen Kommentar, der beschreibt, was du willst – dann lass Copilot vorschlagen und entscheide selbst.

🦀 Lernregel: Copilot darf vorschlagen – aber du musst jede Zeile verstehen.
Nimm keinen Vorschlag an, den du nicht erklären könntest!

🟢 Einstiegsprojekte (1–10)

1. Hallo, Welt! – Lass Copilot die klassische Begrüßung vorschlagen und experimentiere mit verschiedenen Ausgabeformaten.

2. Taschenrechner – Schreibe Kommentare für Addition, Subtraktion, Multiplikation und Division. Lass Copilot die Funktionen vorschlagen.

3. Temperatumrechner – Celsius ↔ Fahrenheit ↔ Kelvin. Schreibe je einen Kommentar pro Umrechnung.

4. Geradzahlen-Prüfer – Kommentiere: „Prüfe ob eine Zahl gerade ist“ – was schlägt Copilot vor?

5. Fibonacci-Folge – Lass Copilot eine rekursive und eine iterative Variante vorschlagen. Vergleiche beide.

6. Buchstaben zählen – Zähle, wie oft ein bestimmter Buchstabe in einem String vorkommt.

7. Palindrom-Prüfer – Schreibe den Kommentar, lass Copilot prüfen ob ein Wort rückwärts gleich ist.

8. Zahl erraten – Copilot schlägt eine Zufallszahl und eine Eingabeschleife vor. Du verstehst, warum.

9. Primzahl-Checker – Kommentiere die Logik schrittweise, beobachte Copilots Vorschläge.

10. Wörter zählen – Zähle die Wörter in einem eingegebenen Satz.

🟡 Mittlere Projekte (11–25)

11. Einkaufsliste – Eine Vektor-basierte Liste, die du ergänzen und ausgeben kannst.

12. Notenrechner – Gib Noten ein, berechne den Durchschnitt und das Prädikat.

13. Passwort-Stärke-Checker – Prüfe Länge, Sonderzeichen und Zahlen in einem Passwort.

14. Wechselgeldrechner – Berechne das optimale Wechselgeld (Scheine und Münzen).

15. Würfelspiel – Simuliere das Würfeln mit verschiedenen Würfeltypen (W6, W12, W20).

16. Binäre Suche – Implementiere mit Copilots Hilfe eine binäre Suche in einem sortierten Array.

17. Stack (Stapel) – Baue einen eigenen Stack mit push, pop und peek.

18. Wortverschlüsselung – Einfache Caesar-Chiffre: Buchstaben um N Stellen verschieben.

19. Einheitenrechner – Kilometer ↔ Meilen, Kilogramm ↔ Pfund, Liter ↔ Gallonen.

20. Körper-Maß-Index – Berechne BMI und zeige Kategorien an.

21. Countdown-Timer – Zähle von einer eingegebenen Zahl rückwärts bis 0.

22. Vokabeln abfragen – Speichere Deutsch-Englisch-Paare und prüfe das Wissen.

23. Lottozahlen – Ziehe 6 zufällige Zahlen aus 1–49, keine Duplikate.

24. Textstatistik – Zähle Buchstaben, Wörter, Sätze und berechne durchschnittliche Wortlänge.

25. Tic-Tac-Toe – Zwei Spieler im Terminal. Copilot hilft mit der Siegbedingung.

🔴 Fortgeschrittene Projekte (26–40)

26. Taschenrechner mit Fehlerbehandlung – Erweitere Projekt 2 um Result und sinnvolle Fehlermeldungen.

27. Kontaktbuch – Speichere Namen und Telefonnummern in einer HashMap.

28. Notiz-App – Füge Notizen hinzu, lösche sie, zeige alle an – alles im Terminal.

29. Budgetverwaltung – Einnahmen und Ausgaben buchen, Kontostand anzeigen.

30. Wortfrequenz-Analyse – Welches Wort kommt in einem Text am häufigsten vor?

31. Morse-Code – Konvertiere Text in Morsecode und zurück.

32. Bruchrechnung – Brüche addieren, subtrahieren, kürzen – mit eigenem Bruch-Struct.

33. Zahlenraten mit KI-Tipp – Die KI (simpler Algorithmus) rät die Zahl des Nutzers durch Fragen.

34. Matrix-Rechner – Addiere und multipliziere 2×2-Matrizen.

35. Anagramm-Prüfer – Sind zwei Wörter Anagramme voneinander?

36. Roman-Zahlen-Konverter – Arabische Zahlen in römische und zurück.

37. Bankkonto – Ein Struct mit Einzahlen, Abheben und Kontostand – mit Fehlern bei Überziehung.

38. Textadventure – Eine einfache Welt mit Räumen und Gegenständen – Copilot hilft bei der Struktur.

39. Zahlenformatierung – Zeige Zahlen mit Tausender-Trennzeichen an (1.000.000).

40. Stoppuhr – Miss, wie lange der Nutzer eine Eingabe benötigt.

⚡ Herausforderungsprojekte (41–50)

41. Vollständiger Student-Verwalter – Struct für Studenten, Noten speichern, Durchschnitt berechnen, Rangfolge ausgeben.

42. Einfache Datenbank im Speicher – Tabellen simulieren: Zeilen einfügen, suchen, löschen.

43. Taschenrechner mit Operator-Vorrang – Klammern und Punkt-vor-Strich korrekt berechnen.

44. Schiffe versenken – Terminal-Spiel für zwei Spieler mit Spielfeld-Ausgabe.

45. CSV-Parser – Lies eine CSV-Datei zeilenweise und gib strukturierte Daten aus.

46. Passwort-Generator – Erzeuge sichere Passwörter mit einstellbarer Länge und Zeichenvorrat.

47. Farbmischer – RGB-Farben mischen, HEX-Code ausgeben.

48. Reguläre Ausdrücke – Validiere E-Mail-Adressen oder Telefonnummern mit einem Pattern.

49. Mehrstufige Menü-App – Eine CLI-App mit Hauptmenü, Untermenüs und Navigation.

50. Eigenes Assembler-Spielzeug – Ein Mini-Interpreter, der einfache „Befehle“ wie ADD 5 3 ausführt.

💡 Zusammenfassung

🦀 Merke: Copilot ist kein Autopilot. Er schlägt vor – du programmierst.
Wer jeden Vorschlag versteht, lernt schneller als jemand, der blind annimmt.

📚 Weiterführende Links

• GitHub Copilot – Offizielle Seite
• Copilot in VS Code – Dokumentation
• Copilot Chat – Chat-Funktion erklärt
• Rust-Buch – Die offizielle Rust-Referenz

🤖 IDE KI-Agenten – Die nächste Generation

Wenn der Editor denkt, plant und handelt – nicht nur vorschlägt.

Während klassische Assistenten wie GitHub Copilot reagieren (auf deinen Cursor, deinen Kommentar, deinen Tastendruck), gehen IDE KI-Agenten einen entscheidenden Schritt weiter: Sie handeln.

Ein IDE KI-Agent kann Dateien öffnen, Terminal-Befehle ausführen, Fehler analysieren, Refactoring über mehrere Dateien hinweg durchführen und dabei immer im Blick behalten, was dein Projekt insgesamt braucht.

In dieser Lektion lernen wir, was IDE KI-Agenten ausmacht, wie wir sie beim Rust-Lernen sinnvoll einsetzen – und welche 50 Projekte sich besonders gut dafür eignen.

Für Anfänger: Ein IDE KI-Agent ist wie ein erfahrener Programmierkollege, der neben dir sitzt. Er kann selbstständig nachschauen, ausprobieren und Fehler beheben – aber du gibst immer die Richtung vor.

🧠 Theorie: Was ist ein IDE KI-Agent?

Der Unterschied: Assistent vs. Agent

Die entscheidende Frage: Wann will ich, dass die KI nur vorschlägt (Assistent), und wann soll sie selbst handeln (Agent)?

Bekannte IDE KI-Agenten (2025/2026)

🔍 Wie arbeitet ein IDE KI-Agent in Rust?

Ein typischer Workflow mit einem IDE-Agenten:

Du:    „Füge Fehlerbehandlung zu allen Funktionen in src/ hinzu"
           ↓
Agent: „Ich werde folgende Änderungen vornehmen:
        - main.rs: Zeile 12 – unwrap() durch ? ersetzen
        - utils.rs: Zeile 8 – Rückgabetyp auf Result<> ändern
        Soll ich fortfahren?"
           ↓
Du:    „Ja"
           ↓
Agent: Führt Änderungen in beiden Dateien aus, zeigt Diff

Das ist komplett anders als Copilot: Der Agent plant, erklärt und führt aus – nicht nur eine Zeile, sondern ein ganzes Vorhaben.

🧩 Typische Agent-Funktionen im IDE-Kontext

1. Planungsmodus (Plan before Act)

Der Agent erklärt erst, was er tun will, bevor er es tut.
Das gibt dir die Kontrolle und hilft dir, die Änderungen zu verstehen.

2. Diff-Ansicht

Jede Änderung wird rot/grün angezeigt – exakt wie in Git.
Du kannst Änderungen einzeln annehmen oder ablehnen.

3. Multi-File-Bearbeitung

Der Agent kann gleichzeitig in main.rs, lib.rs und Cargo.toml arbeiten.
Das ist für größere Refactorings unerlässlich.

4. Terminal-Integration

Der Agent führt cargo build, cargo test oder cargo clippy aus – und interpretiert die Ergebnisse.

5. Kontextfenster

Moderne Agenten „sehen“ das gesamte Projekt (alle Dateien, Projektstruktur, Fehlerausgaben).

🛡️ Wichtige Prinzipien beim Umgang mit IDE-Agenten

Als Anfänger besonders wichtig:

1. Immer Planungsmodus aktivieren – Verstehe, was der Agent vorhat, bevor er handelt.
2. Jede Änderung lesen – Der Diff ist dein bestes Lernwerkzeug.
3. Rückgängig machen üben – Ctrl+Z oder Git git revert retten dich.
4. Kleine Schritte bevorzugen – Lieber 5 kleine Aufgaben als eine große.
5. Fragen stellen – „Erkläre mir diese Änderung“ ist immer erlaubt.

🔄 Wann Agent, wann Assistent?

🛠️ Praxis-Aufgaben

Aufgabe A: Agent erkunden

Öffne die Antigravity IDE und navigiere in den Sidebar-Chat.
Stelle eine einfache Aufgabe:

Zeige mir die Struktur meines Projekts und erkläre mir,
welche Dateien wozu dienen.

Beobachte: Was „sieht“ der Agent? Welche Dateien listet er auf?

Aufgabe B: Planungsmodus testen

Stelle dem Agenten eine Aufgabe, die mehrere Dateien betrifft, und bitte ihn explizit:

Bevor du etwas änderst: Erstelle erst einen Plan,
was du tun willst. Ich möchte jeden Schritt verstehen.

Lies den Plan sorgfältig. Stimme zu oder korrigiere.

Aufgabe C: Diff lesen üben

Lass den Agenten eine kleine Änderung vornehmen – zum Beispiel einen Kommentar zu einer Funktion hinzufügen.
Öffne den Diff und lese, was genau geändert wurde.
Frage dann: „Warum hast du die Änderung genau so gemacht?“

🚀 50 Rust-Projektvorschläge für IDE KI-Agenten

Diese Projekte nutzen die Stärken eines Agenten: Planung, Projektstruktur, Multi-File, Terminal.
Lass den Agenten nicht sofort coden – lass ihn erst erklären, dann handeln.

🦀 Lernregel: Der Agent baut, aber du verstehst.
Frage nach jedem Schritt: „Was hast du gemacht und warum?“

🟢 Einstiegsprojekte (1–10)

1. Projekt-Setup durch den Agenten – Lass den Agenten ein neues Rust-Projekt mit cargo new erstellen, die Struktur erklären und eine erste hello_world-Funktion anlegen.

2. Kommentierter Starter-Code – Der Agent schreibt das Grundgerüst eines CLI-Programms und kommentiert jede Zeile für Anfänger.

3. Fehleranalyse-Session – Schreibe einen Rust-Fehler absichtlich. Der Agent führt cargo build aus, analysiert die Fehlermeldung und erklärt (ohne zu reparieren!).

4. Rustfmt automatisch – Der Agent führt cargo fmt aus und erklärt jeden Formatierungsschritt.

5. Clippy-Analyse – Der Agent führt cargo clippy aus und übersetzt jede Warnung ins Deutsche.

6. Modularisierung Schritt 1 – Eine einzelne main.rs aufteilen: Der Agent erstellt src/rechner.rs und verschiebt eine Funktion dorthin.

7. Cargo.toml erklärt – Der Agent analysiert deine Cargo.toml und erklärt jeden Eintrag auf Anfängerniveau.

8. Erste Tests schreiben – Der Agent erklärt die Test-Syntax in Rust und schreibt Testgerüste (ohne Assertions – die schreibst du).

9. Variablen und Typen – Der Agent zeigt durch eine kleine Demo-Datei, wie Rust Typen ableitet (let x = 5 vs. let x: i32 = 5).

10. Ownership visualisieren – Der Agent schreibt Beispielcode und erklärt mit Pfeilen (ASCII-Art in Kommentaren), wie Ownership übertragen wird.

🟡 Mittlere Projekte (11–25)

11. Vollständige Taschenrechner-App – Der Agent plant die Dateistruktur (main.rs, operations.rs, tests.rs) und erklärt, bevor er erstellt.

12. Struct-basierter Studentenverwaltung – Der Agent legt ein Struct an, erklärt Felder und implementiert grundlegende Methoden.

13. Trait implementieren – Der Agent implementiert das Display-Trait für ein eigenes Struct und erklärt die Syntax.

14. Enums mit Daten – Ein Enum für verschiedene Zahlungsarten – der Agent baut die Varianten und erklärt Pattern Matching.

15. Fehlerbehandlung mit Result – Der Agent nimmt eine unsichere Funktion und wandelt unwrap() in echte Fehlerbehandlung um.

16. Iteratoren verstehen – Der Agent schreibt Beispiele mit .map(), .filter(), .collect() und erklärt jeden Schritt.

17. Lifetime-Einführung – Der Agent erstellt einen minimalen Code mit Lifetimes und erklärt, warum der Compiler das fordert.

18. HashMap-Anwendung – Kontaktbuch mit HashMap<String, String> – der Agent plant Methoden für hinzufügen, suchen, löschen.

19. Datei schreiben/lesen – Der Agent erklärt std::fs und baut eine einfache Lese/Schreib-Demo.

20. Closures – Der Agent demonstriert Closures durch drei verschiedene Beispiele und vergleicht sie mit normalen Funktionen.

21. Command-Line-Argumente – Der Agent nutzt std::env::args() und baut ein Programm, das auf Argumente reagiert.

22. String-Verarbeitung – Der Agent zeigt alle wichtigen String-Methoden (split, trim, contains) in einem kommentierten Demo-Programm.

23. Mehrere Tests – Der Agent schreibt Unit-Tests für alle Funktionen des Taschenrechners aus Projekt 11.

24. Refactoring-Session – Der Agent nimmt deinen selbst geschriebenen Code und macht ihn „idiomatischer“ – mit Erklärung jeder Änderung.

25. Dokumentation mit /// – Der Agent ergänzt alle Funktionen mit Rust-Doc-Kommentaren und erklärt das Format.

🔴 Fortgeschrittene Projekte (26–40)

26. Bibliothek (lib.rs) – Der Agent trennt Logik von main.rs in eine lib.rs und erklärt pub und Sichtbarkeit.

27. Fehler-Typen definieren – Ein eigener enum Error – der Agent baut ihn und erklärt die Konventionen.

28. Generics einführen – Der Agent schreibt eine generische Funktion und erklärt die Syntax <T> Schritt für Schritt.

29. Trait-Objekte – Der Agent demonstriert dyn Trait und erklärt, wann statisches vs. dynamisches Dispatch sinnvoll ist.

30. Integration-Tests – Der Agent legt einen tests/-Ordner an und erklärt den Unterschied zu Unit-Tests.

31. Serde für JSON – Der Agent fügt serde zu Cargo.toml hinzu, erklärt die Dependency und serialisiert ein Struct.

32. Clap für CLI – Der Agent integriert clap für professionelle Kommandozeilen-Argumente.

33. Asynchrone Grundlagen – Der Agent erklärt async/await mit einem minimalen Beispiel und tokio als Runtime.

34. Channels zwischen Threads – Der Agent baut ein Beispiel mit std::sync::mpsc und erklärt das Konzept.

35. Arc und Mutex – Shared State zwischen Threads – der Agent erklärt, warum Rc nicht reicht.

36. Builder-Pattern – Der Agent implementiert das Builder-Pattern für ein komplexes Struct.

37. State-Machine – Eine einfache Zustandsmaschine mit Enums – der Agent plant die Zustände und Übergänge.

38. Prozesse spawnen – Der Agent nutzt std::process::Command und startet externe Programme.

39. Reguläre Ausdrücke mit regex – Der Agent integriert die regex-Crate und erklärt die Pattern-Syntax.

40. Benchmarks mit criterion – Der Agent richtet Benchmarks ein und erklärt, wie man Rust-Performance misst.

⚡ Herausforderungsprojekte (41–50)

41. Vollständige CLI-App mit Tests und Docs – Ein echtes Projekt: Struktur planen, Logik schreiben, Tests, Dokumentation, Clippy – alles mit Agent als Planungshelfer.

42. Eigene Datenstruktur – Eine einfache verkettete Liste in Rust – der Agent erklärt die Besonderheiten mit Ownership.

43. Makro schreiben – Der Agent zeigt macro_rules! und erstellt ein einfaches Utility-Makro.

44. Plugin-System – Dynamisch ladbare Funktionen über Traits – der Agent plant die Architektur.

45. Mini-Interpreter – Ein einfacher Interpreter für eine selbst definierte Sprache mit Ausdrücken und Variablen.

46. Datenbankanbindung – Der Agent integriert rusqlite (SQLite), erklärt Queries und führt Migrationen durch.

47. HTTP-Client – Mit reqwest eine öffentliche API abfragen und die Antwort parsen.

48. Websocket-Verbindung – Ein einfacher Websocket-Client mit tokio-tungstenite.

49. Eigene Derive-Makro – Der Agent erklärt Proc-Makros und baut ein einfaches #[derive(MyDebug)].

50. Projekt-Portfolio – Der Agent hilft, alle bisher gebauten Projekte in eine Bibliothek (Workspace) zu strukturieren und zu dokumentieren.

💡 Zusammenfassung

🦀 Merke: Ein IDE-Agent ist mächtiger als ein Assistent – aber Macht braucht Verantwortung.
Verstehe jede Änderung, die der Agent macht. Der Lerneffekt liegt im Diff!

📚 Weiterführende Links

• Cursor IDE – KI-first Editor auf VS Code-Basis
• Windsurf – Cascade-Agent-System
• Antigravity IDE Dokumentation – Antigravity IDE
• Rust-Buch – Die offizielle Rust-Referenz
• Cargo Guide – Projektverwaltung mit Cargo

🎵 Vibe Coding – Programmieren mit KI im Flow

Wenn die KI den Code schreibt – und du die Ideen hast.

„Vibe Coding“ ist ein Begriff, der 2025 durch den KI-Forscher Andrej Karpathy geprägt wurde. Er beschreibt einen Programmierstil, bei dem der Mensch Ideen, Richtung und Vision gibt – und die KI den Großteil des Codes schreibt.

In dieser Lektion lernen wir, was Vibe Coding bedeutet, welche Chancen und Risiken es birgt, und wie wir als Rust-Anfänger es bewusst und lernfördernd einsetzen können – ohne uns dabei zu verirren.

Wichtig für Anfänger: Vibe Coding ist weder gut noch schlecht. Es ist ein Werkzeug – wie ein Taschenrechner. Wer nicht rechnen kann, lernt nichts vom Taschenrechner. Wer rechnen kann, wird produktiver.
Lerne zuerst – vibe dann.

🧠 Theorie: Was ist Vibe Coding?

Das Konzept

Beim Vibe Coding lässt du die KI den Code fast vollständig schreiben. Du:

• Beschreibst das Problem auf natürliche Sprache
• Siehst den Output
• Testest, ob es funktioniert
• Sagst der KI, was noch fehlt oder falsch ist

Du schreibst selten selbst Code – du führst ein Gespräch mit der KI und beobachtest das Ergebnis.

Wie Andrej Karpathy es beschreibt

„I mostly just see stuff, say stuff, run stuff, and copy-paste stuff, and it mostly works.“
— Andrej Karpathy, 2025

Das klingt verlockend einfach. Aber Karpathy ist einer der führenden KI-Forscher der Welt – er versteht, was die KI macht, auch wenn er es nicht selbst tippt.

🎭 Vibe Coding in der Praxis – Der Ablauf

1. Du:    „Ich will eine CLI-App, die Wörter zählt."
      ↓
2. KI:    Schreibt vollständigen Code
      ↓
3. Du:    Führst aus → es funktioniert (oder nicht)
      ↓
4. Du:    „Das Programm zählt Leerzeilen auch – das soll nicht sein."
      ↓
5. KI:    Korrigiert den Code
      ↓
6. Du:    Führst wieder aus → iterierst weiter

Das ist Vibe Coding: Iteration durch Beschreibung, nicht durch Typen.

🌈 Die Stärken von Vibe Coding

⚠️ Die Risiken von Vibe Coding

🦀 Vibe Coding in Rust – Besondere Herausforderung

Rust ist keine gute Vibe-Coding-Sprache für Anfänger, die gar nichts verstehen.

Warum?

KI-Code in Python → läuft oft sofort
KI-Code in Rust   → scheitert oft am Borrow Checker

Der Rust-Compiler ist streng. Wenn du nicht verstehst, warum er sich beschwert, kannst du nicht sinnvoll mit der KI iterieren.

Die goldene Regel:

🦀 Vibe Code in Rust erst, wenn du Ownership, Borrowing und Lifetimes grundlegend verstanden hast.
Dann wird Vibe Coding ein mächtiges Werkzeug – nicht ein Frustrations-Generator.

🔄 Drei Arten des Vibe Codings

1. Exploratives Vibe Coding

Ziel: Ein unbekanntes Konzept durch Beispiele verstehen.

„Zeig mir, wie Iteratoren in Rust funktionieren.
Schreibe 3 verschiedene Beispiele, die .map() nutzen."

→ Du siehst Code, analysierst ihn, lernst das Muster.

2. Produktives Vibe Coding

Ziel: Ein Projekt schnell aufbauen, das du dann lernend weiterentwickelst.

„Baue eine CLI-App mit clap, die Dateien umbenennt.
Erkläre den Code danach Zeile für Zeile."

→ Du bekommst eine Basis und arbeitest dich in den Code ein.

3. Iteratives Vibe Coding

Ziel: Funktionierenden Code schrittweise verbessern.

„Das hier ist mein Code. Was würde Clippy bemängeln?
Verbessere es – aber erkläre jede Änderung."

→ Du iterierst mit der KI wie mit einem Code-Reviewer.

🧭 Der Lernende Vibe-Coder – Ein Manifest

Wenn du als Anfänger Vibe Coding nutzt, halte dich an diese Regeln:

1. Niemals blind kopieren – Jeden Code, den die KI schreibt, verstehen.
2. Den KI-Code erklären lassen – „Erkläre mir diesen Code Zeile für Zeile.“
3. Eigene Tests schreiben – Teste, ob du den Code wirklich verstehst.
4. Fehler selbst analysieren – Wenn Cargo sich beschwert: erst selbst denken.
5. Regelmäßig ohne KI üben – Mindestens 20% des Codes selbst schreiben.

🛠️ Praxis-Aufgaben

Aufgabe A: Explorations-Session

Starte einen Chat mit dem Agenten und sage:

Ich lerne Rust. Zeig mir drei verschiedene Möglichkeiten,
eine Liste von Zahlen zu summieren. Erkläre die Unterschiede.
Schreibe nur Code mit ausführlichen Kommentaren.

→ Lies jeden Code durch. Tippe den Code selbst ab (kein Copy-Paste!).

Aufgabe B: Vibe Coding mit Analyse

Lass die KI eine kleine Funktion schreiben:

Schreibe eine Rust-Funktion, die prüft ob ein String
eine gültige E-Mail-Adresse ist (einfache Prüfung ohne Regex).

Dann: Erkläre die Funktion selbst, ohne auf den Code zu schauen.
Wenn du nicht kannst: Lies nochmal, verstehe, erkläre erneut.

Aufgabe C: Bewusster Stopp

Fange an, Vibe Coding zu nutzen – aber setze eine Regel:

Nach jedem 3. KI-Output: Schreibe die nächste Funktion selbst,
ohne KI-Hilfe.

Beobachte: Wie verändert sich dein Verständnis?

🚀 50 Rust-Projektvorschläge für Vibe Coding

Diese Projekte sind dafür gedacht, mit iterativem Dialog mit der KI umgesetzt zu werden. Du beschreibst, die KI schreibt, du analysierst und verstehst.

🦀 Lernregel: Für jedes Projekt gilt: Du bekommst den Code – aber du erklärst ihn.
Sage laut, was jede Zeile tut. Wenn du stockst: Frage, höre zu, probiere aus.

🟢 Einstiegs-Vibe-Projekte (1–10)

1. Die Erklärer-App – Lass die KI eine Funktion schreiben und dann sich selbst erklären: „Erkläre mir diesen Code so, als wäre ich 10 Jahre alt.“

2. Fehler absichtlich bauen – Bitte die KI, Code zu schreiben, der einen spezifischen Rust-Fehler provoziert. Dann verstehe den Fehler.

3. Ownership-Visualisierer – Die KI schreibt Code mit ASCII-Diagrammen in Kommentaren, die Ownership zeigen.

4. Analogie-Programm – Bitte um Code zu einem Konzept plus einer Alltagsanalogie in Kommentaren.

5. Code-Vergleicher – Lass die KI dasselbe Problem auf drei Arten lösen: mit Schleife, mit Iterator, mit Rekursion.

6. Kommentier-Challenge – Die KI schreibt Code ohne Kommentare. Du schreibst die Kommentare selbst.

7. Reparier-Übung – Bitte die KI, Code zu schreiben, der absichtlich einen Fehler enthält. Finde und repariere ihn selbst.

8. Typ-Quiz – Die KI schreibt Variablen ohne Typ-Annotationen. Du fügst sie hinzu und lässt danach prüfen.

9. Refactor-Session – Gib der KI schlechten, unleserlichen Code. Lass ihn verbessern und erkläre, warum jede Änderung sinnvoll ist.

10. Mini-Spiel erklärt – Die KI baut ein Würfelspiel (10 Zeilen) und erklärt alles in Extra-Kommentaren.

🟡 Mittlere Vibe-Projekte (11–25)

11. Persönlicher Assistent – Eine CLI-App, die Notizen mit Datum speichert. Du beschreibst die Funktion – die KI baut, du analysierst.

12. Quiz-App – Die KI baut eine Multiple-Choice-Quiz-App. Du verstehst, wie Vektoren von Structs funktionieren.

13. Habit-Tracker – Täglich erledigte Aufgaben markieren und Statistiken ausgeben.

14. Rezept-Manager – Zutaten und Mengen verwalten – die KI plant das Daten-Modell, du verstehst die Structs.

15. Tagesplan-App – Aufgaben mit Zeitfenstern – Prioritäten, Ausgabe, Sortierung.

16. Wetter-Simulator – Zufällige Wetterdaten generieren und auswerten (ohne echte API).

17. Sparschwein-Rechner – Monatlich sparen, Zinsen berechnen, Ziel erreichen – mit Diagramm im Terminal.

18. Horoskop-Generator – Sternzeichen eingeben, zufällige Vorhersage ausgeben. Wichtig: Wie funktioniert der Zufall in Rust?

19. Morse-Code-Übersetzer – Deutsch → Morse → Deutsch. Die KI baut, du verstehst match.

20. Kalorienzähler – Mahlzeiten eingeben, Kalorien summieren, Tagesziel vergleichen.

21. Farb-Mixer – RGB-Werte mischen und den resultierenden Farbton beschreiben.

22. Tippgeschwindigkeit-Test – Zeit messen, wie lange der Nutzer braucht, einen Text abzutippen.

23. Schulnotenrechner – Noten eingeben, Durchschnitt, Bestanden/Nicht Bestanden, Statistiken.

24. Mini-Bibliothek – Bücher verwalten: Titel, Autor, ISBN, Ausgeliehen/Verfügbar.

25. Sprichwort-App – Zufällige Sprichwörter ausgeben – Vektoren, Zufallszahlen, Indexierung.

🔴 Fortgeschrittene Vibe-Projekte (26–40)

26. To-Do-CLI mit Dateispeicherung – Die KI baut eine vollständige To-Do-App, die in einer Datei speichert. Du verstehst fs::read_to_string und fs::write.

27. Zeiterfassung – Zeiten für Projekte erfassen, Berichte ausgeben – du lernst chrono.

28. Passwort-Vault – Passwörter mit einem Master-Passwort verschlüsseln. Du lernst Hashing-Konzepte.

29. RSS-Feed-Reader – Eine URL abrufen, XML-Daten parsen, Nachrichten ausgeben.

30. JSON-Datei-Editor – JSON laden, Werte ändern, wieder speichern – serde_json im Einsatz.

31. Markdown-zu-HTML – Einfache Markdown-Regeln (Überschriften, fett, kursiv) in HTML umwandeln.

32. Datei-Duplikat-Finder – Alle Dateien in einem Ordner auf Duplikate prüfen (via Hash).

33. Git-Log-Analyse – git log parsen und Statistiken ausgeben (wer hat wie oft committed?).

34. Terminal-Dashboard – Systeminfos (CPU, RAM, Laufzeit) im Terminal anzeigen.

35. Spell-Checker (simpel) – Wörter gegen eine Wortliste prüfen, Ähnlichkeiten vorschlagen.

36. Verschlüsselungs-App – XOR-Verschlüsselung für Dateien – die KI erklärt Bitoperationen.

37. Dependency-Analyzer – Cargo.toml lesen und alle Dependencies auflisten.

38. Code-Zähler – Zeilen Code, Kommentare und Leerzeilen in einer Rust-Datei zählen.

39. Konfigurations-Loader – Eine .toml-Datei einlesen und Einstellungen anwenden.

40. Web-Scraper (simpel) – Eine Webseite herunterladen und Text-Inhalte extrahieren.

⚡ Vibe-Coding-Herausforderungen (41–50)

41. Vollständige Blog-Engine (CLI) – Beiträge erstellen, bearbeiten, löschen, ausgeben – alles im Terminal, alles in Dateien gespeichert.

42. Mini-Datenbank – Eine einfache Key-Value-Datenbank, die in einer Datei speichert. Du lernst Serialisierung.

43. Aufgaben-Scheduler – Tasks mit Zeitplan eintragen, zu bestimmten Zeiten als fällig markieren.

44. Multi-User-Notizen – Mehrere Nutzerprofile, je eigene Notizen – HashMap<String, Vec<String>>.

45. Spielwelt-Generator – Zufällige Karte generieren, auf der du durch Räume wandern kannst.

46. Sprachtrainer – Vokabeln mit Lernstatistik – wie oft richtig, wie oft falsch, welche Strategie?

47. Pomodoro-Timer – Arbeits- und Pausenintervalle messen und anzeigen.

48. KI-Tagebuch – Du schreibst Einträge, die KI fasst wöchentlich zusammen (als simulierte KI-Funktion im Code).

49. Einfaches Betriebssystem-Spielzeug – Ein Mini-Shell, das Befehle wie ls, echo und pwd simuliert.

50. Dein Vibe-Coding-Abschlussprojekt – Beschreibe der KI deine eigene Idee. Lass sie bauen. Verstehe alles. Präsentiere es.

🔍 Vibe Coding im Vergleich

💡 Zusammenfassung

🦀 Die wichtigste Lektion:
Vibe Coding ist kein Abkürzung vom Lernen.
Es ist eine andere Art, zu lernen – wenn du dabei aktiv bleibst.
Wer vibecoded und dabei denkt, lernt schnell.
Wer vibecoded und dabei schläft, lernt nichts.

📚 Weiterführende Links

• Andrej Karpathy über Vibe Coding – Der Ursprung des Begriffs
• Rust-Buch – Ohne Grundlagen kein gutes Vibe Coding
• Antigravity IDE – Vibe Coding mit Agentenunterstützung
• Cursor – Einer der beliebtesten Vibe-Coding-Editoren
• Rust Playground – Vibe Coding ohne lokale Installation testen

🧠 Eigene KI-Agenten programmieren – Theorie & Praxis

Von der Idee zum eigenen intelligenten Agenten – in Rust.

Du hast Antigravity genutzt, mit Copilot gearbeitet, Vibe Coding ausprobiert. Jetzt kommt die nächste Stufe:
Du baust deinen eigenen KI-Agenten.

Das klingt nach Science-Fiction – ist es aber nicht. Ein KI-Agent ist im Kern ein Programm, das:

1. Wahrnehmung hat (Input: Text, Dateien, APIs)
2. Entscheidungen trifft (Logik, KI-Modell, Regeln)
3. Handlungen ausführt (Output: Text, Dateien, Terminal-Befehle)

In dieser Lektion lernst du die Theorie dahinter – und baust Schritt für Schritt deinen eigenen Agenten in Rust.

Für Anfänger: Du musst kein KI-Forscher sein, um einen Agenten zu bauen.
Die meisten modernen Agenten nutzen einfach eine API – du rufst ein KI-Modell auf und gibst dem Ergebnis Struktur.
Das ist Rust-Programmierung – keine Magie.

🧠 Theorie: Was ist ein KI-Agent?

Die klassische Definition

Ein KI-Agent ist ein System, das:

┌─────────────────────────────────────────┐
│                                         │
│   Umgebung  →  Agent  →  Aktion         │
│                  ↑                      │
│              Wahrnehmung                │
│                                         │
└─────────────────────────────────────────┘

• Wahrnehmung: Was sieht/hört/liest der Agent?
• Entscheidung: Was soll er tun?
• Aktion: Was tut er tatsächlich?

🔄 Der Agent-Loop

Moderne KI-Agenten arbeiten in einem Schleifenprinzip:

1. WAHRNEHMEN  →  User-Input, Datei lesen, API abfragen
2. DENKEN      →  KI-Modell aufrufen, Ergebnis analysieren
3. HANDELN     →  Datei schreiben, Terminal, Antwort geben
4. BEOBACHTEN  →  Was ist das Ergebnis der Aktion?
5. WIEDERHOLEN →  Zurück zu Schritt 1

Das nennt sich der ReAct-Loop (Reason + Act) – das Grundprinzip hinter Antigravity, Cursor und fast allen modernen Agenten.

🏗️ Architektur eines einfachen Agenten

┌──────────────────────────────────────────────┐
│                  Mein Agent                  │
│                                              │
│  ┌──────────┐   ┌──────────┐  ┌──────────┐  │
│  │  Input-  │   │  KI-    │  │ Output-  │  │
│  │ Handler  │ → │ Modul   │→ │ Handler  │  │
│  └──────────┘   └──────────┘  └──────────┘  │
│                      │                       │
│              ┌───────────────┐               │
│              │   Werkzeuge   │               │
│              │ (Tools/Fns)   │               │
│              │ - Datei lesen │               │
│              │ - HTTP-Call   │               │
│              │ - Terminal    │               │
│              └───────────────┘               │
└──────────────────────────────────────────────┘

🔑 Die vier Schlüssel-Konzepte

1. Das Sprachmodell (LLM)

Das „Gehirn“ des Agenten. Du rufst es über eine API auf:

• OpenAI GPT (über api.openai.com)
• Google Gemini (über generativelanguage.googleapis.com)
• Anthropic Claude (über api.anthropic.com)
• Lokale Modelle: Ollama (kein API-Key nötig!)

2. Der Kontext (System-Prompt)

Was du dem Modell vor dem Nutzer-Input sagst:

"Du bist ein Assistent, der Rust-Code erklärt.
 Antworte immer auf Deutsch.
 Schreibe keinen fertigen Code."

Das ist im Grunde: AGENTS.md in Textform.

3. Die Werkzeuge (Tools / Functions)

Was der Agent tun kann – über Funktionen, die du definierst:

#![allow(unused)]
fn main() {
// Werkzeug: Datei lesen
fn lese_datei(pfad: &str) -> String { ... }

// Werkzeug: Web-Suche
fn suche_web(query: &str) -> String { ... }

// Werkzeug: Terminal-Befehl
fn fuehre_aus(befehl: &str) -> String { ... }
}

4. Das Gedächtnis (Memory)

Wie der Agent sich erinnert:

• Kurzzeitgedächtnis: Der Chat-Verlauf (Vec<Message>)
• Langzeitgedächtnis: Dateien, Datenbank, Vektordatenbank

🦀 Warum Rust für Agenten?

🌐 API-Aufrufe in Rust – Das Grundprinzip

#![allow(unused)]
fn main() {
// Mit der reqwest-Crate (HTTP-Client)
// Cargo.toml: reqwest = { version = "0.11", features = ["json"] }
//             tokio = { version = "1", features = ["full"] }
//             serde = { version = "1", features = ["derive"] }

// So sieht ein API-Aufruf aus (Grundstruktur):
// 1. Request aufbauen (JSON mit Prompt)
// 2. An API senden (POST-Request)
// 3. Antwort empfangen (JSON parsen)
// 4. Text extrahieren und anzeigen
}

Für Anfänger: Du musst kein HTTP-Experte sein. Die Beispiele in den Projekten zeigen dir die Struktur Schritt für Schritt.

🔧 Werkzeuge (Tools) – Wie Agenten handeln

Modern KI-APIs unterstützen Function Calling: Du definierst Werkzeuge, und das Modell entscheidet, wann es sie einsetzt.

Du:     „Wie viele Zeilen hat meine main.rs?"
Agent:  [Denkt: Ich brauche das Werkzeug 'lese_datei']
        [Ruft auf: lese_datei("src/main.rs")]
        [Bekommt: Dateiinhalt mit 47 Zeilen]
Agent:  „Deine main.rs hat 47 Zeilen."

Das ist der Kern eines echten Agenten – nicht nur antworten, sondern handeln.

📦 Wichtige Rust-Crates für Agenten

🔐 API-Keys – Sicher speichern

# .env-Datei anlegen (NIEMALS in Git committen!)
OPENAI_API_KEY=sk-...
GEMINI_API_KEY=AIza...

# .gitignore:
.env

#![allow(unused)]
fn main() {
// In Rust laden:
// dotenv::dotenv().ok();
// let api_key = std::env::var("OPENAI_API_KEY").expect("API-Key fehlt!");
}

🏛️ Agent-Typen – Eine Übersicht

🛠️ Praxis-Aufgaben vor den Projekten

Aufgabe A: Ollama lokal einrichten

Installiere Ollama – damit brauchst du keinen API-Key:

# Ollama installieren (Linux)
curl -fsSL https://ollama.ai/install.sh | sh

# Ein Modell herunterladen
ollama pull llama3.2

# Testen
ollama run llama3.2 "Erkläre mir Ownership in Rust in einem Satz."

Ollama läuft lokal auf http://localhost:11434 – vollständig offline!

Aufgabe B: Erste API-Struktur verstehen

Schaue dir an, wie eine Anfrage an Ollama aufgebaut ist:

{
  "model": "llama3.2",
  "prompt": "Was ist Rust Ownership?",
  "stream": false
}

Und die Antwort:

{
  "response": "Ownership ist Rusts Speicherverwaltungskonzept...",
  "done": true
}

Das ist alles, was du brauchst! JSON rein, JSON raus.

Aufgabe C: cargo new agent

Erstelle dein erstes Agent-Projekt:

cargo new mein-agent
cd mein-agent

Füge in Cargo.toml hinzu:

[dependencies]
reqwest = { version = "0.11", features = ["json", "blocking"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

🚀 50 Rust-Projektvorschläge – Eigene KI-Agenten

Diese 50 Projekte führen dich vom einfachsten Chatbot bis zum vollständigen Multi-Agenten-System.
Jedes Projekt baut auf dem vorherigen auf – du sammelst Baustein für Baustein.

🦀 Lernregel: Verstehe jedes Projekt vollständig, bevor du zum nächsten gehst.
Ein selbst gebauter Agent, den du verstehst, ist wertvoller als 10 kopierte.

🟢 Einstiegsprojekte – Erste Schritte (1–10)

1. Hello, Ollama! – Der einfachste Agent: Sende einen festen Prompt an Ollama und gib die Antwort aus. Lerne reqwest::blocking und JSON-Parsing.

2. Interaktiver Chatbot – Lies Eingaben vom Terminal in einer Schleife und sende sie an Ollama. Dein erster echter Chatbot!

3. Persönlichkeit geben – Füge einen System-Prompt hinzu, der dem Agenten eine Rolle gibt (z. B. „Du bist ein freundlicher Rust-Tutor“).

4. Chat-Verlauf – Speichere alle Nachrichten in einem Vec<Message> und sende den gesamten Verlauf bei jeder Anfrage mit. Jetzt erinnert sich der Agent!

5. Farbige Ausgabe – Nutze die colored-Crate, um Nutzer-Text und Agenten-Text in verschiedenen Farben anzuzeigen.

6. Eingabe-Prompt verbessern – Nutze rustyline für eine professionelle Eingabe mit Pfeil-Tasten-History wie im echten Terminal.

7. Konfigurationsdatei – Lade Modell-Name und System-Prompt aus einer config.toml-Datei statt fest im Code.

8. Streaming-Antworten – Statt auf die komplette Antwort zu warten: Gib Wort für Wort aus, sobald es ankommt (wie ChatGPT).

9. Token-Zähler – Zeige nach jeder Antwort an, wie viele Wörter/Tokens die Konversation bisher hat.

10. Mehrere Modelle – Lass den Nutzer zu Beginn wählen: llama3.2, mistral oder gemma. Lerne, Argumente zu verarbeiten.

🟡 Werkzeuge (Tools) – Agent lernt zu handeln (11–25)

11. Datei-Lese-Werkzeug – Der Agent kann Dateipfade erkennen (z. B. „@main.rs“) und den Inhalt automatisch anhängen.

12. Taschenrechner-Werkzeug – Der Agent erkennt Rechenaufgaben im Text und löst sie mit echtem Rust-Code (nicht vom Modell!).

13. Datum/Zeit-Werkzeug – Wenn der Nutzer nach dem Datum fragt, ruft der Agent eine Funktion auf statt zu raten.

14. Wörterbuch-Werkzeug – Der Agent schlägt unbekannte Wörter in einer lokalen Textdatei nach.

15. Datei-Schreib-Werkzeug – Der Agent kann Dateien erstellen, wenn der Nutzer sagt „Erstelle eine Datei notes.md mit…“.

16. Verzeichnis-Werkzeug – Der Agent listet Dateien in einem Ordner auf und kann damit auf Fragen über Projektstruktur antworten.

17. Terminal-Werkzeug – Der Agent führt einfache Befehle aus (ls, cargo build) und gibt das Ergebnis zurück.

18. Wetter-Werkzeug (simuliert) – Eine Funktion gibt zufällige Wetterdaten zurück. Der Agent nutzt sie, wenn nach dem Wetter gefragt wird.

19. Wikipedia-Werkzeug – Rufe die Wikipedia-API ab und gib dem Agenten Zugriff auf Definitionen und Erklärungen.

20. Mehrere Werkzeuge kombinieren – Der Agent hat nun 3–5 Werkzeuge. Schreibe Logik, die erkennt, welches Werkzeug gebraucht wird.

21. Werkzeug-Protokoll – Zeige dem Nutzer, welches Werkzeug der Agent verwendet hat und warum (Transparenz!).

22. Werkzeug-Genehmigung – Bevor der Agent ein Werkzeug nutzt, fragt er: „Darf ich cargo build ausführen? [j/n]“

23. Werkzeug-Fehlerbehandlung – Was passiert, wenn ein Werkzeug fehlschlägt? Baue robuste Result-Behandlung ein.

24. Dynamische Werkzeuge – Lade Werkzeuge aus einer Konfigurationsdatei statt sie hart im Code zu haben.

25. Werkzeug-Statistik – Zeige am Ende einer Session, welches Werkzeug wie oft verwendet wurde.

🔴 Spezialisierte Agenten (26–40)

26. Rust-Tutor-Agent – Ein Agent, der ausschließlich Rust erklärt. System-Prompt: keine Code-Lösungen, nur Konzepte und Fragen.

27. Code-Review-Agent – Der Agent liest eine Rust-Datei und gibt Feedback zu Stil, Fehlerbehandlung und Klarheit.

28. Dokumentations-Agent – Liest eine Rust-Datei und schreibt ///-Dokumentationskommentare für alle Funktionen.

29. Fehler-Erklärer-Agent – Der Nutzer gibt einen cargo-Fehler ein, der Agent erklärt ihn auf Deutsch und gibt Hinweise.

30. Commit-Message-Agent – Liest git diff und schlägt eine sinnvolle Commit-Message vor.

31. Test-Generator-Agent – Liest eine Funktion und schlägt Testfälle vor (Grenzfälle, Normalfälle, Fehlerfälle).

32. Refactoring-Agent – Analysiert Code und schlägt Verbesserungen vor: bessere Namen, kürzere Funktionen, mehr Rust-Idiome.

33. README-Generator-Agent – Liest ein Rust-Projekt und erstellt automatisch eine README.md.

34. Lernplan-Agent – Der Nutzer gibt sein Ziel an, der Agent erstellt einen strukturierten Lernplan für Rust.

35. Frage-Antwort-Agent (RAG) – Der Agent sucht in einem lokalen Rust-Buch (als Textdateien) nach Antworten.

36. Notiz-Agent – Nimmt Notizen entgegen, speichert sie strukturiert und kann nach Themen suchen.

37. Übersetzungs-Agent – Übersetzt Rust-Fehlermeldungen und Dokumentation auf Deutsch.

38. Code-Kommentar-Agent – Liest unkommentierten Code und fügt hilfreiche Deutsche Kommentare ein.

39. Dependency-Checker-Agent – Analysiert Cargo.toml und prüft, ob neuere Versionen verfügbar sind (via crates.io API).

40. Interview-Agent – Stellt dem Nutzer Fragen zu einem Rust-Konzept – wie ein Lehrer im Sokrates-Stil.

⚡ Fortgeschrittene Agenten-Systeme (41–50)

41. Gedächtnis mit Datei – Der Chat-Verlauf wird in einer JSON-Datei gespeichert und beim nächsten Start geladen. Echter Langzeitspeicher!

42. Mehrsprachiger Agent – Der Agent erkennt die Sprache des Nutzers automatisch und antwortet in derselben Sprache.

43. Agent mit Persönlichkeitsprofilen – Wähle beim Start ein Profil: „Strenger Lehrer“, „Geduldiger Mentor“, „Enthusiastischer Anfänger“.

44. Async Multi-API-Agent – Sende dieselbe Frage gleichzeitig an Ollama und eine andere API, vergleiche die Antworten.

45. Planer-Agent – Der Agent zerlegt eine große Aufgabe in Teilschritte und arbeitet sie nacheinander ab (ReAct-Loop).

46. Kritiker-Agent – Zwei Agenten: Einer schlägt vor, der andere kritisiert. Der Nutzer entscheidet.

47. Spezialisierungs-Router – Ein „Master“-Agent, der entscheidet, welcher Spezialist-Agent die Aufgabe übernimmt.

48. Agent mit Vektordatenbank – Speichere Text-Chunks als Embeddings, suche ähnliche Texte bei jeder Anfrage.

49. Selbst-verbessernder Agent – Der Agent kann seine eigene Konfigurationsdatei (System-Prompt) anpassen, wenn du ihm sagst, was er besser machen soll.

50. Vollständiger Antigravity-Klon (Mini) – Baue einen eigenen kleinen KI-Agenten mit: Chat-Loop, Datei-Werkzeug, Terminal-Werkzeug, Verlauf-Speicher und farbiger Ausgabe. Dein eigenes agy!

🗺️ Lernpfad – So gehst du vor

Projekte 1–5:    Grundstruktur verstehen (API, JSON, Loop)
     ↓
Projekte 6–10:   Benutzerfreundlichkeit (Input, Config, Streaming)
     ↓
Projekte 11–15:  Erste Werkzeuge (Dateien, Rechnen, Zeit)
     ↓
Projekte 16–25:  Werkzeug-System aufbauen (Mehrere, Fehler, Genehmigung)
     ↓
Projekte 26–35:  Spezialisierte Agenten (Tutor, Review, RAG)
     ↓
Projekte 36–45:  Fortgeschrittene Techniken (Gedächtnis, Async, Multi-Agent)
     ↓
Projekte 46–50:  Vollständige Systeme (Router, Planer, Mini-Antigravity)

🔍 Agenten vs. klassische Programme

💡 Zusammenfassung

🦀 Die größte Erkenntnis:
Antigravity, Cursor, ChatGPT-Plugins – sie alle folgen demselben Prinzip.
Du kannst das auch bauen.
Ein Agent ist keine Magie – er ist ein Programm, das ein KI-Modell aufruft und das Ergebnis sinnvoll nutzt.
Und du kennst jetzt alle Zutaten. 🚀

📚 Weiterführende Links

• Ollama – Lokale KI-Modelle, kein API-Key
• Ollama API Docs – REST-API-Referenz
• OpenAI API – GPT-Modelle via API
• Google Gemini API – Gemini via API nutzen
• reqwest Docs – HTTP in Rust
• serde Docs – Serialisierung in Rust
• Rust Async Book – Async/Await verstehen
• LangChain Konzepte – Agent-Konzepte (in Python, aber übertragbar)

Impressum

Angaben gemäß § 5 TMG

• Thorsten Klöhn
• Gerhardstraße 2
• 22926 Ahrensburg

Vertreten durch:

Thorsten Klöhn

Kontakt:

• Telefon: 04102-2 17 40 07\
• E-Mail: thorstenkloehn@gmail.com

Haftungsausschluss:

Haftung für Inhalte

Die Inhalte unserer Seiten wurden mit größter Sorgfalt erstellt. Für die Richtigkeit, Vollständigkeit und Aktualität der Inhalte können wir jedoch keine Gewähr übernehmen. Als Diensteanbieter sind wir gemäß § 7 Abs.1 TMG für eigene Inhalte auf diesen Seiten nach den allgemeinen Gesetzen verantwortlich. Nach §§ 8 bis 10 TMG sind wir als Diensteanbieter jedoch nicht verpflichtet, übermittelte oder gespeicherte fremde Informationen zu überwachen oder nach Umständen zu forschen, die auf eine rechtswidrige Tätigkeit hinweisen. Verpflichtungen zur Entfernung oder Sperrung der Nutzung von Informationen nach den allgemeinen Gesetzen bleiben hiervon unberührt. Eine diesbezügliche Haftung ist jedoch erst ab dem Zeitpunkt der Kenntnis einer konkreten Rechtsverletzung möglich. Bei Bekanntwerden von entsprechenden Rechtsverletzungen werden wir diese Inhalte umgehend entfernen.

Haftung für Links

Unser Angebot enthält Links zu externen Webseiten Dritter, auf deren Inhalte wir keinen Einfluss haben. Deshalb können wir für diese fremden Inhalte auch keine Gewähr übernehmen. Für die Inhalte der verlinkten Seiten ist stets der jeweilige Anbieter oder Betreiber der Seiten verantwortlich. Die verlinkten Seiten wurden zum Zeitpunkt der Verlinkung auf mögliche Rechtsverstöße überprüft. Rechtswidrige Inhalte waren zum Zeitpunkt der Verlinkung nicht erkennbar. Eine permanente inhaltliche Kontrolle der verlinkten Seiten ist jedoch ohne konkrete Anhaltspunkte einer Rechtsverletzung nicht zumutbar. Bei Bekanntwerden von Rechtsverletzungen werden wir derartige Links umgehend entfernen.\

Urheberrecht

Dieses Werk ist lizenziert unter einer Creative Commons Namensnennung 4.0 International Lizenz.Soweit die Inhalte auf dieser Seite nicht vom Betreiber erstellt wurden, werden die Urheberrechte Dritter beachtet. Insbesondere werden Inhalte Dritter als solche gekennzeichnet. Sollten Sie trotzdem auf eine Urheberrechtsverletzung aufmerksam werden, bitten wir um einen entsprechenden Hinweis. Bei Bekanntwerden von Rechtsverletzungen werden wir derartige Inhalte umgehend entfernen.

Datenschutz

Die Nutzung unserer Webseite ist in der Regel ohne Angabe personenbezogener Daten möglich. Soweit auf unseren Seiten personenbezogene Daten (beispielsweise Name, Anschrift oder eMail-Adressen) erhoben werden, erfolgt dies, soweit möglich, stets auf freiwilliger Basis. Diese Daten werden ohne Ihre ausdrückliche Zustimmung nicht an Dritte weitergegeben.
Wir weisen darauf hin, dass die Datenübertragung im Internet (z.B. bei der Kommunikation per E-Mail) Sicherheitslücken aufweisen kann. Ein lückenloser Schutz der Daten vor dem Zugriff durch Dritte ist nicht möglich. Der Nutzung von im Rahmen der Impressumspflicht veröffentlichten Kontaktdaten durch Dritte zur Übersendung von nicht ausdrücklich angeforderter Werbung und Informationsmaterialien wird hiermit ausdrücklich widersprochen. Die Betreiber der Seiten behalten sich ausdrücklich rechtliche Schritte im Falle der unverlangten Zusendung von Werbeinformationen, etwa durch Spam-Mails, vor.\

Impressum vom Impressum Generator der [Kanzlei Hasselbach, Rechtsanwälte für Arbeitsrecht und Familienrecht](https://www.kanzlei-hasselbach

Datenschutz

Verantwortliche Stelle im Sinne der Datenschutzgesetze, insbesondere der EU-Datenschutzgrundverordnung (DSGVO), ist:

• Thorsten Klöhn
• Gerhardstraße 2
• 22926 Ahrensburg
• Telefon: 04102-2 17 40 07
• e-Mail: thorstenkloehn@gmail.com

Ihre Betroffenenrechte

Unter den angegebenen Kontaktdaten unseres Datenschutzbeauftragten können Sie jederzeit folgende Rechte ausüben:

• Auskunft über Ihre bei uns gespeicherten Daten und deren Verarbeitung (Art. 15 DSGVO),
• Berichtigung unrichtiger personenbezogener Daten (Art. 16 DSGVO),
• Löschung Ihrer bei uns gespeicherten Daten (Art. 17 DSGVO),
• Einschränkung der Datenverarbeitung, sofern wir Ihre Daten aufgrund gesetzlicher Pflichten noch nicht löschen dürfen (Art. 18 DSGVO),
• Widerspruch gegen die Verarbeitung Ihrer Daten bei uns (Art. 21 DSGVO) und
• Datenübertragbarkeit, sofern Sie in die Datenverarbeitung eingewilligt haben oder einen Vertrag mit uns abgeschlossen haben (Art. 20 DSGVO).

Sofern Sie uns eine Einwilligung erteilt haben, können Sie diese jederzeit mit Wirkung für die Zukunft widerrufen.

Sie können sich jederzeit mit einer Beschwerde an eine Aufsichtsbehörde wenden, z. B. an die zuständige Aufsichtsbehörde des Bundeslands Ihres Wohnsitzes oder an die für uns als verantwortliche Stelle zuständige Behörde.

Eine Liste der Aufsichtsbehörden (für den nichtöffentlichen Bereich) mit Anschrift finden Sie unter: .

Eingebettete YouTube-Videos

Art und Zweck der Verarbeitung:

Auf einigen unserer Webseiten betten wir YouTube-Videos ein. Betreiber der entsprechenden Plugins ist die YouTube, LLC, 901 Cherry Ave., San Bruno, CA 94066, USA (nachfolgend „YouTube“). Wenn Sie eine Seite mit dem YouTube-Plugin besuchen, wird eine Verbindung zu Servern von YouTube hergestellt. Dabei wird YouTube mitgeteilt, welche Seiten Sie besuchen. Wenn Sie in Ihrem YouTube-Account eingeloggt sind, kann YouTube Ihr Surfverhalten Ihnen persönlich zuzuordnen. Dies verhindern Sie, indem Sie sich vorher aus Ihrem YouTube-Account ausloggen.

Wird ein YouTube-Video gestartet, setzt der Anbieter Cookies ein, die Hinweise über das Nutzerverhalten sammeln.

Weitere Informationen zu Zweck und Umfang der Datenerhebung und ihrer Verarbeitung durch YouTube erhalten Sie in den Datenschutzerklärungen des Anbieters, Dort erhalten Sie auch weitere Informationen zu Ihren diesbezüglichen Rechten und Einstellungsmöglichkeiten zum Schutze Ihrer Privatsphäre (). Google verarbeitet Ihre Daten in den USA und hat sich dem EU-US Privacy Shield unterworfen https://www.privacyshield.gov/EU-US-Framework

Rechtsgrundlage:

Rechtsgrundlage für die Einbindung von YouTube und dem damit verbundenen Datentransfer zu Google ist Ihre Einwilligung (Art. 6 Abs. 1 lit. a DSGVO).

Empfänger:

Der Aufruf von YouTube löst automatisch eine Verbindung zu Google aus.

Speicherdauer und Widerruf der Einwilligung:

Wer das Speichern von Cookies für das Google-Ad-Programm deaktiviert hat, wird auch beim Anschauen von YouTube-Videos mit keinen solchen Cookies rechnen müssen. YouTube legt aber auch in anderen Cookies nicht-personenbezogene Nutzungsinformationen ab. Möchten Sie dies verhindern, so müssen Sie das Speichern von Cookies im Browser blockieren.

Weitere Informationen zum Datenschutz bei „YouTube“ finden Sie in der Datenschutzerklärung des Anbieters unter:

Drittlandtransfer:

Google verarbeitet Ihre Daten in den USA und hat sich dem EU_US Privacy Shield unterworfen .

Bereitstellung vorgeschrieben oder erforderlich:

Die Bereitstellung Ihrer personenbezogenen Daten erfolgt freiwillig, allein auf Basis Ihrer Einwilligung. Sofern Sie den Zugriff unterbinden, kann es hierdurch zu Funktionseinschränkungen auf der Website kommen.

Änderung unserer Datenschutzbestimmungen

Wir behalten uns vor, diese Datenschutzerklärung anzupassen, damit sie stets den aktuellen rechtlichen Anforderungen entspricht oder um Änderungen unserer Leistungen in der Datenschutzerklärung umzusetzen, z.B. bei der Einführung neuer Services. Für Ihren erneuten Besuch gilt dann die neue Datenschutzerklärung.

Fragen an den Datenschutzbeauftragten

Wenn Sie Fragen zum Datenschutz haben, schreiben Sie uns bitte eine E-Mail oder wenden Sie sich direkt an die für den Datenschutz verantwortliche Person in unserer Organisation:

Die Datenschutzerklärung wurde mit dem Datenschutzerklärungs-Generator der activeMind AG erstellt *(Version 2018-09-24).c