diff --git a/Kapitel 13/Tutorial.md b/Kapitel 13/Tutorial.md
index 4e3d00e..79c4e90 100644
--- a/Kapitel 13/Tutorial.md	
+++ b/Kapitel 13/Tutorial.md	
@@ -61,165 +61,166 @@ Damit ist das Fundament gelegt: Der LXC ist vorbereitet, das System auf Stand, u
 
 ---
 
-## Abschnitt 2 – Clipper‑LXC einrichten (Basisdienste & Service‑Skelett)
+## Abschnitt 2 – Clipper-LXC einrichten (Basisdienste & Service-Skelett)
 
-Ziel: Der LXC enthält alles Nötige, damit n8n ihn bei Bedarf starten kann und klare Einstiegspunkte zum **Analysieren** und **Schneiden** vorhanden sind. Die eigentliche Logik füllen wir später (Abschnitt 4/5) – jetzt legen wir nur das **saubere Gerüst** an.
+In diesem Abschnitt bereiten wir den Container so vor, dass der Benutzer **clipper** alle Arbeiten übernimmt. Root wird nur für die Installation und Systemaufgaben genutzt. Danach wechseln wir bewusst in die Session von **clipper** und arbeiten dort weiter. So bleibt das System sauber getrennt und sicher.
+
+---
+
+### Schritt 1: Benutzer und Verzeichnisse anlegen
+Zuerst legen wir den Benutzer `clipper` an und bereiten die Arbeitsverzeichnisse vor.
 
-### 2.1 Service‑Benutzer & Verzeichnisse
 ```bash
-# Systemnutzer ohne Login
-useradd --system --create-home --shell /usr/sbin/nologin clipper
+adduser clipper
+# Passwort vergeben und die Standardfragen beantworten
+
 mkdir -p /srv/clipper/{watch,out,temp,logs,bin}
 chown -R clipper:clipper /srv/clipper
-
-# Ort für Konfiguration/Secrets
-mkdir -p /etc/clipper
-chmod 750 /etc/clipper
-``` 
-
-### 2.2 Pakete installieren
-```bash
-apt update && apt install -y ffmpeg jq python3 python3-venv curl unzip inotify-tools
+chmod 750 /srv/clipper
 ```
 
-> **Warum diese Pakete?**  
-> **ffmpeg** für Analyse/Schnitt, **jq** für JSON‑Handling, **python3/venv** für optionale Analyse‑Hilfen (z. B. Szenen/Facedetect in Abschnitt 4), **inotify-tools** für eventuelle lokale Hooks.
+Damit ist der Benutzer angelegt und besitzt alle notwendigen Verzeichnisse.
+
+---
+
+### Schritt 2: Notwendige Pakete installieren
+Als root installieren wir die benötigten Pakete.
 
-### 2.3 Konfiguration (env)
 ```bash
-nano /etc/clipper/clipper.env
+apt update && apt install -y ffmpeg jq python3 python3-venv curl unzip inotify-tools sudo
 ```
-Inhalt (minimal, erweiterbar in späteren Abschnitten):
+
+- **ffmpeg**: Kernwerkzeug für Analyse und Schnitt  
+- **jq**: JSON-Handling  
+- **python3/venv**: Virtuelle Umgebung für spätere Analyse-Tools  
+- **inotify-tools**: optional für lokale Hooks  
+- **sudo**: erlaubt clipper bei Bedarf Systembefehle auszuführen
+
+---
+
+### Schritt 3: Benutzer clipper für sudo freischalten
+Damit `clipper` bei Bedarf Befehle mit Administratorrechten ausführen kann, geben wir ihm Zugang zur Gruppe **sudo**.
+
+```bash
+usermod -aG sudo clipper
+```
+
+---
+
+### Schritt 4: In die Session des Benutzers clipper wechseln
+Ab hier arbeiten wir direkt als Benutzer `clipper`.
+
+```bash
+su - clipper
+```
+
+---
+
+### Schritt 5: Konfigurationsdatei anlegen
+Wir erstellen die Umgebungsvariablen-Datei, die später von allen Skripten genutzt wird.
+
+```bash
+nano /srv/clipper/clipper.env
+```
+Inhalt:
 ```
 CLIPPER_IN=/srv/clipper/watch
 CLIPPER_OUT=/srv/clipper/out
 CLIPPER_TMP=/srv/clipper/temp
 CLIPPER_LOG=/srv/clipper/logs/clipper.log
-# Standard-Exportformate; Details folgen in Abschnitt 5/6
 EXPORT_VARIANTS="16x9,9x16"
 ```
