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

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

Playbook· lokal

# Tu primer modelo de IA local en 30 minutos

Un modelo de lenguaje en tu propio ordenador, sin nube y sin cuenta. Diez pasos desde la instalación hasta el primer resultado útil, incluidos los puntos donde la mayoría abandona y los ajustes que siguen llamando afuera incluso con modelo local.

Hay dos razones para ejecutar un modelo de lenguaje en tu propio ordenador. Una es la privacidad, y en Alemania eso pesa más que en otros sitios. La otra es que quieres ver por ti mismo qué es realmente esta cosa cuando no hay una empresa por medio. Ambas son buenas razones.

Lo que obtienes es un modelo que responde sin conexión. Sin cuenta, sin facturación por token, sin transferencia a un proveedor. Lo que no obtienes es la calidad de Opus 5 o GPT-5.6. Eso no es poca cosa, y en el paso 9 digo con claridad dónde está el límite. Pero para una cantidad sorprendente de tareas lo local basta, y llegar ahí lleva media hora.

## 1\. Comprueba primero si tu ordenador da la talla

Antes de instalar nada, mira cuánta memoria tienes. En un Mac con Apple Silicon cuenta la memoria compartida, es decir el número que ponía 16 GB o 32 GB al comprarlo. En un ordenador con Windows o Linux y tarjeta gráfica dedicada cuenta la memoria de esa tarjeta, no la del equipo.

El orden de magnitud, a fecha de agosto de 2026, separado por tipo de equipo. Con una **tarjeta gráfica dedicada** dispones de casi toda su memoria: 8 GB bastan para un modelo pequeño, 16 GB son cómodos, a partir de 24 GB se pone serio en contenido. En **Apple Silicon** procesador y gráfica comparten la misma memoria y solo una parte va al modelo, en torno a dos tercios o tres cuartos. De 16 GB salen unos 11 GB utilizables, de 32 GB unos 22. En un Mac, calcula por tanto un escalón más generoso que el número de la caja. Sin tarjeta gráfica también va, solo que más lento, porque calcula el procesador principal.

**Consejo:** Si dudas, empieza igualmente. El primer intento no te cuesta nada salvo espacio en disco, y eso lo recuperas con un comando.

## 2\. Instala Ollama

Ollama es la entrada más cómoda. Descarga modelos, se ocupa del formato y expone una interfaz que a otros programas les parece la de OpenAI. Eso es más práctico de lo que suena, porque permite que muchas herramientas hablen con tu modelo local sin reformas.

En ollama.com hay instaladores para Mac, Windows y Linux. Tras instalar, un pequeño servicio corre en segundo plano, accesible por defecto solo desde tu propio ordenador. Puedes comprobarlo desde la terminal:

```bash
ollama --version
```

**Consejo:** Si prefieres una interfaz para hacer clic antes que una terminal, usa LM Studio. Hace lo mismo y tiene un navegador de modelos integrado. Ojo con los comandos de más abajo: LM Studio arranca su servidor a mano desde la interfaz y escucha en un puerto distinto al de Ollama. La dirección aparece allí en la pestaña del servidor, y esa es la que va en el paso 8 en lugar de la de Ollama. Los comandos `ollama` valen solo para Ollama.

## 3\. Descarga un primer modelo adecuado

Empieza pequeño. Un modelo de siete a nueve mil millones de parámetros con la compresión habitual cabe en ocho gigabytes y responde con fluidez en un ordenador normal.

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

La descarga son unos gigabytes. Mientras tanto puedes leer el paso 4.

**Consejo:** El número antes de la `b` son miles de millones de parámetros, o sea la clase de tamaño. Lo que va detrás, algo como `q4_K_M`, es la compresión. Más sobre eso en [Qué modelo local encaja con tu hardware](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware).

## 4\. Entiende en una frase qué es la cuantización

Un modelo se entrena con números muy precisos. Para ejecutarlo, esos números pueden guardarse de forma más basta, parecido a guardar una foto como JPEG en vez de RAW. El resultado es más pequeño y más rápido, y la mayoría de las veces no se nota la diferencia.

