Bitácora de Claude

Abro **Ajustes** y empiezo por **Privacidad**. Es lo primero que configuro, antes de subir nada. Si ya he trabajado con otro LLM, es probable que esto ya lo tenga resuelto.

Estas son las opciones y lo que decido en cada una:

Mi razón: si tengo esa opción activa y subo un dato de un cliente, la probabilidad de que se filtre es alta. Desactivarla es una medida de seguridad adicional, pero **no garantiza por sí sola el cumplimiento de la ley de protección de datos**.

En **Facturación** veo el uso de la sesión actual. Claude trabaja con **ventanas de 5 horas**, y cada ventana tiene su propio margen.

Por encima están los **límites semanales**. Cada cuenta tiene su propio día de reinicio. También aparece un indicador específico de **Sonnet**. En mi caso marca 0 %, porque trabajo casi todo con **Opus**.

En **Capacidades** está la memoria: un documento que recoge cómo voy gestionando lo que Claude sabe de mí. Desde ahí puedo **verla y editarla**, y corregir o quitar lo que se haya quedado y no quiero.

La memoria de la versión de navegador **no es compartida** con la de la aplicación de escritorio. A veces esa separación me viene bien para aislar determinadas investigaciones.

Importar memoria desde otra IA

Si vengo de ChatGPT, pulso **Iniciar importación** y Claude me da un prompt para extraer toda la información. Pegado tal cual, ChatGPT devuelve **todo**: incluso consultas de 2024 como cocinar una pizza casera en la freidora. Esa información no es relevante y **contamina** la memoria de Claude.

La solución es **personalizar el prompt** (hay un vídeo de la formación que explica cómo) para que ChatGPT clasifique mis inputs antes de importar:

Yo lo he hecho y **funciona muy bien**. El prompt personalizado está enlazado debajo del vídeo de la formación.

En **Acceso a herramientas** elijo cómo se cargan los conectores. Por defecto suele venir *herramientas ya cargadas*.

Yo prefiero **cargar herramientas cuando sea necesario**. La tendencia dentro de Claude es a **sobrecargar el contexto**: si todos los conectores habilitados se cargan siempre, **se consumen tokens de forma sistemática**.

Con la carga bajo demanda, Claude evalúa **cuándo** necesita acceder al correo, al calendario o a otras herramientas, como Excalidraw. Vuelvo a este tema en una sesión posterior.

Visuales en la conversación

Dentro del chat tengo **artefactos**, **artefactos impulsados por inteligencia artificial** y **visualizaciones integradas**. Es parte de la configuración y no exige más decisiones.

Salida a red

En **Permitir salida a red** (ejecución de código y creación de archivos) puedo fijar **dominios permitidos** para que Claude acceda al exterior.

La razón: al navegar y ser agéntico, Claude es **muy susceptible al prompt injection**. Lo veré más a fondo en la versión de escritorio y en Claude Code.

Guardarraíles frente al prompt injection

Los dejo escritos en la **configuración de memoria y de personalización**. Si todavía no los tengo, abro una conversación y le pregunto a Claude **cómo configurarlo de la forma más segura**. Me dirá que lo haga yo.

Eso tiene un segundo valor: es una forma de que **Claude me conozca** y de que yo vaya **poniendo los límites** de la conversación.

**Skills**: están en *Personalizar*. Las desarrollo en una sesión posterior.

**Conectores**: también en *Personalizar*, donde ya están integrados. Hay un catálogo amplio de aplicaciones: Zoho CRM, APIs para scrapers, control de Google Chrome e incluso Spotify. Los exploro según mi necesidad.

Mantengo **conectores distintos** en la versión de navegador (Claude.ai) y en la aplicación de escritorio, porque las uso para cosas diferentes.

**Microsoft 365** se conecta a través de la parte de empresa, y el resto de conexiones queda restringido por la organización en la que trabaje. **En Claude Code** puedo añadir **conectores personalizados mediante MCP**.

En la sección de **Claude in Chrome** habilito la extensión con *permitir extensión* y el asistente me guía en la descarga. Una vez instalada, aparece en el **panel lateral derecho** del navegador.

Puedo **añadir sitios web bloqueados** a mano, por ejemplo espacios maliciosos conocidos o a los que no quiero que acceda.

Está en **beta** y **tiene riesgo**. A cambio, me da **mucha libertad de navegación** y me ayuda mucho en el día a día. Funciona como el asistente de navegación habitual, con una diferencia: **tiene en cuenta mi memoria de Claude**, lo que aporta mucho contexto. Puedo pedirle que abra el navegador y busque algo para complementar un trabajo.

En Claude, la **flecha hacia abajo** da acceso a las descargas: la integración con **Microsoft Office** (Excel y PowerPoint), la aplicación de escritorio y las aplicaciones del móvil.

Vengo de Google Workspace, donde Gemini está integrado de forma nativa en los documentos. Por eso tener Claude de forma nativa en **Excel para análisis de datos** me parece **muy potente**. En **PowerPoint** no lo uso: creo las presentaciones dentro del propio Claude.

**Cowork** y **Claude Code** solo están disponibles en la aplicación de escritorio.

En el menú de la izquierda, los **Proyectos** (que también están ya en la aplicación de escritorio) funcionan como **bases de conocimiento**. Empezaron con la misma función que los GPTs de ChatGPT o los Gems de Gemini, con una diferencia: admiten una **cantidad muy grande de archivos de contexto**.

No llegan a los 2 millones de tokens de Gemini, pero sí a **un millón de tokens** por sistema [⚠ por confirmar].

Además de ser una base documental, admiten **memoria específica del proyecto**. Así trabajo un tema de forma sistemática **sin que se contamine** con otros proyectos paralelos.