+
+Speichern mit **Strg+O**, bestätigen mit **Enter**, beenden mit **Strg+X**.
+
+---
+
+### Schritt 6: Virtuelle Python-Umgebung vorbereiten
+Noch immer als Benutzer `clipper` legen wir die virtuelle Umgebung an und installieren die ersten Pakete.
+
+```bash
+python3 -m venv /srv/clipper/.venv
+source /srv/clipper/.venv/bin/activate
+pip install --upgrade pip
+pip install numpy opencv-python-headless
+```
+
+Damit ist die Grundlage für spätere Analysen geschaffen. KI und STT binden wir später in Abschnitt 4 ein.
+
+---
+
+### Schritt 7: Einstiegsskripte erstellen
+Jetzt erstellen wir die beiden Einstiegspunkte `clipper-analyze` und `clipper-cut`. Sie liegen im Verzeichnis `/srv/clipper/bin/` und dienen n8n als Schnittstelle.
+
+**Analyse-Skript**
+```bash
+nano /srv/clipper/bin/clipper-analyze
+```
+Inhalt:
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+ENV_FILE="/srv/clipper/clipper.env"; [ -r "$ENV_FILE" ] || { echo "ENV nicht lesbar: $ENV_FILE" >&2; exit 1; }; source "$ENV_FILE"
+IN="$1"
+JOBID="${2:-manual}"
+mkdir -p "$CLIPPER_TMP/$JOBID"
+echo "$(date '+%F %T') [ANALYZE] job=$JOBID file=$IN" | tee -a "$CLIPPER_LOG"
+OUT_JSON="$CLIPPER_TMP/$JOBID/candidates.json"
+echo '[]' > "$OUT_JSON"
+echo "$OUT_JSON"
+```
+
+**Schnitt-Skript**
+```bash
+nano /srv/clipper/bin/clipper-cut
+```
+Inhalt:
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+ENV_FILE="/srv/clipper/clipper.env"; [ -r "$ENV_FILE" ] || { echo "ENV nicht lesbar: $ENV_FILE" >&2; exit 1; }; source "$ENV_FILE"
+IN="$1"
+RANGES_JSON="$2"
+JOBID="${3:-manual}"
+mkdir -p "$CLIPPER_OUT/$JOBID"
+echo "$(date '+%F %T') [CUT] job=$JOBID file=$IN ranges=$RANGES_JSON" | tee -a "$CLIPPER_LOG"
+exit 0
+```
+
+Speichern beide Male mit **Strg+O**, bestätigen mit **Enter**, beenden mit **Strg+X**.
+
 Rechte setzen:
 ```bash
-chown root:clipper /etc/clipper/clipper.env
-chmod 640 /etc/clipper/clipper.env
-```
-
-### 2.4 Python-Umgebung vorbereiten (für Analyse-Tools, Abschnitt 4)
-```bash
-# Virtuelle Umgebung als Benutzer "clipper" anlegen
-runuser -u clipper -- python3 -m venv /srv/clipper/.venv
-runuser -u clipper -- /srv/clipper/.venv/bin/pip install --upgrade pip
-# Pakete für spätere Analyse; konkrete Libs folgen in Abschnitt 4
-runuser -u clipper -- /srv/clipper/.venv/bin/pip install numpy opencv-python-headless
-```
-> Hinweis: Wir arbeiten im LXC als root, deshalb **kein `sudo`** – stattdessen `runuser -u clipper -- …`.
-
-### 2.5 Entrypoints (noch „stubs“)
-Wir erstellen zwei **CLI-Einstiegspunkte**, die n8n aufruft. Sie tun jetzt noch nichts Schweres – nur Validierung & Logging. Die echte Logik folgt in Abschnitt 4/5.
-
-**Analyse-Stub**
-```bash
-nano /srv/clipper/bin/clipper-analyze
-```
-Inhalt:
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-source /etc/clipper/clipper.env
-IN="$1"       # absolute Datei
-JOBID="${2:-manual}"
-mkdir -p "$CLIPPER_TMP/$JOBID"
-echo "$(date '+%F %T') [ANALYZE] job=$JOBID file=$IN" | tee -a "$CLIPPER_LOG"
-# Platzhalter: Wir erzeugen vorerst nur eine leere Kandidatenliste
-OUT_JSON="$CLIPPER_TMP/$JOBID/candidates.json"
-echo '[]' > "$OUT_JSON"
-echo "$OUT_JSON"
-```
-
-**Schneid-Stub**
-```bash
-nano /srv/clipper/bin/clipper-cut
-```
-Inhalt:
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-source /etc/clipper/clipper.env
-IN="$1"            # absolute Datei
-RANGES_JSON="$2"   # Zeitbereiche (kommt später aus Abschnitt 4)
-JOBID="${3:-manual}"
-mkdir -p "$CLIPPER_OUT/$JOBID"
-echo "$(date '+%F %T') [CUT] job=$JOBID file=$IN ranges=$RANGES_JSON" | tee -a "$CLIPPER_LOG"
-# Platzhalter: noch kein Schnitt; wir protokollieren nur
-exit 0
-``` Entrypoints (noch „stubs“)
-Wir erstellen zwei **CLI‑Einstiegspunkte**, die n8n aufruft. Sie tun jetzt noch nichts Schweres – nur Validierung & Logging. Die echte Logik folgt in Abschnitt 4/5.
-
-**Analyse‑Stub**
-```bash
-nano /srv/clipper/bin/clipper-analyze
-```
-Inhalt:
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-source /etc/clipper/clipper.env
-IN="$1"       # absolute Datei
-JOBID="${2:-manual}"
-mkdir -p "$CLIPPER_TMP/$JOBID"
-echo "$(date '+%F %T') [ANALYZE] job=$JOBID file=$IN" | tee -a "$CLIPPER_LOG"
-# Platzhalter: Wir erzeugen vorerst nur eine leere Kandidatenliste
-OUT_JSON="$CLIPPER_TMP/$JOBID/candidates.json"
-echo '[]' > "$OUT_JSON"
-echo "$OUT_JSON"
-```
-
-**Schneid‑Stub**
-```bash
-nano /srv/clipper/bin/clipper-cut
-```
-Inhalt:
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-source /etc/clipper/clipper.env
-IN="$1"            # absolute Datei
-RANGES_JSON="$2"   # Zeitbereiche (kommt später aus Abschnitt 4)
-JOBID="${3:-manual}"
-mkdir -p "$CLIPPER_OUT/$JOBID"
-echo "$(date '+%F %T') [CUT] job=$JOBID file=$IN ranges=$RANGES_JSON" | tee -a "$CLIPPER_LOG"
-# Platzhalter: noch kein Schnitt; wir protokollieren nur
-exit 0
-```
-
-Ausführbar machen:
-```bash
 chmod +x /srv/clipper/bin/clipper-*
-chown -R clipper:clipper /srv/clipper/bin
 ```
 