El ajuste habitual se llama `Q4_K_M`. Frente al original sin comprimir, la memoria necesaria baja aproximadamente a una cuarta parte, y la pérdida de calidad es tan pequeña que en el día a día no salta a la vista. No son exactamente cuatro bits por número, se suman valores de escala, por eso el tamaño real del archivo siempre queda algo por encima del cálculo puro. Ollama lo elige automáticamente, no tienes que configurar nada. Lo importante es que sepas de qué se habla cuando leas la etiqueta en algún sitio.

**Consejo:** No bajes de Q4. Q2 y Q3 ahorran más memoria, pero ahí el modelo empieza a volverse notablemente más torpe. Cuánto depende del modelo y de la tarea, y con código y llamadas a herramientas se degrada antes que con prosa.

## 5\. Habla con el modelo por primera vez

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

Aterrizas en un chat en la terminal. Haz una pregunta cuya respuesta ya conozcas, para poder juzgar la calidad. Algo de tu propio campo funciona mejor que una pregunta de cultura general, porque en lo técnico notas enseguida si hay sustancia o solo suena bien.

Sales con `/bye`.

**Consejo:** La primera respuesta tarda más porque el modelo se carga en memoria. A partir de la segunda va ágil. Así que si al principio piensas que esto es inservible de lento, espera al segundo intento.

## 6\. Pon una interfaz delante

Chatear en la terminal está bien para probar e incómodo para el día a día. Open WebUI te da una interfaz en el navegador que parece la de los servicios de chat habituales, pero corre entera en tu ordenador. Reconoce tus modelos de Ollama por sí sola.

Con Docker es un comando, pero en Mac y Windows se ve distinto que en Linux. La diferencia no es cosmética: Ollama escucha solo en `127.0.0.1`, y un contenedor no alcanza por sí solo esa dirección del anfitrión.

En **Mac y Windows**, Docker Desktop crea el nombre `host.docker.internal`, con el que el contenedor alcanza al anfitrión. El comando va aquí en una sola línea para que se pegue igual de bien en Terminal, PowerShell y símbolo del sistema:

```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
```

Lo importante es el `-p 127.0.0.1:3000:8080`: con eso la interfaz solo es accesible desde tu propio ordenador.

En **Linux** ese nombre no existe, y la salida que se lee en todas partes es una trampa. `--network=host` sí deja al contenedor alcanzar el Ollama de `127.0.0.1`, pero elimina la atadura a localhost: la interfaz pasa entonces a escuchar en todas las interfaces. Poner un cortafuegos delante suena a solución pero no es fiable, porque `ufw status: active` no dice nada sobre si ese puerto concreto está cerrado. Y el riesgo es concreto: en una instalación nueva de Open WebUI, la primera persona que se registra se convierte en administradora. Quien esté en la misma red pudo llegar antes.

Por eso esa vía no aparece aquí. En Linux usa la imagen que ya trae Ollama:

```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
```

Ese contenedor tiene su propio Ollama, así que no hay que pasar nada al anfitrión, y ambas ataduras a `127.0.0.1` aguantan sin cortafuegos alguno. El segundo puerto expone la interfaz de Ollama del contenedor, que necesitas en el paso 8. Está a propósito en 11435 y no en 11434, para que no choque con un Ollama que siga instalado en el equipo. Los modelos los descargas aquí desde la interfaz o con `docker exec -it open-webui ollama pull qwen3:8b`. El Ollama del paso 2 ya no hace falta para la interfaz; para los pasos 3 a 5 en la terminal sí fue útil, y puedes dejarlo o desinstalarlo.

Quien no quiera ni Docker ni dos Ollamas, que use LM Studio en Linux. Trae interfaz y gestión de modelos en uno.