Los **Artifacts** llevan mucho tiempo en Claude y hay muchas cosas que acabo delegando en herramientas externas y que puedo resolver aquí. Equivalen al **Canvas** de Gemini y de ChatGPT: construyo mis propias aplicaciones y trabajo con ellas **directamente desde el chat**.

Estos son los que uso o he planteado:

Como son artifacts, los puedo **invocar directamente dentro del propio chat** de Claude.

La pestaña de **Código** abre una sección de Claude Code **vinculada directamente a GitHub**. Aquí no accedo a mis archivos locales, pero sí a mis **repositorios**.

Permite **tareas programadas** sobre los repositorios, por ejemplo una **revisión diaria de código**: escribo un prompt y elijo los repositorios que tengo subidos a GitHub.

He trabajado poco esta versión web de Claude Code.

Desde esta versión web puedo **nutrir la versión de Claude en la nube con lo que trabajo en Claude Code** [⚠ por confirmar]. Con esto termino con la versión web y paso a la aplicación de escritorio.

En la aplicación de escritorio tengo **tres pestañas**: **Chat**, **Cowork** y **Código**. En la práctica uso muy poco el Chat de escritorio y trabajo cada vez menos con Cowork. **Código es el grueso**: ahí vive Claude Code.

Los ajustes de **Privacidad** son prácticamente los mismos que en la versión web. La diferencia es que aquí puedo configurar **conectores concretos** y los **ajustes propios de Claude Code**.

Ajustes de Claude Code que reviso

No entro más en detalle porque ya lo he visto antes: son ajustes que solo tienen efecto **dentro de la aplicación**.

Tareas programadas

Con un plan de uso alto, me **apalanco muchísimo en las tareas programadas** que veíamos al principio. Puedo repartirlas por franjas horarias: en mi panel tengo una tarea a las 9, dos a las 8 y otra a las 5.

Así puedo dejar a Claude **trabajando por la noche**: auditorías u otros trabajos que, a la larga, me **ahorran muchísimo tiempo**. Las iré viendo por proyectos a lo largo de la formación, con cómo configurarlas bien y cómo apalancarme en Claude para que las configure.

Dispatch

**Dispatch** me conecta con el móvil para **trabajar en remoto con mis archivos locales**. La condición: **el ordenador tiene que estar encendido**.

Yo no lo he activado, porque paso el día entero delante del ordenador y llevarme además el trabajo al móvil me parecería excesivo. Si tuviera que viajar a Madrid o a Barcelona, **dejaría Dispatch activado** y podría arreglar mis workflows desde el móvil con tranquilidad. Es una **ventaja enorme**.

Han añadido otras funcionalidades nuevas dentro de Claude que iré viendo a lo largo del curso.

En **Personalizar** tengo varias cosas. Las **habilidades** (skills) las trato en la siguiente sesión: qué es una skill y cómo configurarla bien.

Después están los **conectores**. En mi caso uso **Context7**, un **servidor MCP**. El concepto de MCP lo explicaré también más adelante, para quien no lo controle.

Context7 **analiza la documentación de las API** que contiene, que son la mayoría, **actualizada en tiempo real** para mis aplicaciones. Es un **superpoder**: no tengo que buscar información nueva ni **gastar tokens extra** consultando bases de información. Es **uno de los mejores conectores** que se pueden encontrar.

En el botón **Más** puedo explorar conectores concretos, pero Context7 no aparece en el catálogo. Para añadirlo uso **Agregar conector personalizado** y necesito un **OAuth** o un **secreto de cliente**. El enlace está debajo del vídeo de la formación. Lo veré más adelante, a nivel de personalización total; por ahora basta con saber **dónde está cada cosa**.

Algo fundamental que me **ahorra muchísimo tiempo** es el modo de permisos. Tengo cuatro: **solicitar permisos**, **aceptar ediciones automáticamente**, **modo de planificación** y **omitir permisos** [⚠ por confirmar: en el original se anuncian tres y se enumeran cuatro].

Con **omitir permisos** activo aparece un cuadro que avisa de que Claude puede cometer imprudencias o faltas de seguridad. En términos de responsabilidad **no es lo mejor**, y por eso los **guardarraíles** son tan importantes.

En la terminal han añadido un modo llamado **auto mode**, que hace lo mismo pero **con capas de seguridad**. En la aplicación de escritorio todavía no estaba implementado.

Cómo se activa omitir permisos

1. Pulso mi nombre, abajo a la izquierda.
2. Entro en **Configuración**.
3. Abro **Claude Code**.
4. Activo **Permitir modo de omisión de permisos**.

Al activarlo aparece un aviso: hay que tener cuidado. El modo funciona bien para flujos como **corregir errores** o **generar código repetitivo**, pero permitir que Claude ejecute **comandos arbitrarios** es arriesgado y puede acabar en **pérdida de datos**.

Yo lo tengo **activo por defecto** y, de momento, **sin incidencias**, gracias al tipo de guardarraíles que pongo. **Es una práctica arriesgada**: la documentación oficial recomienda usar este modo solo en entornos aislados (ver la actualización). Una vez activo, en el **directorio de trabajo** no me pide permiso para nada. Si accede a **otras carpetas**, por ejemplo la de otro proyecto, **sí me pide permiso**.

Qué significa “en la nube”

Cuando uso un programa de la forma habitual, el trabajo ocurre **en mi ordenador**. Si lo apago o cierro la tapa, se para. “En la nube” significa que el trabajo ocurre **en los servidores de Anthropic**, no en mi equipo.

La idea es **encargar una tarea y no esperar delante**. Le explico a Claude qué quiero, me puedo ir y él sigue. Cuando vuelvo, el resultado está guardado **en mi cuenta**, disponible desde cualquier dispositivo.

