Sessions sind persistente Superkräfte

Stell dir vor, du hast gerade mit Claude Code an etwas verdammt Geilem gearbeitet. Du schließt das Terminal. Machst Kaffee. Und denkst: "Shit, das ist jetzt weg."

Falsch.

Deine Session? Die lebt noch. Sie wartet auf dich. Mit einem einfachen Befehl holst du deine komplette Arbeit zurück – Code, Context, Conversation. Alles.

Das ist der Moment, wo Claude Code aufhört, ein Tool zu sein, und dein persönlicher Coding-Partner wird.

Phase 1: Sessions wiederherstellen – Back to Business

Okay, du hast eine Session beendet oder dein Terminal geschlossen. Kein Drama.

So funktioniert die Rückkehr:

```claude --continue```

Das war's. Claude lädt deine letzte Session.

Im Terminal siehst du erst mal nichts? Kein Problem. Drücke zweimal:

```Escape Escape```

Boom. Jetzt siehst du die Übersicht deiner Session. Du kannst:

• Alle bisherigen Änderungen sehen
• Zu früheren Punkten zurückspringen
• Neue Befehle eingeben, die auf dem alten Context aufbauen

Phase 2: Code gezielt wiederherstellen

Das Beste? Du kannst selektiv entscheiden, was du zurückholen willst.

Sagen wir, du warst hier:

1. Datei erstellt
2. Translate to English gemacht
3. Weitere Edits durchgeführt

Du willst jetzt nicht alles zurückfahren, sondern nur zu "Translate to English" zurück.

Das machst du so:

```Restore Code in Conversation```

Oder wenn du nur eine bestimmte Aktion willst:

```Nur die Conversation wiederherstellen```

```Nur den Code wiederherstellen```

Claude fragt dich dann, wo genau du anknüpfen willst. Dann selektierst du deine Dateien (Ctrl + Alt + K), gibst einen neuen Befehl ein – z.B. "Translate to Italian" – und es geht weiter.

Der Context ist intact. Die Änderungen sind da. Und du sparst dir den kompletten Aufbau.

Phase 3: Terminal Shortcuts – Die Effizienz-Hacks

Hier kommt der goldene Teil. Diese 7 Shortcuts nutze ich täglich. Sie sparen mir nicht 10 Minuten – sie sparen mir Stunden im Monat.

Keyboard Navigation im Terminal

| Shortcut | Was es macht | Einsatz ||----------|-------------|---------|| Ctrl + A | Zum Anfang der Zeile springen | Nach langem Prompt fix zum Start zurück || Ctrl + E | Zum Ende der Zeile springen | Schnell ans Ende für Edits || Alt + B | Ein Wort zurück | Word-by-Word Navigation (schneller als Pfeiltasten) || Alt + F | Ein Wort vorwärts | Precision beim Editieren || Ctrl + W | Ganzes Wort löschen | Schnelles Cleanup || Ctrl + U | Ganze Zeile löschen | Nuclear Option, wenn alles weg soll || Ctrl + K | Terminal clearen | Frisches Blatt |

Praxis-Beispiel:

Ich diktiere einen langen Prompt:

```"Translate diese readme to english und mache die lizenz zu italiano und noch ein paar andere sachen"```

Jetzt brauch ich nur den ersten Teil. Ich drücke:

```Ctrl + A // Zum AnfangCtrl + E // Zum EndeCtrl + W // "sachen" wegCtrl + W // "andere" wegCtrl + W // "paar" weg// usw.```

5 Sekunden später hab ich nur noch:

```"Translate diese readme to english und mache die lizenz zu italiano"```

Das ist verdammt komfortabel, wenn du viel diktierst (wie ich).

Phase 4: Sessions beenden – Clean Exit

Wenn du fertig bist, gibt es zwei Wege:

Option 1: Sauberer Exit

```exit```

Die Session wird gelöscht. Du bist draußen. Nächste Mal musst du neu anfangen.

Option 2: Nuke & Reset (mein Favorit)

```Ctrl + C```

Drücke nochmal Ctrl + C. Claude Code wird beendet.

Dann kannst du noch ein clear machen und hast wieder ein sauberes Terminal:

```clear```

Das ist besser, wenn du mit mehreren Projekten parallel arbeitest und nicht möchtest, dass Sessions sich vermischen.

Die Wahrheit über Session Management

Sessions sind super powerful, aber du solltest verstehen, was passiert:

• claude --continue bringt dir die letzte Session zurück
• Die Session speichert Context, Code und Conversation
• Wenn du mehrere Sessions brauchst, manage sie bewusst (z.B. mit exit für saubere Trennung)
• Bei größeren Projekten: Legst du dir besser mehrere Terminal-Fenster an, nicht mehrere Sessions

Das ist nicht kompliciert. Aber du solltest es wissen.

Bonus: Kombination aus Terminal + Code Edits

Das Geil-ste? Du kombinierst das:

1. Terminal offen, Claude läuft
2. Du diktierst einen Prompt
3. Claude schlägt Code vor
4. Du nutzt Alt + B und Ctrl + W, um deinen Prompt schnell zu tweaken
5. Neuer Befehl, neue Änderungen

Alles in einer Session. Alles mit Tastaturkürzeln. Keine Maus. Zero Friction.

Das ist die Zukunft von Coding.

Dein Action Plan für heute

1. ✅ Eine Session starten
2. ✅ Ein paar Änderungen machen
3. ✅ Session beenden (exit)
4. ✅ claude --continue eingeben
5. ✅ Die Shortcuts aus der Tabelle oben ausprobieren
6. ✅ Merken, welche dich am meisten reizen

Sobald du diese Shortcuts im Muscle-Memory hast, wirst du verdammt schnell.

Die größte Erkenntnis

Shortcuts sind nicht einfach "nice to have". Sie sind der Unterschied zwischen gemütliches Coding und Flow State Coding.

Je weniger du deine Hände vom Keyboard nimmst, desto schneller dein Brain.

Dein Terminal ist dein Reich. Beherrsche es.

Nächste Woche: Context Management und wie du riesige Projekte ohne Memory Leaks handhabst.

Bis dahin: Viel Spaß mit den Shortcuts. Habt einen tollen Tag. Ciao.