Después abre `http://localhost:3000` en el navegador. La versión fija en el comando de Mac y Windows es intencionada: `:main` se mueve bajo tus pies. La etiqueta `:ollama` de Linux también se mueve, ahí no hay equivalente fijo. Fijar un build de forma exacta solo se consigue con su digest.

**Consejo:** A más tardar aquí merece la pena tener una conversación con un encargo real en vez de con preguntas de prueba. Solo entonces notas si el modelo te vale.

## 7\. Dale al modelo tus propios documentos

El punto donde los modelos locales se vuelven interesantes no es el conocimiento general. Ahí pierden frente a los grandes proveedores. Se vuelve interesante cuando ven algo que no quieres dar a ningún proveedor.

Arrastra un PDF al chat en Open WebUI y pide un resumen. Un contrato, un acta, una factura. Justo las cosas ante las que dudas un momento con ChatGPT.

Antes de meter algo realmente sensible, una salvedad. Local es el modelo, no automáticamente toda la interfaz. Si allí está activada la búsqueda web, hay configurado un servicio de embeddings en la nube para buscar en documentos o hay registrado un modelo ajeno como alternativa, partes de tus datos sí salen. Repasa una vez los ajustes y apaga lo que apunte hacia fuera. Después sí vale la frase de que el archivo no sale del ordenador.

**Consejo:** Al principio mantén los documentos cortos. No porque los modelos pequeños tengan de por sí una ventana de contexto pequeña, eso depende del modelo y no del número de parámetros, sino porque los documentos largos se trocean y se leen solo por fragmentos. En un contrato de 80 páginas eso significa que el resumen puede omitir una cláusula importante sin avisar. Así que contrasta por muestreo los documentos largos con el original.

## 8\. Haz el modelo accesible para otros programas

Ollama expone su interfaz en el puerto 11434 y habla el formato que la mayoría de herramientas conocen de OpenAI. Con eso, en muchos programas basta con cambiar la dirección y de repente la misma aplicación corre contra tu modelo local.

El comando de abajo vale para el Ollama de tu equipo. Con el contenedor de Linux que trae Ollama incluido es la misma interfaz, solo que en el puerto que expusiste en el paso 6: allí pones `11435` en vez de `11434`. Lo demás no cambia.

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

Si llega una respuesta, la interfaz está abierta y puedes seguir construyendo.

**Consejo:** Por defecto el puerto solo es accesible desde tu propio ordenador, y está bien así. Si lo abres a la red, piensa antes quién más está en esa red.

## 9\. Espera lo correcto o te decepcionarás

Aquí va la valoración honesta, sin la cual este playbook estaría incompleto.

Lo que va bien en local: resumir, reformular, traducir, ordenar, clasificar, sacar la estructura de un texto, preguntas sencillas sobre un documento adjunto. O sea, toda la parte laboriosa del trabajo con textos.

Lo que va peor en local: cadenas largas de razonamiento, arquitectura de software difícil, trabajar de forma autónoma a lo largo de muchos pasos, todo lo que exige pensar de verdad en profundidad. Ahí los modelos grandes no son un poco mejores, son claramente mejores.

Esto no es una debilidad pasajera que se arregle la semana que viene. Es el precio de que algo corra en un aparato que está bajo tu escritorio en vez de en un centro de datos. Quien lo acepta tiene una herramienta muy útil. Quien espera un sustituto de Opus 5 lo dejará a los dos días.

**Consejo:** El montaje más productivo suele ser mixto. Local para todo lo que lleve datos sensibles y para el trabajo en masa, nube para los casos duros. Las cuentas están en [Local o nube, las cuentas honestas](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung).

## 10\. Recoge si no quieres quedártelo

Los modelos ocupan sitio, y al probar se acumulan varios rápido. Con el Ollama de tu equipo va así:

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

Con el contenedor de Linux que trae Ollama incluido, los mismos comandos pero dentro del contenedor:

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

En ambos casos eso quita **solo el modelo**. Tus documentos subidos, los historiales de conversación y los índices de búsqueda están en otro sitio, en el área de datos de la interfaz. Justo el material por el que trabajaste en local. Quien borra solo el modelo y cree haber recogido, deja ahí los contratos y los informes médicos.