-### 2.6 Direktaufruf (ohne systemd)
-Um Fehler durch fehlende Parameter zu vermeiden, verzichten wir fürs Job-Handling auf systemd-Templates. **n8n ruft die Skripte direkt** auf (per SSH „Execute Command“). So übergeben wir Dateipfad & JOBID explizit.
+---
 
-**Beispiele:**
+### Schritt 8: Skripte testen
+Wir testen die beiden Einstiegspunkte.
+
+**Analyse-Test:**
 ```bash
-# Analyse starten (Pfad anpassen)
-runuser -u clipper -- /srv/clipper/bin/clipper-analyze \
-  "/srv/clipper/watch/demo.mp4" "job-001"
-
-# Schneiden mit zuvor ermittelten Bereichen
-runuser -u clipper -- /srv/clipper/bin/clipper-cut \
-  "/srv/clipper/watch/demo.mp4" "/srv/clipper/temp/job-001/ranges.json" "job-001"
+/srv/clipper/bin/clipper-analyze /srv/clipper/watch/demo.mp4 job-001
 ```
 
-**Prüfen:**
+**Schnitt-Test:**
+```bash
+/srv/clipper/bin/clipper-cut /srv/clipper/watch/demo.mp4 /srv/clipper/temp/job-001/ranges.json job-001
+```
+
+Logs prüfen:
 ```bash
 tail -n 50 /srv/clipper/logs/clipper.log
 ```
-→ Du solltest die [ANALYZE] bzw. [CUT] Zeilen mit Job-ID sehen.
 
-### 2.7 Log-Rotation Log‑Rotation
+---
+
+### Schritt 9: Logrotation einrichten
+Zum Abschluss richten wir die automatische Log-Rotation ein. Dafür wechseln wir kurz zurück zu root.
+
 ```bash
+exit   # zurück zu root
 nano /etc/logrotate.d/clipper
 ```
 Inhalt:
@@ -235,4 +236,9 @@ Inhalt:
 }
 ```
 
-Damit ist der **Clipper‑LXC** vorbereitet: Benutzer, Verzeichnisse, Pakete, Konfiguration und Systemd‑Skelett sind vorhanden. In den nächsten Abschnitten hängen wir **Twitch/n8n** an, füllen die **Analyse‑Logik** (inkl. Facecam/Hochformat/Untertitel‑Option) und implementieren das **Schneiden** samt sauberer Ablage in Nextcloud.
+---
+
+**Ergebnis Abschnitt 2:**
+- Benutzer **clipper** ist vollständig eingerichtet und übernimmt die Arbeit.  
+- Skripte `clipper-analyze` und `clipper-cut` laufen fehlerfrei in seiner Session.  
+- n8n kann später direkt als Benutzer `clipper` per SSH einsteigen und die Skripte aufrufen.