---
title: ""
canonical: "https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten"
language: de
publisher: "StudioMeyer Academy, https://studiomeyer.academy (llms.txt: https://studiomeyer.academy/llms.txt)"
---

[← Alle Playbooks](https://studiomeyer.academy/playbooks)

Playbook· lokal

# Dein erstes lokales KI-Modell in 30 Minuten

Ein Sprachmodell auf dem eigenen Rechner, ohne Cloud und ohne Konto. Zehn Schritte von der Installation bis zum ersten sinnvollen Ergebnis, inklusive der Stellen an denen die meisten aufgeben und der Einstellungen, die trotz lokalem Modell noch nach draußen funken.

Es gibt zwei Gründe, ein Sprachmodell auf dem eigenen Rechner laufen zu lassen. Der eine ist Datenschutz, und der zählt in Deutschland mehr als anderswo. Der andere ist, dass man einmal selbst sehen will, was so ein Ding eigentlich ist, wenn keine Firma dazwischen sitzt. Beides ist ein guter Grund.

Was Du danach hast, ist ein Modell das offline antwortet. Kein Konto, keine Abrechnung nach Token, keine Übertragung an einen Anbieter. Was Du nicht hast, ist die Qualität von Opus 5 oder GPT-5.6. Das ist keine Kleinigkeit, und ich sage gleich in Schritt 9 ehrlich, wo die Grenze liegt. Aber für erstaunlich viele Aufgaben reicht das Lokale, und der Weg dahin dauert eine halbe Stunde.

## 1\. Prüf zuerst, ob Dein Rechner überhaupt mitspielt

Bevor Du irgendetwas installierst, schau nach, wie viel Arbeitsspeicher Du hast. Bei einem Mac mit Apple Silicon zählt der gemeinsame Speicher, also die Zahl die beim Kauf als 16 GB oder 32 GB dastand. Bei einem Windows- oder Linux-Rechner mit dedizierter Grafikkarte zählt der Speicher der Grafikkarte, nicht der des Rechners.

Die grobe Einordnung, Stand August 2026, und zwar getrennt nach Bauart. Bei einer **dedizierten Grafikkarte** steht Dir ihr Speicher fast vollständig zur Verfügung: 8 GB reichen für ein kleines Modell, 16 GB sind angenehm, ab 24 GB wird es inhaltlich ernsthaft. Bei **Apple Silicon** teilen sich Prozessor und Grafik denselben Speicher, und davon steht nur ein Teil dem Modell zur Verfügung, grob zwei Drittel bis drei Viertel. Aus 16 GB werden also eher 11 GB nutzbar, aus 32 GB etwa 22. Rechne bei einem Mac deshalb eine Stufe großzügiger als die Zahl auf dem Karton vermuten lässt. Ohne Grafikkarte geht es auch, nur langsamer, weil dann der Hauptprozessor rechnet.

**Tipp:** Wenn Du unsicher bist, fang trotzdem an. Der erste Versuch kostet Dich nichts außer Festplattenplatz, und den bekommst Du mit einem Befehl zurück.

## 2\. Installier Ollama

Ollama ist der bequemste Einstieg. Es lädt Modelle herunter, kümmert sich um das Format und stellt eine Schnittstelle bereit, die sich für andere Programme wie die von OpenAI anfühlt. Das ist praktischer als es klingt, weil viele Werkzeuge dadurch ohne Umbau mit Deinem lokalen Modell reden können.

Auf ollama.com gibt es Installer für Mac, Windows und Linux. Nach der Installation läuft ein kleiner Dienst im Hintergrund, standardmäßig nur auf Deinem eigenen Rechner erreichbar. Ob er da ist, prüfst Du im Terminal:

```bash
ollama --version
```

**Tipp:** Wenn Du eine Oberfläche zum Klicken lieber magst als ein Terminal, nimm stattdessen LM Studio. Es kann dasselbe und hat einen eingebauten Modell-Browser. Achtung bei den Befehlen weiter unten: LM Studio startet seinen Server von Hand aus der Oberfläche und lauscht auf einem anderen Port als Ollama. Die Adresse steht dort im Server-Tab, und die musst Du in Schritt 8 statt der Ollama-Adresse einsetzen. Die `ollama`\-Kommandos gelten nur für Ollama.

## 3\. Lad ein passendes erstes Modell

Fang klein an. Ein Modell mit sieben bis neun Milliarden Parametern in der üblichen Kompression passt in acht Gigabyte und antwortet auf einem normalen Rechner flüssig.

```bash
ollama pull qwen3:8b
```

Der Download ist ein paar Gigabyte groß. Währenddessen kannst Du Schritt 4 lesen.

**Tipp:** Die Zahl vor dem `b` sind Milliarden Parameter und damit die grobe Größenklasse. Was dahinter noch steht, etwa `q4_K_M`, ist die Kompression. Mehr dazu im Playbook [Welches lokale Modell zu Deiner Hardware passt](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware).

## 4\. Versteh in einem Satz, was Quantisierung ist

Ein Modell wird trainiert mit sehr genauen Zahlen. Für den Betrieb kann man diese Zahlen gröber speichern, ähnlich wie ein Foto als JPEG statt als RAW. Das Ergebnis ist kleiner und schneller, und man sieht den Unterschied meistens nicht.

Die übliche Einstellung heißt `Q4_K_M`. Gegenüber dem unkomprimierten Original schrumpft der Speicherbedarf damit grob auf ein Viertel, und die Qualität leidet so wenig, dass es im Alltag nicht auffällt. Exakt vier Bit pro Zahl sind es nicht, es kommen noch Skalierungswerte dazu, deshalb ist die echte Dateigröße immer etwas höher als die reine Rechnung. Ollama wählt das automatisch, Du musst nichts einstellen. Wichtig ist nur, dass Du weißt was gemeint ist, wenn Du die Angabe irgendwo liest.

**Tipp:** Geh nicht unter Q4. Q2 und Q3 sparen zwar weiter Speicher, aber da fängt das Modell an, spürbar dümmer zu werden. Wie stark, hängt vom Modell und von der Aufgabe ab, und bei Code und Werkzeug-Aufrufen bricht es früher ein als beim Fließtext.

## 5\. Sprich das Modell zum ersten Mal an

```bash
ollama run qwen3:8b
```

Du landest in einem Chat im Terminal. Stell eine Frage, zu der Du die Antwort schon kennst, damit Du die Qualität einschätzen kannst. Etwas aus Deinem Fachgebiet ist besser geeignet als eine Wissensfrage, weil Du beim Fachlichen sofort merkst, ob es Substanz hat oder nur gut klingt.

Beenden kannst Du mit `/bye`.

**Tipp:** Die erste Antwort dauert länger, weil das Modell in den Speicher geladen wird. Ab der zweiten geht es zügig. Wenn Du also im ersten Moment denkst, das sei unbrauchbar langsam, warte den zweiten Versuch ab.

## 6\. Häng eine Oberfläche dran

Im Terminal zu chatten ist zum Ausprobieren in Ordnung und für den Alltag unbequem. Open WebUI gibt Dir eine Oberfläche im Browser, die aussieht wie die üblichen Chat-Dienste, aber komplett auf Deinem Rechner läuft. Es kennt Deine Ollama-Modelle von selbst.

Mit Docker ist es ein Befehl, aber er sieht auf Mac und Windows anders aus als auf Linux. Der Unterschied ist nicht kosmetisch: Ollama lauscht nur auf `127.0.0.1`, und ein Container erreicht diese Adresse des Wirts nicht von allein.

Auf **Mac und Windows** legt Docker Desktop den Namen `host.docker.internal` an, über den der Container den Wirt erreicht. Der Befehl steht hier in einer Zeile, damit er sich in Terminal, PowerShell und Eingabeaufforderung gleichermaßen einfügen lässt:

```bash
docker run -d -p 127.0.0.1:3000:8080 --add-host=host.docker.internal:host-gateway -e OLLAMA_BASE_URL=http://host.docker.internal:11434 -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:v0.6.31
```

Das `-p 127.0.0.1:3000:8080` ist der wichtige Teil: die Oberfläche ist damit nur von Deinem eigenen Rechner aus erreichbar.

Auf **Linux** gibt es diesen Namen nicht, und der Ausweg, den man überall liest, ist eine Falle. `--network=host` lässt den Container zwar an das Ollama auf `127.0.0.1` heran, hebt dabei aber die Bindung auf localhost auf: die Oberfläche hört dann auf allen Schnittstellen. Eine Firewall davorzusetzen klingt nach Lösung, ist aber keine verlässliche, denn `ufw status: active` sagt nichts darüber, ob genau dieser Port auch geschlossen ist. Und das Risiko ist konkret: bei einer frischen Open-WebUI-Installation wird der erste, der sich registriert, Administrator. Wer im selben Netz sitzt, war womöglich schneller.

Deshalb steht dieser Weg hier nicht. Nimm auf Linux das Image, das Ollama gleich mitbringt:

```bash
docker run -d -p 127.0.0.1:3000:8080 -p 127.0.0.1:11435:11434 -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama
```

Dieser Container hat sein eigenes Ollama, es muss also nichts zum Wirt durchgereicht werden, und beide Bindungen auf `127.0.0.1` halten ohne jede Firewall. Der zweite Port gibt die Ollama-Schnittstelle des Containers frei, die brauchst Du in Schritt 8. Er liegt bewusst auf 11435 und nicht auf 11434, damit er sich nicht mit einem noch installierten Ollama auf dem Rechner beißt. Modelle lädst Du hier in der Oberfläche oder mit `docker exec -it open-webui ollama pull qwen3:8b`. Das Ollama aus Schritt 2 brauchst Du für die Oberfläche dann nicht mehr; für die Terminal-Schritte 3 bis 5 war es trotzdem nützlich, und Du kannst es liegen lassen oder deinstallieren.

Wer weder Docker noch zwei Ollamas will, nimmt auf Linux LM Studio. Das bringt Oberfläche und Modellverwaltung in einem mit.

Danach im Browser `http://localhost:3000` aufrufen. Die feste Version im Mac- und Windows-Befehl ist Absicht: `:main` verschiebt sich unter Dir. Der Linux-Tag `:ollama` wandert leider ebenfalls, dort gibt es keine feste Entsprechung. Ganz exakt festnageln lässt sich ein Build ohnehin nur über seinen Digest.

**Tipp:** Spätestens hier lohnt es sich, ein Gespräch mit einem echten Arbeitsauftrag zu führen statt mit Testfragen. Erst dann merkst Du, ob das Modell für Dich taugt.

## 7\. Gib dem Modell Deine eigenen Dokumente

Der Punkt, an dem lokale Modelle interessant werden, ist nicht das allgemeine Wissen. Da verlieren sie gegen die großen Anbieter. Interessant wird es, wenn sie etwas sehen, das Du keinem Anbieter geben willst.

Zieh in Open WebUI ein PDF in den Chat und lass es zusammenfassen. Einen Vertrag, ein Protokoll, eine Rechnung. Genau die Sachen, bei denen Du bei ChatGPT kurz zögerst.

Ein Vorbehalt gehört dazu, bevor Du wirklich Sensibles hineingibst. Lokal ist das Modell, nicht automatisch die ganze Oberfläche. Wenn dort Websuche eingeschaltet ist, ein Embedding-Dienst in der Cloud für die Dokumentensuche eingetragen ist oder ein Fremdmodell als Alternative hinterlegt wurde, gehen Teile Deiner Daten doch hinaus. Geh die Einstellungen einmal durch und schalt aus, was nach draußen zeigt. Danach stimmt der Satz, dass die Datei den Rechner nicht verlässt.

**Tipp:** Halt die Dokumente am Anfang kurz. Nicht weil kleine Modelle grundsätzlich ein kleines Kontextfenster hätten, das hängt am Modell und nicht an der Parameterzahl, sondern weil lange Dokumente automatisch zerstückelt und nur ausschnittsweise gelesen werden. Bei einem 80-seitigen Vertrag heißt das: die Zusammenfassung kann eine wichtige Klausel schlicht auslassen, ohne es zu erwähnen. Prüf deshalb bei langen Dokumenten stichprobenartig gegen das Original.

## 8\. Mach das Modell für andere Programme erreichbar

Ollama stellt seine Schnittstelle auf Port 11434 bereit und spricht dabei das Format, das die meisten Werkzeuge von OpenAI kennen. Damit kannst Du in vielen Programmen einfach die Adresse austauschen und plötzlich läuft dieselbe Anwendung gegen Dein lokales Modell.

Der Befehl unten gilt für das Ollama auf Deinem Rechner. Beim Linux-Container mit gebündeltem Ollama ist es dieselbe Schnittstelle, nur auf dem Port, den Du in Schritt 6 mit freigegeben hast: dort steht dann `11435` statt `11434`. Sonst ändert sich nichts.

```bash
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen3:8b","messages":[{"role":"user","content":"Sag Hallo"}]}'
```

Kommt hier eine Antwort, ist die Schnittstelle offen und Du kannst weiterbauen.

**Tipp:** Der Port ist standardmäßig nur auf Deinem eigenen Rechner erreichbar, und das ist gut so. Wenn Du ihn im Netzwerk freigibst, denk vorher darüber nach, wer sonst noch in diesem Netz sitzt.

## 9\. Erwarte das Richtige, sonst wirst Du enttäuscht

Hier die ehrliche Einordnung, ohne die dieses Playbook unvollständig wäre.

Was lokal gut geht: zusammenfassen, umformulieren, übersetzen, sortieren, klassifizieren, aus einem Text die Struktur ziehen, einfache Fragen zu einem beigelegten Dokument. Also der ganze Fleiß-Anteil der Textarbeit.

Was lokal schlechter geht: lange Ketten von Schlussfolgerungen, schwierige Code-Architektur, selbstständiges Arbeiten über viele Schritte hinweg, alles was wirklich tiefes Denken braucht. Da sind die großen Modelle nicht ein bisschen besser, sondern deutlich.

Das ist keine vorübergehende Schwäche, die nächste Woche behoben ist. Es ist der Preis dafür, dass etwas auf einem Gerät läuft, das unter Deinem Schreibtisch steht statt in einem Rechenzentrum. Wer das akzeptiert, hat ein sehr nützliches Werkzeug. Wer den Ersatz für Opus 5 erwartet, legt es nach zwei Tagen weg.

**Tipp:** Der produktivste Aufbau ist meistens gemischt. Lokal für alles mit sensiblen Daten und für Massenarbeit, Cloud für die schweren Fälle. Die Rechnung dazu steht in [Lokal oder Cloud, die ehrliche Rechnung](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung).

## 10\. Räum auf, wenn Du es nicht behalten willst

Modelle belegen Platz, und beim Ausprobieren sammeln sich schnell mehrere an. Beim Ollama auf Deinem Rechner geht das so:

```bash
ollama list
ollama rm qwen3:8b
```

Beim Linux-Container mit gebündeltem Ollama dieselben Befehle, nur im Container:

```bash
docker exec -it open-webui ollama list
docker exec -it open-webui ollama rm qwen3:8b
```

Das entfernt allerdings jeweils **nur das Modell**. Deine hochgeladenen Dokumente, die Gesprächsverläufe und die Suchindizes liegen woanders, nämlich im Datenbereich der Oberfläche. Genau die Sachen also, wegen denen Du lokal gearbeitet hast. Wer nur das Modell löscht und denkt, damit sei aufgeräumt, lässt die Verträge und Arztbriefe liegen.

Vollständig weg ist es erst so:

```bash
docker rm -f open-webui
docker volume rm open-webui
```

Wenn Du auf Linux den Container mit gebündeltem Ollama genommen hast, liegt dort noch eine zweite Modellkopie in einem eigenen Volume:

```bash
docker volume rm ollama
```

Bei LM Studio liegt das Gegenstück im Programmordner unter Deinem Benutzerverzeichnis, dort gehören Chats und angehängte Dateien mit gelöscht.

Damit sind Deine Inhalte weg. Was liegen bleibt, ist Infrastruktur: das Docker-Image, die Ollama-Installation und weitere Modelle, die Du noch nicht entfernt hast. Nichts davon enthält Deine Dokumente, aber Platz belegt es. Was es dagegen nicht gibt: ein Konto, das gekündigt werden muss, oder ein Abo, das weiterläuft. Das ist die andere angenehme Seite an lokal.

**Tipp:** Bevor Du löschst, notier Dir welches Modell für welche Aufgabe gut war. Diese Notiz ist beim nächsten Mal mehr wert als das Modell selbst, weil die Auswahl sich alle paar Monate ändert.

## Was als nächstes

Wenn Du jetzt wissen willst, welches Modell auf Deiner konkreten Hardware das beste Ergebnis bringt, geht es in [Welches lokale Modell zu Deiner Hardware passt](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware) weiter. Wenn Du das Ganze im Unternehmen einsetzen willst, klärt [Lokale KI und die DSGVO](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) was wirklich gilt und was nur behauptet wird. Und wenn Dein lokales Modell nicht nur reden, sondern auch Werkzeuge benutzen soll, zeigt [MCP mit lokalen Modellen](https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen) den Anschluss an den Rest Deines Aufbaus.

## Quellen

Zahlen zu Speicherbedarf und Modellgrößen ändern sich mit jeder Modell-Generation. Prüf sie vor einer Kaufentscheidung an der Quelle, nicht in Blogposts.

- Ollama, Installation und Modell-Bibliothek: https://ollama.com
- LM Studio, Desktop-Oberfläche mit lokalem Server: https://lmstudio.ai
- Open WebUI, Browser-Oberfläche für lokale Modelle: https://openwebui.com
- llama.cpp, die Engine unter Ollama: https://github.com/ggml-org/llama.cpp

[← Deinen MCP-Server ändern ohne](https://studiomeyer.academy/playbooks/mcp-server-aendern-ohne-nutzer-zu-brechen) [Welches lokale Modell zu Deine →](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware)

Alle Playbooks

[01. Von ChatGPT zu Claude. Anleitung in 10 Schritten](https://studiomeyer.academy/playbooks/von-chatgpt-zu-claude) [02. Von ChatGPT zu Codex. Anleitung in 10 Schritten](https://studiomeyer.academy/playbooks/von-chatgpt-zu-codex) [03. Dein erster MCP-Server in 90 Minuten](https://studiomeyer.academy/playbooks/erster-mcp-server-in-90-minuten) [04. Memory portabel nutzen, gleiches Gedächtnis in Claude, Codex und Cursor](https://studiomeyer.academy/playbooks/memory-portabel-nutzen) [05. DACH-Legal. EU AI Act und DSGVO für AI-Operator](https://studiomeyer.academy/playbooks/dach-legal-eu-ai-act-und-dsgvo) [06. Dein erster Sub-Agent in 30 Minuten](https://studiomeyer.academy/playbooks/erster-sub-agent-in-30-min) [07. MCP-Server publishen Schritt für Schritt](https://studiomeyer.academy/playbooks/mcp-server-publishen) [08. Hooks gegen Halluzinationen](https://studiomeyer.academy/playbooks/hooks-gegen-halluzinationen) [09. Git für KI, Quickstart in 30 Minuten](https://studiomeyer.academy/playbooks/git-fuer-ki-quickstart) [10. Scheduled Agents mit Claude Code Routines](https://studiomeyer.academy/playbooks/scheduled-agents-mit-routines) [11. Tool-Sprawl vermeiden, von 530 auf 30 MCP-Tools pro Session](https://studiomeyer.academy/playbooks/tool-sprawl-vermeiden) [12. Claude Code Update-Strategie, ohne dass Dein Workflow plotzlich kaputt ist](https://studiomeyer.academy/playbooks/claude-code-update-strategie) [12. Subagent-Team strukturieren, welche sechs Rollen Du im Daily-Driver brauchst](https://studiomeyer.academy/playbooks/subagent-team-strukturieren) [13. Claude Code Cost Controls für Daily Driver, in 10 Schritten unter 30 Dollar pro Tag bleiben](https://studiomeyer.academy/playbooks/claude-code-cost-controls-fuer-daily-driver) [14. Eigene Slash-Commands für Claude Code, in 30 Minuten produktiv](https://studiomeyer.academy/playbooks/eigene-slash-commands-fuer-claude-code) [15. Claude Code headless in CI/CD, ein Setup das morgen schon läuft](https://studiomeyer.academy/playbooks/claude-code-headless-in-ci-cd) [16. Agent-Eval in 60 Minuten, wie Du herausfindest ob Dein Agent gut ist](https://studiomeyer.academy/playbooks/agent-eval-in-60-minuten) [17. Plan Mode in Claude Code, der unsichtbare Sicherheitsgurt, wann Du ihn brauchst und wie Du ihn drin lässt](https://studiomeyer.academy/playbooks/plan-mode-richtig-nutzen) [18. MCP debuggen wenn nichts geht, die 10 Checks die 90 Prozent der Fälle lösen](https://studiomeyer.academy/playbooks/mcp-debuggen-wenn-nichts-geht) [18. Prompt-Caching meistern, in 10 Schritten von Cache-Miss zu 80 Prozent Hit-Rate](https://studiomeyer.academy/playbooks/prompt-caching-meistern) [19. Memory Drift reparieren, wenn das Gedächtnis kippt](https://studiomeyer.academy/playbooks/memory-drift-reparieren) [20. MCP-STDIO-Sicherheit, was die OX-Security-Story für Dich bedeutet](https://studiomeyer.academy/playbooks/mcp-stdio-sicherheit) [21. Opus 4.7 Migration, was sich für API-Builder geändert hat](https://studiomeyer.academy/playbooks/opus-4-7-migration) [22. Erste eigene Skill in 30 Minuten, wenn Slash-Commands nicht mehr reichen](https://studiomeyer.academy/playbooks/erste-eigene-skill-in-30-min) [23. Context-Window managen in langen Claude-Code-Sessions](https://studiomeyer.academy/playbooks/context-window-managen-claude-code) [24. Advisor Tool, Opus als Berater und Sonnet als Executor in einem API-Call](https://studiomeyer.academy/playbooks/advisor-tool-opus-als-berater-sonnet-als-executor) [25. MCP-Server mit OAuth 2.1 absichern, in 60 Minuten produktiv](https://studiomeyer.academy/playbooks/mcp-server-auth-mit-oauth-2-1) [26. Plugin-Bundles per URL teilen, --plugin-url in 30 Minuten](https://studiomeyer.academy/playbooks/plugin-bundle-via-url-distribution) [27. Claude Code im Team, wie ihr CLAUDE.md gemeinsam pflegt ohne dass es zur Mülltonne wird](https://studiomeyer.academy/playbooks/claude-code-im-team-claude-md-gemeinsam-pflegen) [27. Fremde Claude-Code-Plugins aus ZIP und URL laden, sicher in 20 Minuten](https://studiomeyer.academy/playbooks/claude-code-plugins-aus-zip-und-url-laden) [28. Confused-Deputy-Audit für Claude Code, in 25 Minuten durchziehen](https://studiomeyer.academy/playbooks/confused-deputy-audit-fuer-claude-code) [28. Dein erstes Claude Code Plugin in 60 Minuten, vom leeren Folder zum installierbaren Bundle](https://studiomeyer.academy/playbooks/dein-erstes-claude-code-plugin) [29. Pull Request Reviews mit Claude Code, 10 Schritte für den PR-Workflow den keiner mehr blockiert](https://studiomeyer.academy/playbooks/pull-request-reviews-mit-claude-code) [30. Claude Projects für Nicht-Coder, ein produktiver Workspace in 30 Minuten](https://studiomeyer.academy/playbooks/claude-projects-fuer-nicht-coder) [31. Promptbibliothek aufbauen, Lieblings-Prompts wiederverwenden ohne Copy-Paste](https://studiomeyer.academy/playbooks/prompt-bibliothek-aufbauen) [32. Output Styles für Claude Code, in 20 Minuten ein eigener Ton](https://studiomeyer.academy/playbooks/output-styles-fuer-claude-code) [33. Statusline für Claude Code, in 15 Minuten Kontext im Blick](https://studiomeyer.academy/playbooks/statusline-fuer-claude-code) [34. Claude Code Checkpoints und /rewind: dein Sicherheitsnetz für riskante Edits](https://studiomeyer.academy/playbooks/claude-code-checkpoints-und-rewind) [34. Discovery-Files konsistent halten, damit AI-Crawler nicht alte Bullshit-Bios zitieren](https://studiomeyer.academy/playbooks/discovery-files-konsistent-halten) [34. Hooks debuggen wenn nichts feuert](https://studiomeyer.academy/playbooks/hooks-debuggen-wenn-nichts-feuert) [34. Parallele Claude-Code-Sessions mit git worktrees, zwei Branches gleichzeitig ohne Konflikt](https://studiomeyer.academy/playbooks/parallele-claude-sessions-mit-worktrees) [34. Skill triggert nicht, was Du in 10 Schritten prüfst bevor Du wieder /befehl tippst](https://studiomeyer.academy/playbooks/skill-trigger-debugging) [34. Sub-Agent oder Skill oder MCP-Tool, was wählst Du wann](https://studiomeyer.academy/playbooks/sub-agent-oder-skill-oder-mcp-tool) [35. Mit Git Worktrees parallele Claude-Code-Sessions fahren](https://studiomeyer.academy/playbooks/claude-code-mit-git-worktrees) [35. Memory-Backup vor Update, damit Du nach einem Schema-Migrations-Bug nicht weinst](https://studiomeyer.academy/playbooks/memory-backup-vor-update) [36. AGENTS.md neben CLAUDE.md, ein Repo-Kontext für mehrere AI-Tools](https://studiomeyer.academy/playbooks/agents-md-neben-claude-md) [47. Generative Engine Optimization für kleine Sites, damit Perplexity und ChatGPT-Search Dich zitieren](https://studiomeyer.academy/playbooks/geo-fuer-kleine-sites) [50. Opus 4.8 Migration, das erste Opus-Update ohne Breaking Changes](https://studiomeyer.academy/playbooks/opus-4-8-migration) [51. Background-Sessions mit Claude Agents: lange Tasks laufen lassen ohne dein Terminal zu blockieren](https://studiomeyer.academy/playbooks/background-sessions-mit-claude-agents) [52. Claude Code Bash-Sandbox einrichten: Befehle isolieren statt blind freigeben](https://studiomeyer.academy/playbooks/claude-code-bash-sandbox-einrichten) [53. Vom Skript zum eigenen Agent: der Claude Agent SDK in 90 Minuten](https://studiomeyer.academy/playbooks/claude-agent-sdk-erster-eigener-agent) [54. MCP App bauen: interaktive UI in deinem MCP-Tool statt Text-Wand](https://studiomeyer.academy/playbooks/mcp-app-interaktive-ui-bauen) [55. Mythos teure Modellklasse: Wann sich das teuerste KI-Modell wirklich lohnt](https://studiomeyer.academy/playbooks/mythos-klasse-wann-lohnt-sich-das) [56. Fallback-Modelle einrichten, damit Claude Code bei Overload nicht stehenbleibt](https://studiomeyer.academy/playbooks/claude-code-fallback-modelle) [57. Dynamic Workflows in Claude Code, dein erstes orchestriertes Multi-Agent-Skript](https://studiomeyer.academy/playbooks/dynamic-workflows-in-claude-code) [58. Security-Guidance Plugin für Claude Code, automatischer Sicherheits-Review während du baust](https://studiomeyer.academy/playbooks/claude-code-security-guidance-plugin) [59. Claude Code spinnt nach einer Config-Änderung, so findest du die Ursache](https://studiomeyer.academy/playbooks/claude-code-safe-mode-diagnose) [60. MCP ist stateless, was die 2026-07-28 Spec ändert und was Du jetzt tun musst](https://studiomeyer.academy/playbooks/mcp-spec-2026-07-was-aendert-sich) [61. Dein erster echter n8n-Flow, Automatisierung für Leute die nicht programmieren](https://studiomeyer.academy/playbooks/mein-erster-n8n-flow-fuer-nicht-coder) [62. Agentic Payments mit x402, was Du als Builder über maschinen-bezahlte APIs wissen musst](https://studiomeyer.academy/playbooks/agentic-payments-x402) [63. GPT-5.6 oder Opus 5, welches Modell für welche Aufgabe](https://studiomeyer.academy/playbooks/gpt-5-oder-opus-4-8-welches-modell) [64. Subagents die Subagents spawnen, die 5-Ebenen-Regel von Claude Code](https://studiomeyer.academy/playbooks/subagents-die-subagents-spawnen) [65. Claude Code Agent Teams einrichten, mehrere Sessions die sich gegenseitig zuarbeiten](https://studiomeyer.academy/playbooks/claude-code-agent-teams-einrichten) [66. Modell-Verfügbarkeit tracken, wenn ein Modell über Nacht verschwindet](https://studiomeyer.academy/playbooks/modell-verfuegbarkeit-tracken) [67. Datenschutz beim Arbeiten mit KI-Tools: zehn Gewohnheiten, die dich schützen](https://studiomeyer.academy/playbooks/datenschutz-mit-ki-tools) [68. Auto Mode in Claude Code sicher nutzen, in 10 Schritten ohne Selbstmord-Kommandos](https://studiomeyer.academy/playbooks/claude-code-auto-mode-sicher-nutzen) [69. KI für die Jobsuche: In 10 Schritten durch den ATS-Filter](https://studiomeyer.academy/playbooks/ki-fuer-jobsuche) [70. In 10 Schritten ein AI-Portfolio bauen das dir einen Job bringt](https://studiomeyer.academy/playbooks/ai-portfolio-fuer-den-job) [71. AI-Skills im Lebenslauf und Interview glaubwürdig belegen](https://studiomeyer.academy/playbooks/ai-skills-belegen-lebenslauf-interview) [72. Effort-Level in Claude Code, wann low reicht und wann Du max brauchst](https://studiomeyer.academy/playbooks/effort-level-in-claude-code-einstellen) [73. Vom Academy-Skill zum ersten bezahlten KI-Auftrag](https://studiomeyer.academy/playbooks/erster-bezahlter-ki-auftrag) [74. Eine KI-Antwort faktenchecken: 10 Schritte gegen falsche Auskünfte](https://studiomeyer.academy/playbooks/ki-antwort-faktenchecken) [75. KI-Bilder für deine Marke, vom ersten Prompt zum fertigen Set](https://studiomeyer.academy/playbooks/ki-bilder-fuer-deine-marke) [76. KI für Selbstständige, Angebote und Kundenmails in der halben Zeit schreiben](https://studiomeyer.academy/playbooks/ki-fuer-selbststaendige-angebote-und-mails) [77. KI-Inhalte erkennen und richtig kennzeichnen](https://studiomeyer.academy/playbooks/ki-inhalte-erkennen-und-kennzeichnen) [78. KI-Notizen für Meetings, die wirklich brauchbar sind](https://studiomeyer.academy/playbooks/ki-notizen-fuer-meetings) [79. Lokale KI auf dem eigenen Rechner, damit deine Daten nie das Haus verlassen](https://studiomeyer.academy/playbooks/lokale-ki-auf-dem-eigenen-rechner) [80. Die drei MCP-Primitive verstehen, Tools, Resources und Prompts](https://studiomeyer.academy/playbooks/mcp-primitives-tools-resources-prompts) [81. Verlässliches JSON aus jeder AI, damit Deine Automation nicht bricht](https://studiomeyer.academy/playbooks/verlaessliches-json-aus-ai) [82. Was KI-Tools wirklich kosten, und wo die versteckten Rechnungen lauern](https://studiomeyer.academy/playbooks/was-kostet-ki-wirklich) [83. Prompt Injection verstehen, die drei Fallen wenn dein KI-Assistent fremde Texte liest](https://studiomeyer.academy/playbooks/prompt-injection-erkennen) [84. Dich vor KI-Betrug schützen, Fake-Anrufe, Phishing und falsche Job-Angebote](https://studiomeyer.academy/playbooks/dich-vor-ki-betrug-schuetzen) [85. Opus 5 Migration, wenn Denken plötzlich der Standard ist](https://studiomeyer.academy/playbooks/opus-5-migration) [86. Die KI-Richtlinie für kleine Teams, auf einer Seite](https://studiomeyer.academy/playbooks/ki-richtlinie-fuer-kleine-teams) [87. Agenten die abdriften stoppen](https://studiomeyer.academy/playbooks/agenten-die-abdriften-stoppen) [88. Sehen was Dein Agent wirklich getan hat, Tracing in 10 Schritten mit OpenTelemetry](https://studiomeyer.academy/playbooks/agent-tracing-mit-opentelemetry) [89. Lange Dokumente von KI zusammenfassen lassen, ohne dass sie Sachen erfindet](https://studiomeyer.academy/playbooks/lange-dokumente-sicher-zusammenfassen) [90. Fremde MCP-Server sicher prüfen, bevor Du sie installierst](https://studiomeyer.academy/playbooks/fremde-mcp-server-sicher-pruefen) [91. KI als Lern-Coach: ein neues Feld lernen für den Berufswechsel](https://studiomeyer.academy/playbooks/ki-lern-coach-berufswechsel) [92. Berufsbild AI-Operator: was macht man da eigentlich?](https://studiomeyer.academy/playbooks/berufsbild-ai-operator) [93. KI nutzen ohne selbst zu verlernen](https://studiomeyer.academy/playbooks/ki-nutzen-ohne-selbst-zu-verlernen) [94. Warum dein Screenshot schrumpft, und wie du das steuerst](https://studiomeyer.academy/playbooks/bilder-und-screenshots-an-die-ki-geben) [95. Einen Deep-Research-Auftrag formulieren, damit der Bericht auch was taugt](https://studiomeyer.academy/playbooks/deep-research-auftrag-formulieren) [96. Zahlen und Tabellen mit KI auswerten, ohne dass am Ende Unsinn rauskommt](https://studiomeyer.academy/playbooks/zahlen-und-tabellen-mit-ki-auswerten) [97. KI-Benchmarks lesen ohne dich verarschen zu lassen](https://studiomeyer.academy/playbooks/ki-benchmarks-richtig-lesen) [98. KI als Sparringspartner, bessere Entscheidungen statt netter Zustimmung](https://studiomeyer.academy/playbooks/ki-als-sparringspartner-fuer-entscheidungen) [99. Mit KI eine neue Fähigkeit lernen, der ehrliche Weg](https://studiomeyer.academy/playbooks/mit-ki-neue-faehigkeit-lernen) [100. Deinen MCP-Server ändern ohne die Nutzer zu brechen](https://studiomeyer.academy/playbooks/mcp-server-aendern-ohne-nutzer-zu-brechen) [101. Dein erstes lokales KI-Modell in 30 Minuten](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) [102. Welches lokale Modell zu Deiner Hardware passt](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware) [103. Lokale KI und die DSGVO, was sie wirklich löst und was nicht](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) [104. MCP mit lokalen Modellen, Werkzeuge ohne Cloud](https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen) [105. Lokal oder Cloud, die ehrliche Rechnung](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung) [106. Wenn ein fremdes Repo Deine KI konfiguriert. Der ChainDrop-Fall](https://studiomeyer.academy/playbooks/agent-konfiguration-als-angriffsweg) [107. Gespräche offline transkribieren, ohne dass sie das Haus verlassen](https://studiomeyer.academy/playbooks/gespraeche-offline-transkribieren) [108. n8n mit einem lokalen Modell verbinden](https://studiomeyer.academy/playbooks/n8n-mit-lokalem-modell-verbinden) [109. Dokumente offline auslesen, wenn der Scan nicht hochgeladen werden darf](https://studiomeyer.academy/playbooks/dokumente-offline-auslesen) [→ Zur Academy](https://studiomeyer.academy/levels/1)

## Sitemap

Öffentliche Seiten dieser Website als Markdown: [Sitemap](https://studiomeyer.academy/sitemap.md). Kuratierter Einstieg: [llms.txt](https://studiomeyer.academy/llms.txt), Volltext: [llms-full.txt](https://studiomeyer.academy/llms-full.txt).