Del todo fuera es así:

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

Si en Linux usaste el contenedor con Ollama incluido, allí queda una segunda copia de los modelos en su propio volumen:

```bash
docker volume rm ollama
```

En LM Studio el equivalente está en la carpeta del programa dentro de tu directorio de usuario; ahí van también los chats y los archivos adjuntos.

Con eso tus contenidos desaparecen. Lo que queda es infraestructura: la imagen de Docker, la instalación de Ollama y los modelos que aún no hayas quitado. Nada de eso contiene tus documentos, pero ocupa sitio. Lo que no hay: una cuenta que cancelar o una suscripción que siga corriendo. Esa es la otra cara agradable de lo local.

**Consejo:** Antes de borrar, apunta qué modelo iba bien para qué tarea. Esa nota vale más la próxima vez que el modelo en sí, porque la oferta cambia cada pocos meses.

## Qué sigue

Si ahora quieres saber qué modelo da el mejor resultado en tu hardware concreto, sigue en [Qué modelo local encaja con tu hardware](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware). Si quieres usarlo en la empresa, [IA local y el RGPD](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) aclara qué se aplica de verdad y qué solo se afirma. Y si tu modelo local no solo debe hablar sino también usar herramientas, [MCP con modelos locales](https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen) enseña la conexión con el resto de tu montaje.

## Fuentes

Las cifras sobre memoria necesaria y tamaños de modelo cambian con cada generación. Compruébalas en la fuente antes de una decisión de compra, no en blogs.

- Ollama, instalación y biblioteca de modelos: https://ollama.com
- LM Studio, interfaz de escritorio con servidor local: https://lmstudio.ai
- Open WebUI, interfaz de navegador para modelos locales: https://openwebui.com
- llama.cpp, el motor bajo Ollama: https://github.com/ggml-org/llama.cpp