Tres formas de hacerlo

Cómo activo Cowork en la nube

1. Compruebo que tengo un **plan de pago**. En la web, Cowork está disponible en Pro, Max y Team. En la aplicación de escritorio, en todos los planes de pago.
2. Abro **claude.ai** (pestaña Inicio), la app móvil o la de escritorio, siempre en su **versión más reciente**. Si no aparece Cowork, actualizo la app.
3. En la caja de mensaje, abajo a la izquierda, elijo **Cowork** en lugar de Chat. Para volver a una conversación normal, elijo Chat.
4. Describo la tarea con claridad. Claude la ejecuta en remoto.
5. Miro el avance desde cualquier dispositivo. El móvil me avisa cuando termina o cuando necesita algo de mí.

Cómo activo Claude Code en la web

1. Preparo un **repositorio en GitHub**. Es el requisito de partida.
2. Entro en **claude.ai/code** con mi cuenta de Claude.
3. **Conecto GitHub**: la página me pide instalar la app de Claude para GitHub. Si ya uso la herramienta gh en la terminal, también puedo ejecutar /web-setup.
4. Creo un **entorno en la nube**: el espacio donde Claude trabajará. Define qué se instala y qué acceso a red tiene.
5. Elijo el repositorio en el selector bajo la caja de mensaje y escribo la tarea.

Qué puedo hacer y qué sigue necesitando mi ordenador

Para qué me sirve

Ejemplos de uso que cita la documentación de Claude Code:

• Una **revisión de código a medida** cada vez que se abre una pull request.
• Una **revisión nocturna** del repositorio con un prompt fijo.
• Una **comprobación semanal de documentación**: revisar las pull requests fusionadas y señalar los documentos que citan algo que ha cambiado.

Antes de lanzarme: precauciones

• **Es beta.** En las sesiones remotas todavía faltan algunas funciones.
• **Las rutinas no piden aprobación mientras se ejecutan**, y los commits y pull requests salen con mi usuario de GitHub. Defino con cuidado el prompt, los repositorios y los conectores antes de activarlas.
• Una sesión de Claude Code web puede acceder a **cualquier repositorio que vea la cuenta de GitHub conectada**, no solo a aquellos donde instalé la app.
• Las variables y los scripts de un entorno en la nube **los ve cualquiera que pueda editarlo**.
• El uso de Claude, Claude Desktop y Claude Code **cuenta contra el mismo límite** del plan.
• Con datos de terceros o sensibles, leo antes el artículo oficial “Use Claude Cowork safely”.

Hay muchos nombres parecidos: Claude, Cowork, Claude Code, Cursor, Antigravity, los IDEs. Al empezar de cero es un lío. Mi objetivo es tener claro **para qué sirve cada herramienta y para qué no**, y eso es **bastante importante**.

Lo organizo en cuatro pasos: el **inventario**, un **marco de tres preguntas** para elegir herramienta, una **tabla de decisión con casos reales** y **cuándo no usar un agente**, ya sea Cowork o Claude Code (bloque 22).

Trabajo con **una sola herramienta**: **Claude Desktop**, la aplicación de escritorio. Dentro hay **tres pestañas**, arriba a la izquierda: **Chat** a la izquierda, **Cowork** en el medio y **Code** a la derecha. Todo lo demás es **opcional, complementario o externo**.

Se anuncian seis herramientas, pero lo que enumero es Claude Desktop con sus tres pestañas, la CLI y los IDEs [⚠ por confirmar el recuento]. **Resumen: trabajo con Claude Desktop y con sus tres pestañas: Chat, Cowork y Code.**

**No es lo mismo**, y aquí hay mucha confusión. Estas son las diferencias a grandes rasgos.

Chat

Es una interacción de **pregunta y respuesta**: pregunto, me contesta y listo. Es como usar ChatGPT a la antigua usanza. No hay memoria entre sesiones, salvo que trabaje con **proyectos** o con una memoria muy compactada de cosas pequeñas que le voy diciendo, como la que tienen ChatGPT o Gemini. No hay memoria persistente como en los agentes.

**No toca mi ordenador**: trabaja en la nube de Claude, sin acceso a nada mío. Es ideal para **brainstorming**, **redacción**, **dudas puntuales** y **resumir textos largos** que pego. Y tiene una ventaja importante: **no contamina mi contexto**.

Su límite es que **todo requiere trabajo manual**. No puede conectarse con una herramienta externa, por ejemplo mi página web, y hacer algo en ella [⚠ por confirmar: más adelante, en el bloque 20, el Chat sí se conecta a calendario, Gmail, Drive y Notion mediante conectores].

Agente (Cowork)

Un agente **percibe, planifica, actúa y observa a la vez**. Lee archivos y carpetas directamente de mi ordenador; puede **crear, editar y mover archivos** y **ejecutar scripts**. Tiene **bucles autónomos**: si algo falla, se autocorrige, lo vuelve a intentar y me da la solución final. Es **proactivo**.

Es ideal para **reorganizar carpetas** (lo hace de escándalo), construir webs, auditar repositorios y crear aplicaciones. La única limitación que le veo es que **requiere una carpeta abierta**: tengo que decirle “trabaja sobre esta carpeta, sobre este entorno de mi ordenador”, y eso lo hace menos instantáneo.

Para saber qué herramienta uso, me hago **tres preguntas**, de forma muy sencilla.