[← Cambiar tu servidor MCP sin ro](https://studiomeyer.academy/playbooks/mcp-server-aendern-ohne-nutzer-zu-brechen) [Qué modelo local encaja con tu →](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware)

Alle Playbooks

[01. De ChatGPT a Claude, guía en 10 pasos](https://studiomeyer.academy/playbooks/von-chatgpt-zu-claude) [02. De ChatGPT a Codex, guía en 10 pasos](https://studiomeyer.academy/playbooks/von-chatgpt-zu-codex) [03. Tu primer servidor MCP en 90 minutos](https://studiomeyer.academy/playbooks/erster-mcp-server-in-90-minuten) [04. Memoria portable, la misma memoria en Claude, Codex y Cursor](https://studiomeyer.academy/playbooks/memory-portabel-nutzen) [05. DACH legal. EU AI Act y GDPR para operadores de IA](https://studiomeyer.academy/playbooks/dach-legal-eu-ai-act-und-dsgvo) [06. Tu primer sub-agente en 30 minutos](https://studiomeyer.academy/playbooks/erster-sub-agent-in-30-min) [07. Publicar un servidor MCP paso a paso](https://studiomeyer.academy/playbooks/mcp-server-publishen) [08. Hooks contra alucinaciones](https://studiomeyer.academy/playbooks/hooks-gegen-halluzinationen) [09. Git para IA, quickstart en 30 minutos](https://studiomeyer.academy/playbooks/git-fuer-ki-quickstart) [10. Agents programados con Claude Code routines](https://studiomeyer.academy/playbooks/scheduled-agents-mit-routines) [11. Evitar el tool sprawl, de 530 a 30 MCP tools por sesión](https://studiomeyer.academy/playbooks/tool-sprawl-vermeiden) [12. Estrategia de updates de Claude Code, sin que tu workflow se rompa de golpe](https://studiomeyer.academy/playbooks/claude-code-update-strategie) [12. Estructurar tu equipo de subagentes, los seis roles que necesitas en el día a día](https://studiomeyer.academy/playbooks/subagent-team-strukturieren) [13. Cost controls de Claude Code para uso diario, quedarte bajo 30 dólares al día en 10 pasos](https://studiomeyer.academy/playbooks/claude-code-cost-controls-fuer-daily-driver) [14. Tus propios slash commands para Claude Code, productivo en 30 minutos](https://studiomeyer.academy/playbooks/eigene-slash-commands-fuer-claude-code) [15. Claude Code headless en CI/CD, un setup que ya corre mañana](https://studiomeyer.academy/playbooks/claude-code-headless-in-ci-cd) [16. Eval de agente en 60 minutos, cómo saber si tu agente es bueno](https://studiomeyer.academy/playbooks/agent-eval-in-60-minuten) [17. Plan Mode en Claude Code, el cinturón invisible, cuándo lo necesitas y cómo dejarlo puesto](https://studiomeyer.academy/playbooks/plan-mode-richtig-nutzen) [18. Depurar MCP cuando nada funciona, los 10 checks que resuelven el 90 por ciento de los casos](https://studiomeyer.academy/playbooks/mcp-debuggen-wenn-nichts-geht) [18. Dominar el prompt caching, de cache miss al 80 por ciento de aciertos en 10 pasos](https://studiomeyer.academy/playbooks/prompt-caching-meistern) [19. Reparar memory drift, cuando la memoria de tu agente empieza a contradecirse](https://studiomeyer.academy/playbooks/memory-drift-reparieren) [20. Seguridad de MCP STDIO, qué significa para ti la historia de OX Security](https://studiomeyer.academy/playbooks/mcp-stdio-sicherheit) [21. Migración a Opus 4.7, qué cambió para builders de API](https://studiomeyer.academy/playbooks/opus-4-7-migration) [22. Tu primer Skill en 30 minutos, cuando los slash commands ya no bastan](https://studiomeyer.academy/playbooks/erste-eigene-skill-in-30-min) [23. Gestionar la ventana de contexto en sesiones largas de Claude Code](https://studiomeyer.academy/playbooks/context-window-managen-claude-code) [24. Advisor Tool, Opus como asesor y Sonnet como ejecutor en una sola llamada API](https://studiomeyer.academy/playbooks/advisor-tool-opus-als-berater-sonnet-als-executor) [25. Asegura tu servidor MCP con OAuth 2.1 en 60 minutos](https://studiomeyer.academy/playbooks/mcp-server-auth-mit-oauth-2-1) [26. Distribuir plugin bundles via URL, --plugin-url en 30 minutos](https://studiomeyer.academy/playbooks/plugin-bundle-via-url-distribution) [27. Claude Code en equipo, cómo mantener vivo CLAUDE.md sin que se convierta en un cubo de basura](https://studiomeyer.academy/playbooks/claude-code-im-team-claude-md-gemeinsam-pflegen) [27. Cargar plugins ajenos de Claude Code desde ZIP y URL, seguro en 20 minutos](https://studiomeyer.academy/playbooks/claude-code-plugins-aus-zip-und-url-laden) [28. Auditoría de confused deputy para Claude Code, hecha en 25 minutos](https://studiomeyer.academy/playbooks/confused-deputy-audit-fuer-claude-code) [28. Tu primer plugin de Claude Code en 60 minutos, de la carpeta vacía al bundle instalable](https://studiomeyer.academy/playbooks/dein-erstes-claude-code-plugin) [29. Pull request reviews con Claude Code, 10 pasos para un workflow de PR que nadie bloquea ya](https://studiomeyer.academy/playbooks/pull-request-reviews-mit-claude-code) [30. Claude Projects para no-coders, un workspace productivo en 30 minutos](https://studiomeyer.academy/playbooks/claude-projects-fuer-nicht-coder) [31. Construir una biblioteca de prompts, reutilizar tus prompts favoritos sin copy-paste](https://studiomeyer.academy/playbooks/prompt-bibliothek-aufbauen) [32. Output Styles para Claude Code, un tono propio en 20 minutos](https://studiomeyer.academy/playbooks/output-styles-fuer-claude-code) [33. Statusline para Claude Code, contexto a la vista en 15 minutos](https://studiomeyer.academy/playbooks/statusline-fuer-claude-code) [34. Checkpoints y /rewind en Claude Code: tu red de seguridad para ediciones arriesgadas](https://studiomeyer.academy/playbooks/claude-code-checkpoints-und-rewind) [34. Mantener coherentes los discovery files para que los crawlers de IA no citen bios viejas y falsas](https://studiomeyer.academy/playbooks/discovery-files-konsistent-halten) [34. Depurar hooks cuando no se dispara nada](https://studiomeyer.academy/playbooks/hooks-debuggen-wenn-nichts-feuert) [34. Sesiones paralelas de Claude Code con git worktrees, dos ramas a la vez sin conflicto](https://studiomeyer.academy/playbooks/parallele-claude-sessions-mit-worktrees) [34. La skill no se dispara, qué comprobar en 10 pasos antes de volver a teclear /comando](https://studiomeyer.academy/playbooks/skill-trigger-debugging) [34. Sub-agente o skill o herramienta MCP, ¿cuál eliges y cuándo?](https://studiomeyer.academy/playbooks/sub-agent-oder-skill-oder-mcp-tool) [35. Llevar sesiones paralelas de Claude Code con git worktrees](https://studiomeyer.academy/playbooks/claude-code-mit-git-worktrees) [35. Backup de memoria antes de actualizar, para que no llores por un bug de migración de esquema](https://studiomeyer.academy/playbooks/memory-backup-vor-update) [36. AGENTS.md junto a CLAUDE.md, un contexto de repo para varias herramientas de IA](https://studiomeyer.academy/playbooks/agents-md-neben-claude-md) [47. Generative Engine Optimization para sitios pequeños, para que Perplexity y ChatGPT-Search te citen](https://studiomeyer.academy/playbooks/geo-fuer-kleine-sites) [50. Migración a Opus 4.8, la primera actualización de Opus sin breaking changes](https://studiomeyer.academy/playbooks/opus-4-8-migration) [51. Sesiones en segundo plano con agentes de Claude: ejecuta tareas largas sin bloquear tu terminal](https://studiomeyer.academy/playbooks/background-sessions-mit-claude-agents) [52. Configura la sandbox de bash de Claude Code: aísla comandos en vez de permitirlos a ciegas](https://studiomeyer.academy/playbooks/claude-code-bash-sandbox-einrichten) [53. Del script a tu propio agente: el Claude Agent SDK en 90 minutos](https://studiomeyer.academy/playbooks/claude-agent-sdk-erster-eigener-agent) [54. Crea una MCP App: UI interactiva en tu herramienta MCP en lugar de un muro de texto](https://studiomeyer.academy/playbooks/mcp-app-interaktive-ui-bauen) [55. El mito del modelo caro: cuándo merece la pena de verdad el modelo de IA más caro](https://studiomeyer.academy/playbooks/mythos-klasse-wann-lohnt-sich-das) [56. Configurar modelos de fallback para que Claude Code no se quede colgado en sobrecarga](https://studiomeyer.academy/playbooks/claude-code-fallback-modelle) [57. Dynamic workflows en Claude Code, tu primer script multiagente orquestado](https://studiomeyer.academy/playbooks/dynamic-workflows-in-claude-code) [58. Plugin security-guidance para Claude Code, revisión de seguridad automática mientras construyes](https://studiomeyer.academy/playbooks/claude-code-security-guidance-plugin) [59. Claude Code falla tras un cambio de configuración, cómo encontrar la causa](https://studiomeyer.academy/playbooks/claude-code-safe-mode-diagnose) [60. MCP es stateless: qué cambia la spec 2026-07-28 y qué tienes que hacer ahora](https://studiomeyer.academy/playbooks/mcp-spec-2026-07-was-aendert-sich) [61. Tu primer flujo real en n8n: automatización para quienes no programan](https://studiomeyer.academy/playbooks/mein-erster-n8n-flow-fuer-nicht-coder) [62. Pagos agénticos con x402, lo que un builder debe saber sobre APIs pagadas por máquinas](https://studiomeyer.academy/playbooks/agentic-payments-x402) [63. GPT-5.6 u Opus 5, qué modelo para qué tarea](https://studiomeyer.academy/playbooks/gpt-5-oder-opus-4-8-welches-modell) [64. Subagents que generan subagents, la regla de 5 niveles de Claude Code](https://studiomeyer.academy/playbooks/subagents-die-subagents-spawnen) [65. Configurar agent teams en Claude Code, varias sesiones que se ayudan entre sí](https://studiomeyer.academy/playbooks/claude-code-agent-teams-einrichten) [66. Rastrear la disponibilidad de modelos, cuando un modelo desaparece de la noche a la mañana](https://studiomeyer.academy/playbooks/modell-verfuegbarkeit-tracken) [67. Protección de datos al trabajar con herramientas de IA: diez hábitos que te protegen](https://studiomeyer.academy/playbooks/datenschutz-mit-ki-tools) [68. Usar Auto Mode en Claude Code con seguridad, en 10 pasos sin comandos suicidas](https://studiomeyer.academy/playbooks/claude-code-auto-mode-sicher-nutzen) [69. IA para la búsqueda de empleo: 10 pasos para pasar el filtro ATS](https://studiomeyer.academy/playbooks/ki-fuer-jobsuche) [70. Construye en 10 pasos un portafolio de IA que te consiga trabajo](https://studiomeyer.academy/playbooks/ai-portfolio-fuer-den-job) [71. Demostrar tus habilidades de IA de forma creíble en el CV y la entrevista](https://studiomeyer.academy/playbooks/ai-skills-belegen-lebenslauf-interview) [72. Niveles de effort en Claude Code, cuándo basta low y cuándo necesitas max](https://studiomeyer.academy/playbooks/effort-level-in-claude-code-einstellen) [73. Del skill de la Academy al primer encargo de IA pagado](https://studiomeyer.academy/playbooks/erster-bezahlter-ki-auftrag) [74. Verificar una respuesta de IA: 10 pasos contra la información falsa](https://studiomeyer.academy/playbooks/ki-antwort-faktenchecken) [75. Imágenes de IA para tu marca, del primer prompt al set terminado](https://studiomeyer.academy/playbooks/ki-bilder-fuer-deine-marke) [76. IA para autónomos, escribir presupuestos y correos a clientes en la mitad de tiempo](https://studiomeyer.academy/playbooks/ki-fuer-selbststaendige-angebote-und-mails) [77. Detectar y etiquetar correctamente el contenido de IA](https://studiomeyer.academy/playbooks/ki-inhalte-erkennen-und-kennzeichnen) [78. Notas de reuniones con IA que de verdad sirven](https://studiomeyer.academy/playbooks/ki-notizen-fuer-meetings) [79. IA local en tu propio ordenador, para que tus datos nunca salgan de casa](https://studiomeyer.academy/playbooks/lokale-ki-auf-dem-eigenen-rechner) [80. Entender las tres primitivas de MCP. Tools, Resources y Prompts](https://studiomeyer.academy/playbooks/mcp-primitives-tools-resources-prompts) [81. JSON fiable de cualquier IA, para que tu automatización no se rompa](https://studiomeyer.academy/playbooks/verlaessliches-json-aus-ai) [82. Lo que cuestan de verdad las herramientas de IA, y dónde acechan las facturas ocultas](https://studiomeyer.academy/playbooks/was-kostet-ki-wirklich) [83. Entender la prompt injection, las tres trampas cuando tu asistente de IA lee textos ajenos](https://studiomeyer.academy/playbooks/prompt-injection-erkennen) [84. Protegerte del fraude con IA, llamadas falsas, phishing y ofertas de empleo falsas](https://studiomeyer.academy/playbooks/dich-vor-ki-betrug-schuetzen) [85. Migración a Opus 5, cuando pensar pasa a ser lo normal](https://studiomeyer.academy/playbooks/opus-5-migration) [86. La política de IA para equipos pequeños, en una sola página](https://studiomeyer.academy/playbooks/ki-richtlinie-fuer-kleine-teams) [87. Frenar a los agentes que se desvían](https://studiomeyer.academy/playbooks/agenten-die-abdriften-stoppen) [88. Ver qué hizo realmente tu agente, tracing en 10 pasos con OpenTelemetry](https://studiomeyer.academy/playbooks/agent-tracing-mit-opentelemetry) [89. Que la IA resuma documentos largos sin que se invente cosas](https://studiomeyer.academy/playbooks/lange-dokumente-sicher-zusammenfassen) [90. Revisar servidores MCP ajenos con seguridad antes de instalarlos](https://studiomeyer.academy/playbooks/fremde-mcp-server-sicher-pruefen) [91. La IA como coach de aprendizaje: aprender un campo nuevo para cambiar de profesión](https://studiomeyer.academy/playbooks/ki-lern-coach-berufswechsel) [92. El perfil de AI operator: ¿en qué consiste realmente?](https://studiomeyer.academy/playbooks/berufsbild-ai-operator) [93. Usar la IA sin perder tu propio criterio](https://studiomeyer.academy/playbooks/ki-nutzen-ohne-selbst-zu-verlernen) [94. Por qué tu captura se encoge y cómo controlarlo](https://studiomeyer.academy/playbooks/bilder-und-screenshots-an-die-ki-geben) [95. Formular un encargo de deep research para que el informe valga algo](https://studiomeyer.academy/playbooks/deep-research-auftrag-formulieren) [96. Analizar cifras y tablas con IA sin acabar con disparates](https://studiomeyer.academy/playbooks/zahlen-und-tabellen-mit-ki-auswerten) [97. Leer benchmarks de IA sin que te tomen el pelo](https://studiomeyer.academy/playbooks/ki-benchmarks-richtig-lesen) [98. La IA como sparring, mejores decisiones en vez de amable aprobación](https://studiomeyer.academy/playbooks/ki-als-sparringspartner-fuer-entscheidungen) [99. Aprender una habilidad nueva con IA, por el camino honesto](https://studiomeyer.academy/playbooks/mit-ki-neue-faehigkeit-lernen) [100. Cambiar tu servidor MCP sin romper a los usuarios](https://studiomeyer.academy/playbooks/mcp-server-aendern-ohne-nutzer-zu-brechen) [101. Tu primer modelo de IA local en 30 minutos](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) [102. Qué modelo local encaja con tu hardware](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware) [103. IA local y el RGPD, qué resuelve de verdad y qué no](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) [104. MCP con modelos locales, herramientas sin nube](https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen) [105. Local o nube, las cuentas honestas](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung) [106. Cuando el repo de otro configura tu IA. El caso ChainDrop](https://studiomeyer.academy/playbooks/agent-konfiguration-als-angriffsweg) [107. Transcribir conversaciones sin conexión, sin que salgan de casa](https://studiomeyer.academy/playbooks/gespraeche-offline-transkribieren) [108. Conectar n8n con un modelo local](https://studiomeyer.academy/playbooks/n8n-mit-lokalem-modell-verbinden) [109. Leer documentos sin conexión, cuando el escaneo no se puede subir](https://studiomeyer.academy/playbooks/dokumente-offline-auslesen) [→ Zur Academy](https://studiomeyer.academy/levels/1)

## Sitemap

Páginas públicas de este sitio como Markdown: [sitemap](https://studiomeyer.academy/sitemap.md). Punto de entrada curado: [llms.txt](https://studiomeyer.academy/llms.txt), texto completo: [llms-full.txt](https://studiomeyer.academy/llms-full.txt).