1. **¿Necesito que tenga acceso a los archivos de mi ordenador?** Si la respuesta es no, tiro siempre de la pestaña **Chat** o de **claude.ai en la web**, que es lo mismo. Si es sí, paso a la siguiente.
2. **¿Es una tarea operativa o un proyecto con código?** Si es operativa, siempre **Cowork**. Si es un proyecto que requiere código, un desarrollo de web o de aplicaciones, siempre **Code**.
3. **¿La tarea dura más de 30 minutos?** Si no, necesito un modo rápido y directo: **Chat**. Por ejemplo, para resumir algo o pedir contexto, no hace falta un agente en Cowork; no tiene sentido. Si sí, seguramente tendré que entrar en **plan mode** y en **CLAUDE.md**, que configuraré en próximas sesiones.

Esto es para hacerlo de la manera más organizada posible. Mucha gente trabaja todo con Code y nunca con Cowork. Puede servir para las dos cosas, pero Claude está montado para que vaya a Code cuando necesito trabajar con código. En resumen: **tarea rápida, Chat; tarea más larga que requiere mis archivos, Cowork o Code** [⚠ por confirmar: el original manda al Chat las tareas de menos de 30 minutos aunque necesiten archivos].

Esta es la tabla de decisión con casos reales. Puedo filtrarla por herramienta.

**Resumen:** Chat cuando no necesito mis archivos; Cowork y Code para trabajar de forma agéntica sobre mis archivos. Los IDEs, como Cursor o Antigravity, quedan **fuera de este curso** (bloque 21).

Los IDEs, como Cursor o Antigravity, quedan **fuera de este curso**. Son algo **un pelín más avanzado** y **un pelín diferente**, y Claude Desktop ya me da **todo el ecosistema que necesito** para trabajar.

Si ya trabajo con Cursor o Antigravity y me siento cómoda, **puedo seguir haciéndolo**. De hecho, puedo **usar modelos de Claude** dentro de esos ecosistemas. La mayoría de lo que veo para trabajar con Claude también se puede trabajar con Antigravity.

Para este curso lo centralizo todo en **Claude Desktop**. Si toco herramientas distintas a la vez, **acabaría liándome**.

Esto es **súper importante**, porque mucha gente abre Cowork para todo y quiere hacerlo todo con agentes. Hay situaciones en las que no es bueno e incluso es **contraproducente**.

Esto nos pasa a todos. Cada vez que voy a abrir un agente me pregunto: **¿realmente necesito un agente, o Cowork, o Claude Code, para esta tarea?** Muchas veces la respuesta es no, sobre todo si la tarea es rápida. Entonces **abro el Chat**: es más eficiente, más rápido y **no contamino el contexto de mis archivos**. Profundizaré en eso más adelante.

Antes de practicar, **instalo Claude Desktop**. Es un paso sencillo y probablemente ya esté hecho, pero lo repaso para empezar de cero: **descargo la aplicación, la instalo como cualquier otro programa, la abro, inicio sesión y verifico el plan**.

La descarga se hace desde la web de Claude, eligiendo **Mac** o **Windows** según mi equipo. Al entrar me pide que verifique que soy yo con el inicio de sesión. El plan se ve **abajo a la izquierda**: puede aparecer como gratuito, Pro o Max.

Como mínimo conviene el plan **Pro**, de 20 dólares al mes [⚠ por confirmar: el precio se da en euros y en dólares]. Da **muchos más tokens y más margen para trabajar**. Con el plan gratuito, hay quien ve Code y quien no [⚠ por confirmar: comentario de oídas].

Abro **Cowork** y lo primero es **elegir la carpeta de trabajo**. La interfaz lo plantea como *trabajar en un proyecto*. Puedo elegir una carpeta existente o **crear una nueva**.

La clave es **acotar**. Si le doy el escritorio o la carpeta de documentos, le doy acceso a **todo** lo que hay dentro, y eso suele ser demasiado amplio. Cuanto más acoto la ruta, más restringido queda su espacio de trabajo.

Una estructura que funciona: una carpeta madre, por ejemplo “Proyectos de Claude”, con **una subcarpeta por proyecto** (una web, un cliente, una prueba). **Cowork solo tiene acceso a una carpeta por proyecto** [⚠ por confirmar]. Es la forma estándar de trabajar.

Para empezar, creo una carpeta nueva con un nombre de prueba y le doy acceso solo a ella. Al abrirla aparece el aviso de **permiso para que Claude modifique archivos dentro de esa carpeta**. Elijo **permitir siempre**, acotado a esa carpeta. Todo lo que haga aquí se guarda aquí, y puedo crear subcarpetas y documentos con permisos solo sobre ella.

**Code funciona igual.** Cambio a Code, veo la carpeta sobre la que trabaja y, para cambiarla, elijo *abrir carpeta*. El entorno pasa a la nueva. También puedo añadir otra carpeta de referencia, pero lo habitual es trabajar con una sola [⚠ por confirmar].

Para probar, le doy a Cowork un encargo sencillo: que **busque en internet y escriba un documento Markdown** con la mejor manera de publicar en una red profesional. Lo envío y observo.

**Cowork planifica primero.** A la derecha aparece el **progreso**: lo que hace en cada momento. Investiga estrategias, busca en varias webs de forma automática para reunir todo el contexto y después redacta el documento.

Cuando termina, el documento está **dentro de mi carpeta de trabajo** y puedo abrirlo desde el propio resultado. Es lo esperado: **Cowork crea documentos en mi ordenador a partir de lo que le pido**, y siempre dentro de la carpeta que le he dado.

En la carpeta puede haber un archivo **CLAUDE.md**, **vacío al principio** [⚠ por confirmar: que Cowork lo cree por sí solo]. Contiene **las instrucciones de Claude para esa carpeta**: qué contexto tiene, y se va completando con el trabajo, por ejemplo con el prompt de cierre del bloque 34. Es importante porque **cada vez que abro una sesión, Cowork o Code leen este documento**. Es una **memoria persistente** del proyecto.

**Markdown** es texto plano con una estructura que a la inteligencia artificial le resulta fácil de interpretar. Usa **almohadillas** para los títulos y **asteriscos** para destacar. Lo abro con el editor de texto del sistema para ver cómo es: sin formato visual, solo la estructura.

En la interfaz, el archivo se presenta como un lugar para **dar instrucciones a Claude sobre cómo trabajar en esa carpeta**. Puedo pedirle que añada ahí cómo quiero trabajar. Lo desarrollo en próximas explicaciones.

Con la carpeta ya en marcha, **amplío el trabajo**: pido lo mismo para otra red social y que **cree una carpeta** con un nombre claro para esa información y **guarde ahí los documentos**.

Vuelven a aparecer las **tareas planificadas**: primero investigar, después crear la carpeta y organizar los documentos y, por último, redactar. Mientras tanto veo cómo se crea la carpeta y cómo se añaden los archivos.

El resultado es **dos documentos y una subcarpeta**. Todo lo que hay dentro de la carpeta inicial **puede modificarlo Claude directamente**: puedo pedirle que añada más información o que quite alguna.

Abajo está el **selector de modelos**. Mientras Cowork trabaja aparece **bloqueado**: en Cowork **no puedo cambiar de modelo a mitad de una conversación** [⚠ por confirmar]. En Code veré que sí se puede. Para elegir, abro una **tarea nueva** y selecciono ahí.

Cuando lo vi, el selector mostraba Opus 4.7 como el más potente, Sonnet 4.6, Haiku 4.5 y otros anteriores, como Opus 4.6. Esto **cambia con el tiempo**.

El **pensamiento adaptativo** conviene tenerlo **encendido**: según lo que pida la tarea, Claude usa un modelo u otro y así **ahorro tokens**. Si detecta que no hace falta Opus, se ajusta solo [⚠ por confirmar: ver la actualización].

Arriba a la izquierda tengo **todas las conversaciones**. Cuando termino de trabajar, lo interesante es que **se guarde una memoria** para que la sesión siguiente arranque con contexto.

Al cerrar, le pido algo así: **voy a cerrar la sesión; guarda un archivo de memoria con todo lo trabajado y todo el contexto**. Me responde que lo ha guardado y puedo abrir la **memoria de sesión**, que recoge **de forma muy detallada** lo trabajado.

En una **sesión nueva de la misma carpeta**, le pido que **revise la memoria** para tener el contexto, y continuamos. Claude mira **primero las instrucciones de CLAUDE.md**, que lo hace siempre, y **después la memoria de sesión**. A partir de ahí **propone por dónde seguir** según todo el contexto: otras redes, un documento comparativo, una skill o un calendario editorial.

Hoy lo hago de forma **manual**. En Code se puede hacer de forma más automática, cuando llegue a temas más avanzados.

Estos son los errores más habituales y cómo los resuelvo.

Con esto ya tengo una carpeta de trabajo, dos archivos creados y una subcarpeta, y sé cómo guardar el contexto entre sesiones. Sigo con la siguiente parte.

El **contexto** es todo lo que Claude tiene presente en una conversación: mis instrucciones, los archivos que lee y sus propias respuestas. Tiene un límite, la **ventana de contexto**. Entender cómo se llena explica la mayoría de los problemas de calidad en las sesiones largas.

A medida que se llena, **la calidad de las respuestas baja**. Se dice que ocurre a partir de la mitad de la ventana [⚠ por confirmar: no hay umbral oficial]. Este deterioro se conoce como **context rot**: cuantos más tokens hay en el contexto, peor recupera el modelo la información que contiene.

Al llegar al límite, Claude **condensa**: hace un autorresumen y borra la parte de arriba para dejar espacio. **Pierde información**, y no sé en qué momento lo hará. La recomendación es **no llegar al 100 % ni depender de la condensación**: guardar lo importante en archivos y seguir en una conversación nueva.

La gestión del contexto no es igual en las dos herramientas.

En Code, además, el indicador **ya marca algo antes de escribir**, porque las instrucciones y la memoria que se cargan al empezar consumen parte de la ventana. Lo veo llenarse a medida que trabajo.

En Cowork la gestión es menos directa, pero se puede **mitigar con hábitos**, que veo en el bloque siguiente. Los niveles de esfuerzo los veo más adelante.

Sin comandos ni indicador, en Cowork **gestiono el contexto con tres hábitos**.

**Cambio de tarea es igual a conversación nueva.** El contexto se contamina más rápido de lo que parece: si pregunto por un proyecto nuevo con el contexto del anterior cargado, la respuesta sale mezclada. Con el contexto limpio, la misma pregunta da una respuesta distinta y mejor [⚠ por confirmar: sin respaldo oficial].

Cuando en una conversación larga quiero hacer otra cosa, **no la hago ahí**. Le pido un **prompt de traspaso**, lo copio a una conversación nueva y, como ya remite a los archivos de la carpeta, **no tengo que volver a explicar nada**. Al arrancar le pido además que lea CLAUDE.md o la memoria anterior, y puedo combinarlo con el prompt nuevo.

Si todo se hace en una misma conversación, acabará **condensándose sola**: me avisa de que va a condensar, pero no cuándo, y al hacerlo pierde mucha información. Los comandos de limpiar y comprimir existen en Code, que veo más adelante.

Tres prompts dan estructura al día de trabajo con Cowork. Los copio tal cual, y los nombres de archivo se pueden adaptar a cada proyecto.

Buenos días. Léete CLAUDE.md y dime en qué estábamos.

Lee este PDF y resúmelo en bullets accionables. Sin opinión, datos.

Antes de cerrar: 1) actualiza CLAUDE.md con lo que hemos hecho hoy, 2) lista los pendientes en pendientes.md, 3) si hay decisiones tomadas, añádelas a decisions-log.md.

Y para continuar en otra conversación sin perder contexto, una plantilla de **traspaso**:

Quiero hacer [tarea nueva], pero no aquí: el contexto ya está llegando al límite. Dame un prompt para hacerlo en otra sesión.

Variaciones más completas de los mismos cuatro prompts, para trabajos en los que la **trazabilidad** importa. Piden evidencia, separan lo confirmado de lo supuesto y evitan que se invente lo que falta.

Buenos días. Antes de empezar, lee CLAUDE.md, pendientes.md y decisions-log.md. Después dime, en un máximo de diez líneas: 1) dónde lo dejamos, 2) qué decisiones siguen vigentes y cuáles conviene revisar, 3) los tres pendientes más importantes y en qué orden, 4) qué dato podría estar desactualizado. Si falta algún archivo, dímelo en lugar de suponer su contenido. Termina proponiendo la primera acción de hoy.

Lee este PDF y entrégame: 1) un resumen en viñetas accionables, 2) los datos clave con la página de la que salen, 3) lo que el documento no aclara o en lo que se contradice, 4) las preguntas que debería resolver antes de actuar. Usa solo lo que aparece en el documento, sin opinión. Si algo no está en el texto, indícalo en lugar de completarlo por tu cuenta. Guarda el resumen en notas/[nombre]-resumen.md.

Antes de cerrar: 1) actualiza CLAUDE.md con lo hecho hoy, indicando la fecha y los archivos modificados; 2) lista los pendientes en pendientes.md, ordenados por prioridad; 3) añade a decisions-log.md cada decisión tomada con su fecha, el motivo y las alternativas descartadas; 4) separa en cada archivo lo confirmado de lo que sigue siendo una suposición. No borres entradas anteriores y no anotes nada que no se haya hecho de verdad.

Quiero hacer [tarea nueva], pero no aquí: el contexto ya está llegando al límite. Prepárame un prompt autosuficiente para otra conversación que indique el objetivo, los archivos de la carpeta que debe leer primero, las decisiones ya tomadas que no debe reabrir, lo que sigue pendiente y el formato del resultado que espero.

Son tres errores que se repiten al principio, y cada uno tiene una corrección sencilla.

Con esta estructura **no tengo que volver a explicar nada**: al arrancar le pido que lea lo anterior y sigo desde ahí.

Con todo lo anterior queda una rutina de cuatro pasos para el día.

Cuatro ideas para llevarme:

• Arrancar siempre pidiendo que lea CLAUDE.md y me diga en qué estábamos.
• /compact comprime sin cerrar, pero solo existe en Code. En Cowork, conversación nueva al cambiar de tarea.
• Una tarea, un prompt. Nunca cinco cosas en el mismo mensaje.
• Cierre antes de terminar, con CLAUDE.md actualizado: si no, al día siguiente se empieza desde cero.

**Reto:** identificar la tarea que más veces se explica desde cero. Esa es la que va a CLAUDE.md: si Cowork la conoce de entrada, deja de ser necesario explicarla. Basta con empezar por una.

Los subagentes, que trabajan cada uno con su propio contexto, los veo en próximas explicaciones.

Un prompt mejor escrito no corrige un planteamiento mal pensado. Con IA, **el límite suele estar en cómo pienso antes de escribir**, y no tanto en cómo escribo.

La IA **amplifica lo que ya hay**. Con buen criterio acelera el trabajo; sin él, acelera también los errores, y lo hace con la misma fluidez.

Kahneman describe dos modos de pensar. El **Sistema 1** es rápido, automático e intuitivo. El **Sistema 2** es lento, deliberado y analítico. Una respuesta fluida y segura empuja a quedarse en el primero: leer, aceptar y copiar. Trabajar bien con IA exige pasar al segundo.

Los modelos generan respuestas **plausibles, no garantizadas**: una respuesta convincente puede ser incorrecta. Por eso **verificar forma parte del trabajo**, no es un paso opcional.

Hay además un dato poco intuitivo: usar IA mejora el resultado, pero **también hace sobreestimarlo**, y la sobreestimación es mayor en quienes se consideran más versados en IA. Saber más de IA no protege por sí solo. Una posible defensa es observar cómo pienso, lo que se llama metacognición [⚠ por confirmar: es una interpretación, no un resultado del estudio].

Son atajos mentales que sirven en la vida cotidiana y que, con IA, se vuelven trampas: la respuesta llega fluida, ordenada y con tono de experto. **No son defectos**, sino el funcionamiento normal del cerebro. Lo útil es **reconocerlos cuando aparecen**.

A esto se suma que los modelos tienden a **darle la razón a quien les escribe**, lo que refuerza los sesgos 1 y 2. Por eso conviene pedir de forma explícita que señalen lo que ven mal.

Para no depender de acordarme de los ocho sesgos, uso un conjunto corto de preguntas de control repartidas en **tres momentos**.

Conviene tenerlas **a la vista, junto a la pantalla**. Con el uso se interiorizan, pero al principio hace falta el recordatorio.

Un primer ejercicio: elegir una **decisión reciente tomada con ayuda de IA** y repasar las siete preguntas.

Son dos cosas que se confunden. El **pensamiento crítico** es analizar evidencia, detectar falacias y evaluar argumentos. El **criterio** es saber cuándo aplicar qué, leer el contexto y decidir con matices.

La IA puede ayudar con lo primero, aunque no está libre de errores. Lo segundo depende de lo que solo yo conozco: mis datos, mi equipo, mi mercado y las consecuencias de decidir. **Sin criterio, el análisis de la IA no basta para decidir.**

Por eso la IA sirve mejor como **crítico** que como validador. Antes de decidir, le pido que busque los puntos débiles de mi idea; con su respuesta delante, la decisión sigue siendo mía.

**Iterar** es mejorar un resultado de forma progresiva. **Insistir** es repetir lo mismo esperando que salga distinto. La señal de que estoy insistiendo es **repetir la misma corrección varias veces sin avanzar**.

Cuando ocurre, cambio de táctica en lugar de forzar:

• **Empezar de cero** con un enfoque distinto, llevando solo lo aprendido, por ejemplo en un resumen breve.
• **Cambiar de modelo** si el actual no da lo que busco (bloque 28).
• **Abrir otra conversación** para obtener una respuesta independiente y compararla con la primera.

Una conversación nueva no arrastra el historial de la anterior, lo que ayuda a comparar. Aun así, la memoria de Claude puede aportar contexto de chats previos, salvo en los chats incógnito.

También hay que decidir cuándo soltar: seguir parcheando por lo ya invertido es el sesgo de coste hundido (bloque 38). Y si una conversación se alarga mucho dentro de la misma tarea, el contexto empieza a degradarse (bloque 31).

Una pregunta bien planteada hace de contrapeso a un sesgo. Hay cuatro formas de preguntar que **cuestionan en lugar de confirmar**.

Si la IA me da la razón en todo, **algo falla**. Conviene pedir de forma explícita que no sea complaciente y que señale lo que ve mal.

Cuatro prompts para llevar estas preguntas a la práctica:

Estoy a punto de [decisión]. Antes de que avance, busca los puntos débiles: ¿en qué supuestos me apoyo sin haberlos comprobado?, ¿qué podría salir mal y cómo me daría cuenta pronto?, ¿qué alternativa estoy dejando sin mirar? Sé directo: no busques darme la razón.

Cuando analices [tema], termina siempre con tres apartados: lo que das por seguro, lo que es una suposición tuya y lo que yo debería comprobar por mi cuenta.

Este es mi problema: [problema]. Esta es mi solución actual: [solución]. Propón dos enfoques realmente distintos, no variaciones, compara los tres en esfuerzo, riesgo y coste, y dime cuál elegirías y por qué.

Antes de darme un plan para [objetivo], dime qué información necesitas de mí que todavía no te haya dado.

El trabajo con IA se ordena mejor con un recorrido corto. **Saltarse pasos suele dar resultados genéricos o incorrectos.**

Los fallos más comunes nacen de los sesgos: aceptar la primera respuesta, dar poco contexto, tratar a la IA como un oráculo, no pedirle que me corrija y terminar sin acciones concretas.

Un ejercicio breve: elegir un **problema real de hoy**, escribir objetivo, datos y límites antes de abrir la IA, mantener una conversación con preguntas que cuestionen, repasar las preguntas de control (bloque 39) y salir con **tres a cinco acciones con fecha**.

**Skill, hook y plugin** se mencionan constantemente y se confunden con la misma frecuencia. Me quedo con una frase para cada uno; el resto es detalle.

Un hook corre **fuera del modelo** y reacciona a eventos: no se pide, salta. Funciona en la pestaña **Código** de Claude Desktop; en **Cowork** hoy no se ejecuta [⚠ por confirmar: lo recogen incidencias abiertas, no la documentación].

Ante una necesidad, **tres preguntas** dan la respuesta en pocos segundos.

Y **tres errores** que se repiten:

Un plugin tiene sentido cuando hay **varias piezas relacionadas** (el material habla de tres o más skills) que voy a dar a clientes, alumnos o a un equipo [⚠ por confirmar: no es una regla oficial].

Una skill es una carpeta con un archivo **SKILL.md**: un encabezado (*frontmatter*) con el nombre y la descripción, y debajo las instrucciones.

No me obsesiono con que sea compleja: **muchas veces la simple basta, y es mejor**.

---
name: redactar-post
description: Escribe un post cuando le paso un tema o un brief.
---

Instrucciones de la skill...

Claude carga las skills **por niveles**, para no gastar contexto: al empezar carga **el nombre y la descripción de todas**; el **cuerpo del SKILL.md solo cuando se invoca**; y las **referencias solo cuando la skill las necesita**. Por eso conviene **nombrar y describir bien** cada skill, para que se active con lenguaje natural.

Si un SKILL.md se vuelve muy largo, lo que no se usa siempre es candidato a pasar a las referencias: queda un contexto más limpio.

Un **hook** se dispara cuando ocurre algo: cuando pasa X (editar un archivo, ejecutar un comando), hace Z. No lo invoca nadie y **no necesita prompt**.

Se declara en el archivo de ajustes con un **evento** y un filtro. Los eventos más conocidos son estos:

Un caso típico es **bloquear un comando destructivo** antes de que Claude lo ejecute. Otros son formatear un archivo tras editarlo o avisarme al terminar.

Los hooks de comando **corren fuera del modelo**, así que no gastan tokens del contexto, y esa es la diferencia clave con una skill. Hay una excepción: los hooks de **prompt** y de **agente** sí llaman a un modelo.

Funcionan en la pestaña **Código** de Claude Desktop. En **Cowork** hoy no se ejecutan [⚠ por confirmar: lo recogen incidencias abiertas, no la documentación].

Todo lo que creo en Claude Code (una skill, un hook, un ajuste) se guarda en alguna carpeta de mi ordenador, y **puedo elegir dónde**. Hacerlo bien evita que la configuración se líe al cambiar de proyecto o de cliente. Esto vale para Claude Code y para la pestaña Código de Claude Desktop.

Para ver las carpetas ocultas: en Mac, Cmd + Shift + .; en Windows, *Vista*, *Mostrar* y *Elementos ocultos*.

La forma más fácil de entender las dos ubicaciones principales es con una analogía. **Global** es el armario de casa: lo que guardo en ~/.claude/ está disponible en cualquier proyecto. **Proyecto** es el cajón de la mesa del cliente: lo que guardo en ./.claude/ solo existe cuando ese proyecto está abierto.

El archivo **local** es para lo que no debe salir de mi máquina. Claude Code configura git para ignorarlo cuando lo crea, pero conviene separar los secretos aunque no use git: así, si comparto la carpeta del proyecto, no viajan con ella.

El nivel **gestionado** solo aplica si una empresa gestiona Claude para sus empleados. Es el de mayor prioridad y lo impone TI, sin que yo pueda verlo ni cambiarlo.

Cuando la misma cosa existe en dos sitios, importa **cuál manda**. El orden de los ajustes, del más fuerte al más débil:

Claude **combina** los ajustes de los distintos niveles. Los **objetos se suman**: si en global tengo el modelo y en el proyecto añado el idioma, en ese proyecto valen los dos. Los **arrays se combinan y se deduplican**: si en global permito Read y Write y en el proyecto añado Bash, en ese proyecto valen los tres. Si un permiso está permitido en global y denegado en el proyecto, manda el proyecto.

Con las **skills** funciona distinto. Si dos skills tienen **el mismo nombre**, la **personal gana a la de proyecto**, y la corporativa gana a ambas. Con una deploy en ~/.claude/skills/ y otra en el proyecto, /deploy ejecuta la personal. Las skills de un plugin llevan prefijo (plugin:skill) y no chocan con las demás.

Por eso, para una versión adaptada a un cliente, le doy **un nombre distinto** (por ejemplo, cierre-cliente-x) en lugar de reutilizar el nombre de la global.

Mover una skill de global a proyecto, o al revés, es **mover su carpeta**. Hay dos formas:

• **Desde el Finder o el Explorador:** activo los elementos ocultos, abro la carpeta de origen y la de destino, y **arrastro la carpeta de la skill**.
• **Desde la terminal:** mv ~/.claude/skills/mi-skill ./.claude/skills/ para pasarla de global a proyecto, y al revés para devolverla.

Para mover una clave de settings.json de un nivel a otro, edito los dos archivos a mano: copio la clave al destino y la borro del origen [⚠ por confirmar: no he visto una herramienta oficial].

Claude Code detecta los cambios en las carpetas de skills sin reiniciar. Si **creo por primera vez** la carpeta skills/ en un nivel, ejecuto /reload-skills una vez para que la reconozca.

La regla mental que ahorra dudas: **si es mío y reutilizable, global; si es del proyecto y se puede compartir, proyecto; si es secreto, local.** Resuelve casi todos los casos. Tres casos límite:

El mínimo para una skill es **una carpeta con un archivo SKILL.md** dentro. No hay magia: es un directorio con un archivo Markdown que Claude lee cuando la invoco.

En Claude Code, al escribir / aparecen en el menú las skills disponibles. Escribo /redactar-post y Claude ejecuta las instrucciones del SKILL.md; el texto que añado detrás llega a la skill como argumentos.

Las skills no son exclusivas de una herramienta: sirven en **Code** y también en **Chat y Cowork**, pero se gestionan de forma distinta (bloque 53). La anatomía completa y la carga por niveles están en el bloque 46.

**skill-creator** es una skill oficial de Anthropic. Se instala una vez y **me entrevista** para generar el SKILL.md, en lugar de que lo escriba yo a mano.

El proceso con **Claude Code** tiene cuatro pasos.

Ayúdame a crear una skill llamada [nombre] que [qué hace y cuándo debe usarse]. Antes de escribir nada, pregúntame lo que necesites sobre el tono, la longitud, el formato de salida y los ejemplos que quiera incluir. Después genera el SKILL.md con una descripción que diga con claridad cuándo debe cargarse, y enséñamelo antes de guardarlo.

En **Chat o Cowork** el camino es otro. Preparo la carpeta con su SKILL.md y la comprimo en un **ZIP con la carpeta de la skill como raíz**. Voy a **Personalizar > Skills**, elijo **+ > Crear skill > Subir una skill** y la activo. Una skill subida es privada de mi cuenta. En Cowork de Claude para Mac también puedo **grabar la pantalla** mientras hago una tarea, y Claude propone la skill.

Una vez creada la carpeta con su SKILL.md, **Claude Code la detecta sin reiniciar**. Escribo / y la skill ya está en el menú; al escribir /redactar, el menú filtra y la muestra con su descripción.

El ciclo es inmediato: ejecuto, veo el resultado y ajusto. Solo si creo por primera vez una carpeta de skills ejecuto /reload-skills.

También puedo **iterar sin abrir archivos**: le pido a Claude el cambio en lenguaje natural, y la siguiente invocación ya lo lleva.

Modifica la skill [nombre] para que [cambio]. Enséñame primero qué líneas vas a cambiar y no toques el resto de las instrucciones. Después dime cómo probar el cambio.

Si el SKILL.md crece demasiado, paso lo que es de referencia a la subcarpeta references/ (bloque 46).

Hay seis skills que suelen ahorrar más tiempo si trabajo con contenido y con clientes.

No hace falta crearlas todas. Empiezo por la que **más tiempo me ahorra ahora mismo**.

**Reto:** de las seis ideas, elegir la que más tiempo ahorre ahora y crearla esta semana. Con skill-creator es rápido.

Dónde buscar skills ya hechas y cómo instalarlas lo veo en próximas explicaciones.