> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Deje que Claude coordine el trabajo en curso con Projects
> Proporcione a Claude un conjunto de trabajo relacionado en una conversación y deje que coordine sesiones en la nube paralelas que compartan repositorios, instrucciones y memoria.
Projects está en versión beta pública en los planes Pro y Max y se está implementando gradualmente, comenzando con cuentas que han utilizado [sesiones en la nube](/docs/es/claude-code-on-the-web) y no tienen proyectos existentes en el chat de claude.ai o en Cowork. Aún no está disponible en los planes Team o Enterprise. Si **Projects** no aparece en la barra lateral en [claude.ai/code](https://claude.ai/code) o en la pestaña Code de la [aplicación de escritorio](/docs/es/desktop), el despliegue aún no ha llegado a su cuenta, y puede [unirse a la lista de espera](https://claude.com/form/projects). [Ejecutar agentes en paralelo](/docs/es/agents) enumera lo que puede usar mientras tanto.
Un proyecto es una conversación en curso donde Claude coordina un flujo de trabajo relacionado para usted. Usted le dice qué necesita hacerse y comienza un hilo para cada tarea. Cada hilo es una [sesión en la nube](/docs/es/claude-code-on-the-web): Claude Code ejecutándose en la nube en lugar de en su máquina. Los hilos se ejecutan en paralelo y continúan después de cerrar la computadora portátil.
Sin un proyecto, ejecutar varias sesiones significa hacer la coordinación usted mismo: decide en qué trabaja cada una, repite el mismo contexto al inicio de cada una, y verifica cuál terminó o necesita una respuesta. Con un proyecto, en su lugar:
* **Envíe trabajo a un solo lugar**: pegue un informe de error, un seguimiento de pila o una lista de tareas en la conversación cada vez que surja uno. Claude comienza un hilo para cada pieza de trabajo o lo pasa al hilo que ya está trabajando en esa área, y responde preguntas rápidas en su lugar.
* **Establezca el contexto una sola vez**: cada nuevo hilo comienza con los repositorios, instrucciones y memoria del proyecto, por lo que una regla que establezca una sola vez, como qué rama dirigirse, llega a todos ellos.
* **Aléjese y regrese al trabajo terminado**: cuando regrese una hora después o a la mañana siguiente, el panel **Overview** muestra qué hilos terminaron, qué solicitudes de extracción están listas para revisión y qué hilo está esperando su respuesta.
Si ya sabe el trabajo que desea que un proyecto ejecute, vaya directamente a [Crear un proyecto](#create-a-project).
Cuándo usar un proyecto
Vale la pena crear un proyecto cuando el trabajo tiene un objetivo que perdura más allá de una sesión y sigue produciendo tareas. Estos tipos de trabajo se adaptan bien a un proyecto:
* **Un objetivo en muchos repositorios**: "Llevar cada servicio a la nueva configuración de lint." Claude puede ejecutar un hilo por repositorio, cada uno con su propia solicitud de extracción, y el panel [**Overview**](#see-what-needs-you-in-overview) muestra cuáles están listas para revisión.
* **Un área que sigues alimentando**: los errores, seguimientos de pila y solicitudes de revisión para un servicio, pegados en la conversación a medida que te llegan. Una trampa que le dices a Claude que recuerde después de una corrección está en [memoria del proyecto](#give-a-project-standing-context) para la siguiente.
* **Una compilación o migración más grande que una sesión**: "Construir lo que describe `docs/spec.md`" o "Mover la aplicación del ORM obsoleto." El trabajo se divide en hilos que cada uno toma una parte, las decisiones que le pides a Claude que recuerde al principio llegan a los hilos posteriores, y la especificación cambia y los errores que encuentras durante la compilación van a la misma conversación.
* **Trabajo que no es código**: una carpeta de contratos o una exportación de tickets de soporte a la que sigues regresando con nuevas preguntas, como "encontrar los diez errores de integración más comunes en estos tickets." Carga los documentos en lugar de agregar un repositorio, y los hilos entregan cada informe como un archivo en la pestaña [**Library**](#see-what-needs-you-in-overview) del proyecto.
En cualquiera de ellos puedes enviar un lote de tareas, decirle a Claude que comience sin pedirte que confirmes, alejarte, y encontrar los hilos que te necesitan bajo [**Waiting on you**](#see-what-needs-you-in-overview) cuando regreses, o pedirle a Claude que ponga parte del trabajo en un horario como una [rutina](/docs/es/routines). Si esta es tu situación, [crea un proyecto](#create-a-project).
Cuándo algo más se adapta mejor
Los hilos funcionan en repositorios de GitHub y en los archivos, carpetas y carpetas de Google Drive que cargues en el proyecto, no en archivos o herramientas que existan solo en tu máquina. Algo más se adapta mejor en estos casos:
* **Una tarea que cabe en una sesión**: "Arreglar la prueba de inicio de sesión inestable." Comienza una [sesión en la nube](/docs/es/claude-code-on-the-web) tú mismo.
* **Trabajo que necesita herramientas o servicios que solo tu máquina puede alcanzar**: una base de datos local, un emulador de dispositivo, una API detrás de tu VPN. Usa una sesión local, o [vista de agente](/docs/es/agent-view) para ejecutar varias a la vez. Si el trabajo solo necesita archivos locales, cárgalos en el proyecto en su lugar.
* **Una tarea que se repite en un horario sin conversación alrededor**: "Publicar un informe de dependencias cada lunes." Crea una [rutina](/docs/es/routines) por su cuenta.
* **Varias personas dándole trabajo a Claude y dirigiéndolo juntos en un canal de Slack**: ver [Claude Tag](https://claude.com/docs/claude-tag/overview).
Un proyecto utiliza los mismos límites de plan que tus otras sesiones de Claude Code y los utiliza más rápido. [Uso y costo](#usage-and-cost) cubre qué utiliza tu plan y cómo mantenerlo bajo.
Cómo se organiza un proyecto
Un proyecto es una conversación coordinadora con Claude más los hilos que comienza para hacer el trabajo. Estas son sus partes:
* **La conversación del proyecto**: una sesión de larga duración donde Claude actúa como coordinador. Toma lo que envías, decide qué se convierte en un hilo, y mantiene un registro de cada hilo que comenzó. Ve lo que los hilos reportan, no cada paso que toman.
* **Hilos**: los trabajadores. Cada uno es una [sesión en la nube](/docs/es/claude-code-on-the-web) separada con su propia ventana de contexto que hace una pieza de trabajo en su propia rama, abre una solicitud de extracción cuando el trabajo lo requiere, e informa a la conversación cuando termina.
* **Lo que cada hilo comienza con**:
* Los repositorios y archivos del proyecto, más sus [instrucciones y memoria](#give-a-project-standing-context)
* El `CLAUDE.md`, skills, y plugins en [cada uno de los repositorios del proyecto](#what-threads-pick-up-from-your-repositories), y en un proyecto con un repositorio, las reglas de permisos y hooks de ese repositorio también
* Los [conectores](#get-skills-plugins-connectors-and-tools-into-threads) en tu cuenta de claude.ai
* Un [entorno en la nube](#choose-an-environment-for-threads) que establece su acceso a la red, variables de entorno, credenciales de API, y herramientas instaladas
* **El panel Overview**: donde [ves todos los hilos a la vez](#see-what-needs-you-in-overview) y cuáles de ellos te necesitan. Sus otras pestañas son **Library** para los archivos que agregaste y los archivos que produjeron los hilos, **Pull requests** para los que abrieron los hilos, y **Routines** para el trabajo programado en el proyecto.
Los hilos no recogen nada de la configuración de Claude Code en tu propia máquina. [Obtener skills, plugins, conectores y herramientas en hilos](#get-skills-plugins-connectors-and-tools-into-threads) cubre cómo darles lo que de otro modo les faltaría.
Así es como esas partes se conectan, desde ti a través de la conversación hasta los hilos haciendo el trabajo, con **Overview** rastreando su estado:
Crear un proyecto
Creas y usas proyectos en [claude.ai/code](https://claude.ai/code) o en la pestaña Code de la aplicación de escritorio. Hay dos formas de comenzar uno:
* **Desde cero**, cuando sabes el flujo de trabajo que deseas que ejecute Claude: abre el diálogo **New project** y nómbralo. [Comienza un nuevo proyecto desde cero](#start-a-new-project-from-scratch) te guía a través del diálogo.
* **Desde una sesión en la nube que ya está haciendo el trabajo**: elige **Continue as a project** del menú de esa sesión, y Claude propone la configuración del proyecto a partir de lo que la sesión estaba haciendo. Ver [Comenzar desde una sesión en la nube existente](#start-from-an-existing-cloud-session).
De cualquier forma, [verifica los requisitos previos](#check-the-prerequisites) primero.
Verifica los requisitos previos
Antes de crear un proyecto, verifica tu plan, tu configuración de GitHub, y a qué necesita llegar el trabajo:
* **Plan**: estás en Pro o Max y **Projects** aparece en tu barra lateral.
* **GitHub, si el proyecto trabajará en código**: tu código está en github.com en lugar de GitHub Enterprise Server, GitLab o Bitbucket, tu cuenta de GitHub conectada tiene acceso de inserción a él, y la Claude GitHub App está instalada en él. Si conectaste GitHub con [`/web-setup`](/docs/es/web-quickstart#connect-from-your-terminal), ese token permite que tus otras sesiones en la nube accedan a un repositorio pero no es suficiente para hilos de proyecto, que necesitan la Claude GitHub App. [Configurar acceso a GitHub](#set-up-github-access) tiene los pasos.
* **Red, credenciales y herramientas**: estos provienen del [entorno en la nube](#choose-an-environment-for-threads) del proyecto. El entorno predeterminado ya alcanza [registros de paquetes comunes](/docs/es/cloud-environments#default-allowed-domains), así que verifica esto solo si el trabajo necesita otros dominios, un secreto, o una herramienta que no esté preinstalada. Si el trabajo necesita un servidor MCP, verifica que aparezca como conectado en tus [conectores de claude.ai](https://claude.ai/customize/connectors).
Comienza un nuevo proyecto desde cero
Comenzar un proyecto desde cero significa abrir el diálogo **New project**, nombrar el flujo de trabajo, y opcionalmente darle un objetivo y los repositorios y archivos en los que trabaja. Solo el nombre es requerido, así que puedes crear el proyecto primero y llenar el resto a medida que el trabajo toma forma.
En [claude.ai/code](https://claude.ai/code) o en la pestaña Code de la aplicación de escritorio, selecciona **Projects** en la barra lateral izquierda, luego selecciona **New project**. En un navegador también puedes ir directamente a [claude.ai/code/projects/browse](https://claude.ai/code/projects/browse).
Limita el proyecto a un flujo de trabajo que seguirás agregando, como todo lo que se necesita para mantener una API bajo su objetivo de latencia. [Cuándo usar un proyecto](#when-to-use-a-project) tiene más ejemplos. Luego completa los campos del diálogo:
* **Name**: cómo aparece el proyecto en la lista **Projects**.
* **Goal** (opcional): una línea de lo que estás tratando de lograr, como "Mantener la latencia p95 de la API por debajo de 200 ms". Claude en la conversación trabaja hacia él. Sin un objetivo, Claude trabaja a partir de las tareas que envías, y puedes agregar un objetivo más tarde en **Project settings > General**.
* **Context** (opcional): los repositorios de GitHub en los que trabaja este proyecto, más cualquier archivo, carpeta o carpeta de Google Drive que los hilos deban leer. Haz clic en **Add** para cada uno. Agrega los repositorios que la mayoría de las tareas necesitan en lugar de cada uno que el trabajo podría tocar; [Decide qué repositorios agregar](#decide-which-repositories-to-add) cubre la elección, y puedes agregar más tarde en **Project settings > Environment**.
Las reglas permanentes sobre cómo deben trabajar los hilos van en [instrucciones del proyecto](#give-a-project-standing-context), que estableces después de que el proyecto exista.
Haz clic en **Create project**. La conversación del proyecto se abre con un cuadro de mensaje en la parte inferior, donde describes trabajo para Claude.
En tu primer proyecto, Claude toma un turno por su cuenta tan pronto como se crea el proyecto, a menos que envíes un mensaje primero. Ese turno utiliza tu plan. En él, Claude puede:
* Comenzar un hilo que explora el repositorio sin cambiar nada y propone los próximos pasos, si el proyecto tiene un repositorio que puede leer.
* Publicar **Setup recommendations** extraídas de tus sesiones en la nube recientes: repositorios para agregar, rutinas para crear, e hilos que podría comenzar. Cada repositorio y rutina recomendados comienzan activados. Desactiva los que no deseas, luego haz clic en **Update setup** para agregar el resto, o ignora las recomendaciones y describe el trabajo tú mismo.
El proyecto ahora está listado bajo **Projects** en la barra lateral, y su conversación está abierta. [Tu primer lote](#your-first-batch) cubre qué configurar antes de enviarle trabajo.
Comienza desde una sesión en la nube existente
Si ya tienes una sesión en la nube haciendo trabajo que pertenece a un proyecto, abre el menú de la sesión en la barra lateral y elige **Continue as a project** o **Move to project**:
* **Continue as a project** crea un nuevo proyecto nombrado después de la sesión y lo abre. Claude lee la sesión y publica **Setup recommendations** en la conversación para que confirmes. La sesión original permanece en tu lista de sesiones, y si estaba en medio de un turno sigue ejecutándose, así que detenla tú mismo si no deseas que ambas trabajen a la vez. Si usas el banner **Set up project** que puede aparecer arriba del cuadro de mensaje de la sesión en la nube, el resultado es el mismo, excepto que el turno en ejecución de la sesión se detiene una vez que se abre el proyecto.
* **Move to project** trae el trabajo de la sesión a un proyecto existente. Publica un mensaje en la conversación de ese proyecto pidiéndole a Claude que lea la sesión y continúe desde donde se quedó, y el nuevo trabajo continúa en los propios hilos del proyecto. La sesión original permanece en tu lista de sesiones, sin cambios.
Configurar acceso a GitHub
La mayoría de la configuración de GitHub sucede una vez, no por proyecto. Conectas tu cuenta de GitHub a Claude una vez, y la Claude GitHub App se instala una vez por repositorio, o una vez para toda una organización de GitHub si le das todos los repositorios. Vuelves a estos pasos cuando agregas un repositorio que la Claude GitHub App aún no cubre o uno en una organización de GitHub que aplica SSO.
Si no has usado claude.ai/code antes, tu primera visita te guía a través de conectar GitHub; ver [Conectar GitHub](/docs/es/web-quickstart#connect-github). De lo contrario, usa una de las [opciones de autenticación de GitHub](/docs/es/claude-code-on-the-web#github-authentication-options).
Instala la [Claude GitHub App](https://github.com/apps/claude) y otórgale los repositorios que el proyecto usará. En un repositorio propiedad de una organización de GitHub, solo un propietario de la organización puede completar la instalación; si no eres uno, GitHub envía al propietario una solicitud de instalación y el proyecto no puede usar el repositorio hasta que lo apruebe.
Si una organización de GitHub aplica SAML SSO, reconecta GitHub y autoriza la aplicación Claude para esa organización. Hasta que lo hagas, los repositorios privados de esa organización no aparecen en el diálogo **New project** o **Project settings > Environment**.
Cuando uno de estos pasos está incompleto, el diálogo **New project** y la página del proyecto nombran el paso faltante y enlazan a donde lo terminas. Termina el paso allí, luego haz clic en **Check again** si el diálogo lo ofrece. Si un repositorio aún falta de la lista después, abre la instalación de la Claude GitHub App en GitHub, en [github.com/settings/installations](https://github.com/settings/installations) para una cuenta personal, y confirma que el repositorio está listado bajo **Repository access**. Para los mensajes de error que un hilo o el proyecto reportan cuando el acceso aún es incorrecto, ver [Errores de acceso al repositorio](#repository-access-errors).
Trabaja en un proyecto
Dale trabajo a Claude a través de la conversación del proyecto: tareas una a la vez o varias a la vez, más actualizaciones y pensamientos sueltos a medida que surjan. Claude enruta cada mensaje, y los hilos hacen el trabajo e informan.
Tu primer lote
Antes de enviar a un nuevo proyecto un lote de trabajo, configúralo para que los primeros hilos regresen como deseas:
1. [Escribe instrucciones del proyecto](#write-project-instructions): el resumen que cada hilo comienza, como qué rama dirigirse, cómo un hilo verifica su trabajo, y qué necesita tu aprobación.
2. Envía una pequeña pieza del trabajo real, o comienza uno de los hilos que Claude sugirió, y abre el hilo cuando termine para ver cómo informa y qué hizo en su rama. Si asumió algo incorrecto o no pudo alcanzar lo que necesitaba, [Los hilos adivinaron o se estancaron en lugar de preguntar](#threads-guessed-or-stalled-instead-of-asking) cubre dónde arreglarlo.
3. Verifica **Thread model** y **Thread effort** en **Project settings > General**. Un nuevo proyecto ejecuta cada hilo en Opus con alto esfuerzo, que utiliza tu plan más rápido; [Elige modelos y deja que Claude maneje el contexto](#choose-models-and-let-claude-manage-context) cubre las alternativas.
4. Pídele a Claude que [proponga hilos antes de comenzarlos y que ejecute algunos a la vez](#tune-how-claude-runs-a-project), y suelta esos límites una vez que algunos hilos regresen como deseas.
Envía trabajo y lee resultados
Claude decide dónde va cada mensaje que envías en la conversación:
* Una pregunta rápida generalmente obtiene una respuesta en la conversación.
* El nuevo trabajo va a un hilo nuevo o a un hilo que ya está trabajando en esa área, y Claude te dice cuál. Cada hilo nuevo aparece bajo tu mensaje como una tarjeta: una caja con el título y estado del hilo, que haces clic para abrir el hilo.
* Varias tareas no relacionadas en un mensaje se convierten en hilos separados.
Si Claude enruta algo diferente a lo que querías, dilo. [Ajusta cómo Claude ejecuta un proyecto](#tune-how-claude-runs-a-project) enumera cosas que puedes decirle, como reutilizar un hilo existente para seguimientos o responder en el lugar en lugar de comenzar un hilo.
Los resultados completos de un hilo permanecen en el hilo, y abres su tarjeta en la conversación para leerlos. Los archivos que produjo un hilo también están en la pestaña **Library** en **Overview**.
A veces Claude propone hilos en lugar de comenzarlos, en una lista **Suggested threads**. Haz clic en la flecha en una sugerencia para comenzar ese hilo. Cuando se enumeran varios, un botón debajo de la lista comienza todos ellos.
Revisa la solicitud de extracción de un hilo
Cuando un hilo cambia código, esto es lo que hace a menos que le digas lo contrario:
* **Branch**: trabaja en una rama nueva, comenzada desde la rama predeterminada del repositorio.
* **Pull request**: abre una cuando lo pides, y puede abrir una por su cuenta para una corrección de error u otro cambio concreto.
* **Después de que se abre**: observa la solicitud de extracción con [auto-fix](/docs/es/claude-code-on-the-web#auto-fix-pull-requests) activado, independientemente de si auto-fix está activado para tus otras sesiones en la nube. Inserta correcciones cuando CI falla, aborda comentarios de revisión, y responde en el hilo cuando las verificaciones pasan y la solicitud de extracción está lista para ti.
La tarjeta del hilo en la conversación muestra un botón para el próximo paso de la solicitud de extracción cuando hay uno, como **Resolve conflicts**, **Fix CI**, **Address comments**, o **Merge it**. Hacerlo clic envía esa instrucción al hilo como un mensaje de ti, así que puedes indicar al hilo tú mismo en lugar de esperar a que reaccione a la solicitud de extracción. **Review PR** abre la solicitud de extracción en GitHub.
Para cambiar cuándo los hilos abren solicitudes de extracción, por ejemplo solo cuando lo pides, o qué rama comienzan, dilo en la tarea o en [instrucciones del proyecto](#write-project-instructions).
Ve qué te necesita en Overview
El panel **Overview** junto a la conversación rastrea los hilos del proyecto. Ya está abierto la primera vez que abres un nuevo proyecto. El botón **Overview** en el encabezado del proyecto lo cierra y reabre, y muestra un punto cuando un hilo te está esperando.
En la aplicación de escritorio, también obtienes una notificación de escritorio cuando Claude publica en la conversación, un hilo golpea un error, o un hilo necesita tu entrada, así que no tienes que mantener el proyecto abierto para enterarte. Para también obtener uno cada vez que un hilo termina un turno, o para desactivarlos para un proyecto, elige **Notifications** en el menú de la barra lateral del proyecto. Estas notificaciones son solo de escritorio: en un navegador, verifica el punto en el botón **Overview**.
La pestaña **Threads** del panel agrupa hilos por estado:
| Grupo | Qué hay en él |
| :------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Ready for review** | Hilos cuya solicitud de extracción está abierta y esperando revisión |
| **Waiting on you** | Hilos que necesitan tu respuesta o aprobación, o que fallaron |
| **Working** | Hilos aún en ejecución |
| **Landing** | Hilos cuya solicitud de extracción está aprobada o en cola para fusionar |
| **Idle** | Hilos que terminaron y no están esperando nada |
| **Resolved** | Hilos marcados como hecho: por ti desde el menú del hilo, por Claude una vez que hayas tomado el último paso, como fusionar su solicitud de extracción, o automáticamente después de una semana sin actividad. Puedes reabrir uno desde el mismo menú |
Las otras pestañas del panel son **Library** para los archivos y carpetas que agregaste y los archivos que produjeron los hilos, **Pull requests** una vez que los hilos hayan abierto alguno, y **Routines** para las [rutinas](/docs/es/routines) que Claude configuró desde este proyecto.
Abre un hilo cuando necesites control
Haz clic en la tarjeta de un hilo en la conversación o su fila en **Overview** para abrir su transcripción en el panel Overview. Desde allí puedes:
* Leer qué hizo Claude, paso a paso.
* Dirige la tarea escribiendo en el cuadro de mensaje del hilo. Un mensaje allí va directamente a ese hilo, mientras que un seguimiento en la conversación del proyecto lo alcanza solo cuando Claude coincide el seguimiento con ese hilo.
* Responde a un aviso de permiso que el hilo está esperando.
* Interrumpe el hilo con **Stop**, que reemplaza el botón enviar mientras el hilo está trabajando, o presionando Esc.
Elige modelos y deja que Claude maneje el contexto
Establece modelos y esfuerzo en **Project settings > General**. Un nuevo proyecto ejecuta Opus en todas partes, con alto [esfuerzo](/docs/es/model-config#adjust-effort-level) para hilos y bajo esfuerzo para la conversación:
* **Thread model** y **Thread effort** se aplican a los hilos. Para usar un modelo diferente para una tarea, pídelo en la tarea; para un hilo ya en ejecución, usa el selector de modelo de ese hilo.
* **Coordinator model** y **Coordinator effort** se aplican a Claude en la conversación del proyecto.
No administras ventanas de contexto en un proyecto. Los hilos se compactan automáticamente, y la conversación funciona a partir de mensajes recientes, hilos recientes, y memoria del proyecto en lugar de su historial completo, así que sigue funcionando mientras el proyecto se ejecute. Pon cualquier cosa que nunca deba descartarse en [memoria del proyecto](#give-a-project-standing-context). Si un hilo crece más allá de su contexto, muestra [Claude ran out of context on this turn](#context-limit).
Ajusta cómo Claude ejecuta un proyecto
Dile a Claude en la conversación cuántos hilos ejecutar a la vez, cuándo publicar actualizaciones, y cuándo abrir solicitudes de extracción. Si Claude está coordinando de una manera que no deseas, dilo. Por ejemplo, puedes decir:
* "Propón hilos y espera mi aprobación antes de comenzarlos" o "Comienza estos ahora sin pedirme que confirme"
* "Ejecuta como máximo dos hilos a la vez" o "Reutiliza un hilo existente para seguimientos en la misma área"
* "Publica actualizaciones más cortas" o "Solo publica cuando algo termina o está bloqueado"
* "Dame una actualización de estado en cada hilo"
* "Haz esta tarea con un modelo más pequeño"
* "No abras una solicitud de extracción hasta que haya visto el plan"
* "Dime qué está mal en estos repositorios y no arregles nada todavía", cuando deseas revisar los hallazgos antes de que cualquiera se convierta en un hilo
* "Responde eso aquí en lugar de comenzar un hilo", cuando Claude comienza un hilo para algo que quisiste como una pregunta rápida
Claude guarda preferencias como estas en [memoria del proyecto](#give-a-project-standing-context) por su cuenta y las sigue en hilos posteriores. Son instrucciones que Claude mantiene, no configuraciones aplicadas, así que un límite de hilos que das de esta manera no es un límite duro. Agrega uno a las instrucciones del proyecto cuando deseas que esté redactado exactamente y aplicado a cada hilo desde el inicio.
Desbloquea un hilo esperando aprobación
Los hilos se ejecutan en [modo automático](/docs/es/permission-modes#eliminate-prompts-with-auto-mode) cuando el modelo del hilo lo soporta, así que la mayoría de las llamadas de herramientas se ejecutan sin pedirte. Cuando un hilo necesita tu aprobación, el aviso está dentro de ese hilo y el hilo espera hasta que respondas allí. Decirle a Claude en la conversación del proyecto que adelante no lo alcanza.
Cada aprobación cubre ese aviso, o el resto de ese hilo si eliges la opción más amplia. Para permitir que cada hilo ejecute ciertos comandos sin preguntar, o para bloquear algunos, agrega [reglas de permiso](/docs/es/permissions) al `.claude/settings.json` del repositorio. Los hilos las aplican solo en un proyecto con un repositorio; ver [Lo que los hilos recogen de tus repositorios](#what-threads-pick-up-from-your-repositories).
Dale a un proyecto contexto permanente
La memoria del proyecto, las instrucciones del proyecto, y los repositorios, archivos y entorno del proyecto llevan contexto a través de hilos. Estableces cada uno una vez y se aplica a cada hilo nuevo.
| Contexto | Qué lleva | Cómo lo estableces |
| :------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Memoria del proyecto | Notas que Claude mantiene sobre el proyecto, como requisitos, decisiones y trampas, almacenadas como archivos. Cada hilo lee el archivo de índice `MEMORY.md` cuando comienza y abre los otros archivos cuando los necesita | Pídele a Claude en la conversación del proyecto o cualquier hilo que recuerde un requisito, una decisión, o una trampa, o que olvide uno. Lee, edita, y elimina los archivos en **Project settings > Memory** |
| Instrucciones del proyecto | Texto enviado a cada hilo nuevo y a Claude en la conversación del proyecto, hasta 16,000 caracteres. [Escribe instrucciones del proyecto](#write-project-instructions) cubre qué poner en él | **Project settings > Memory > Project instructions**, o pídele a Claude que cambie las instrucciones |
| Repositorios, archivos y entorno | Los repositorios que cada hilo clona, las carpetas y archivos que cada hilo puede leer bajo `/mnt/project-files`, y el entorno en la nube en el que se ejecutan los hilos | Repositorios y entorno en **Project settings > Environment**, o pídele a Claude en la conversación que agregue un repositorio al proyecto. Archivos y carpetas desde **Add** en la pestaña **Library** en **Overview** |
**Project settings > Memory** enumera estos archivos bajo **Auto memory**, porque Claude los escribe a sí mismo mientras trabaja en el proyecto. Son separados de la [memoria automática](/docs/es/memory) que Claude Code mantiene en tu máquina, aunque ambas usen un índice `MEMORY.md`. La memoria del proyecto también es separada de los archivos `CLAUDE.md` en los repositorios del proyecto. Cada hilo aún lee esos archivos `CLAUDE.md` de su clon cuando comienza, así que pon instrucciones sobre un repositorio en su `CLAUDE.md` y notas sobre el proyecto en la memoria del proyecto.
Escribe instrucciones del proyecto
Las instrucciones del proyecto son el resumen que cada hilo nuevo comienza. Haz clic en el icono de engranaje en el encabezado del proyecto para abrir **Project settings**, luego ve a **Memory > Project instructions**. Un resumen útil cubre:
* Para qué es el proyecto
* Dónde sucede el trabajo: qué repositorios, qué rama comenzar, cómo nombrar solicitudes de extracción
* Cómo un hilo verifica su propio trabajo antes de llamarlo hecho
* Qué hacer cuando algo que necesita falta
* Qué necesita tu aprobación primero
Por ejemplo:
```text theme={null}
Este proyecto mantiene la latencia p95 de la API de pagos por debajo de 200 ms: perfilado, correcciones de consultas y almacenamiento en caché, y las actualizaciones de dependencias que vienen con ellas, en el repositorio de la API de pagos.
- Rama desde main y abre un borrador de solicitud de extracción por hilo.
- Antes de llamar al trabajo hecho, ejecuta `make test` y `make lint` y pega las líneas de resumen en tu mensaje final.
- Si no puedes alcanzar algo que necesitas, como un repositorio, un secreto, una API, o un conector, di exactamente qué falta en tu primer mensaje y detente. No sustituyas, simules, o adivines.
- No fusiones, hagas push forzado, o cambies la configuración de CI sin preguntarme en el hilo.
```
Las reglas sobre un repositorio, como sus comandos de compilación, pertenecen al `CLAUDE.md` de ese repositorio, que cada hilo lee cuando el repositorio es parte del proyecto. Una vez que el trabajo está en marcha, cuando corriges un hilo, también dile a Claude que recuerde la corrección: va a [memoria del proyecto](#give-a-project-standing-context) y los hilos posteriores comienzan con ella.
Decide qué repositorios agregar
Los repositorios que agregas a un proyecto vienen con todo en ellos, su código, `CLAUDE.md`, y skills, en cada hilo. Los repositorios que no agregas aún están al alcance: un hilo puede agregar uno a sí mismo cuando su tarea lo necesita. La mayoría de los proyectos usan ambos:
* **Agrégalo al proyecto**, en el diálogo **New project**, en **Project settings > Environment**, o pidiéndole a Claude en la conversación que lo agregue al proyecto. Cada hilo a partir de entonces lo clona y comienza con su `CLAUDE.md` y skills cargados, independientemente de si la tarea lo toca. Pasar de un repositorio a varios también cambia lo que los hilos toman del `.claude/settings.json` de cada repositorio; ver [Lo que los hilos recogen de tus repositorios](#what-threads-pick-up-from-your-repositories).
* **Déjalo fuera y deja que los hilos lo agreguen cuando sea necesario.** Un hilo cuya tarea necesita un repositorio que el proyecto no tiene puede agregarlo a sí mismo, y una nota en el hilo dice que fue agregado solo a este hilo. El clon sucede a mitad de la tarea, así que el `CLAUDE.md` y skills de ese repositorio no estaban allí cuando el hilo comenzó. El siguiente hilo comienza sin él de nuevo. Un repositorio que un hilo agrega necesita los mismos [requisitos previos](#check-the-prerequisites) que un repositorio del proyecto: la Claude GitHub App instalada en él y acceso de inserción desde tu cuenta de GitHub.
Un proyecto no necesita un repositorio en absoluto. Sus hilos aún pueden investigar, escribir documentos, y escribir y ejecutar código en su propia sandbox, y entregan archivos a la pestaña **Library**. Un hilo allí también puede agregar un repositorio a sí mismo cuando una tarea lo requiere.
Una vez que el proyecto tiene repositorios, Claude solo puede agregar repositorios de un propietario de GitHub que el proyecto ya usa, ya sea que agregue uno al proyecto o un hilo agregue uno a sí mismo. Para traer un repositorio de un propietario diferente, agrégalo al proyecto tú mismo en **Project settings > Environment**.
Para un proyecto que abarca muchos repositorios, como una característica con código de servidor, web, móvil y escritorio, agrega el uno o dos repositorios que casi cada tarea toca y nombra los otros en [instrucciones del proyecto](#write-project-instructions) para que Claude sepa dónde vive el resto del código. Los hilos entonces comienzan pequeños y tiran en los otros repositorios solo para las tareas que los necesitan.
Lo que los hilos recogen de tus repositorios
Cada hilo clona cada repositorio en el proyecto y carga `CLAUDE.md`, skills, y plugins de todos ellos. Las reglas de permiso, hooks, y `env` vienen solo del `.claude/settings.json` en el directorio en el que comienza el hilo: dentro del repositorio cuando el proyecto tiene uno, y arriba de los clones cuando tiene varios, donde no se lee el archivo de ningún repositorio para ellos.
| En cada repositorio | Un repositorio | Varios repositorios |
| :--------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CLAUDE.md` | Se carga cuando comienza el hilo | Se carga desde cada repositorio cuando comienza el hilo |
| Skills, agentes, y comandos bajo `.claude/` | Se cargan | Se cargan desde cada repositorio |
| Plugins habilitados en `.claude/settings.json` | Se cargan | Se cargan desde cada repositorio. Si dos repositorios no están de acuerdo sobre un plugin, establécelo en **Project settings > Plugins**, que tiene precedencia |
| Reglas de permiso, hooks, y `env` definidos en `.claude/settings.json` | Se aplican al hilo, excepto las claves `env` que [ninguna sesión en la nube honra](/docs/es/cloud-environments#what-carries-over-from-your-setup) | No se aplican |
En un proyecto con varios repositorios, cada clon se adjunta al hilo como un [directorio adicional](/docs/es/memory#load-from-additional-directories) con carga de `CLAUDE.md` activada, que es por qué el `CLAUDE.md` y skills de cada repositorio se cargan al inicio aunque el hilo comience arriba de ellos. En cualquier caso, los hooks que proporciona un plugin habilitado aún se ejecutan, ya que los plugins se cargan desde cada repositorio. En un proyecto con varios repositorios, pon reglas permanentes en instrucciones del proyecto y dale a los hilos variables de entorno a través del [entorno en la nube](#choose-an-environment-for-threads).
Elige un entorno para los hilos
Cada hilo nuevo comienza en el [entorno en la nube](/docs/es/cloud-environments) del proyecto. El entorno establece qué dominios pueden alcanzar los hilos, qué variables de entorno tienen, qué credenciales de API se agregan a sus solicitudes, y qué instala el script de configuración antes de que Claude comience. Los hilos usan un entorno predeterminado alojado por Anthropic hasta que elijas uno en **Project settings > Environment**.
Si los hilos necesitan alcanzar una API interna o un registro de paquetes privado, o necesitan un token que tu máquina normalmente mantiene, cambia el entorno en lugar del proyecto: ver [Acceso a la red](/docs/es/cloud-environments#network-access), [Agregar credenciales de API](/docs/es/cloud-environments#add-api-credentials), y [Scripts de configuración](/docs/es/cloud-environments#setup-scripts).
Los hilos son sesiones en la nube, así que no tienen los skills, servidores MCP, plugins, y herramientas instalados solo en tu máquina. Para hacer que cada uno de estos esté disponible para los hilos:
* Skills, subagentes, y comandos: confirma que están en un repositorio que agregaste al proyecto, por ejemplo un skill en `.claude/skills//SKILL.md`. Cada hilo clona cada repositorio en el proyecto y carga `.claude/skills/`, `.claude/agents/`, y `.claude/commands/` de cada uno de ellos, así que un skill confirmado en un repositorio está disponible en cada hilo nuevo. Los hilos también cargan los skills que habilitas para tu cuenta de claude.ai.
* Plugins: agrégalos en **Project settings > Plugins**; se cargan en cada hilo nuevo. Los plugins que un repositorio declara en su `.claude/settings.json` también se cargan; ver [Lo que se lleva de tu configuración](/docs/es/cloud-environments#what-carries-over-from-your-setup).
* Servidores MCP: los hilos obtienen sus herramientas MCP de los conectores en tu cuenta de claude.ai, que son servidores MCP que conectas una vez en [claude.ai/customize/connectors](https://claude.ai/customize/connectors) o a través del enlace **Manage connectors** en **Project settings > Environment**. Cada hilo puede usar todos ellos sin configuración por proyecto. La conversación del proyecto en sí no tiene conectores, así que envía trabajo que necesita uno como una tarea para un hilo. En un proyecto con un repositorio, los hilos también cargan servidores MCP del [`.mcp.json`](/docs/es/cloud-environments#what-carries-over-from-your-setup) de ese repositorio. [Cómo los conectores llegan a Claude Code](/docs/es/mcp#how-connectors-reach-claude-code) enumera las reglas para sesiones en la nube y la configuración que desactiva los conectores.
* Herramientas de línea de comandos y paquetes: instálalos en el [script de configuración](/docs/es/cloud-environments#setup-scripts) del entorno.
Para ver qué conectores tiene un hilo en ejecución en claude.ai/code, abre el hilo y selecciona **Connectors** desde el menú **+** junto a su cuadro de mensaje. Desactivar un conector allí lo elimina de ese hilo, y permanece desactivado para hilos iniciados después hasta que lo reactives. Un hilo recoge un conector que agregas o reconectas después del siguiente mensaje que le envías.
Referencia de configuración del proyecto
Cambias la configuración del proyecto en claude.ai/code o en la aplicación de escritorio, no en `settings.json`. Abre **Project settings** desde **Settings** en el menú de la barra lateral del proyecto o desde el icono de engranaje en el encabezado del proyecto.
Los cambios se guardan a medida que los realizas; un campo de texto que estés editando, como el objetivo o las instrucciones, muestra **Save changes** y **Discard** hasta que lo dejes. Los cambios en instrucciones, repositorios, plugins, y entorno en **Project settings** llegan a hilos nuevos, no a hilos ya en ejecución.
| Configuración | Sección | Qué controla |
| :---------------------------- | :---------- | :------------------------------------------------------------------------------------------------------------------------- |
| Nombre, icono y objetivo | General | El nombre e icono del proyecto en la barra lateral, y su objetivo de una línea |
| Modelo coordinador y esfuerzo | General | El modelo y [nivel de esfuerzo](/docs/es/model-config#adjust-effort-level) para Claude en la conversación del proyecto |
| Modelo de hilo y esfuerzo | General | El modelo y nivel de esfuerzo para hilos |
| Instrucciones del proyecto | Memory | [Reglas permanentes](#give-a-project-standing-context) que cada hilo nuevo recibe |
| Repositorios del proyecto | Environment | Los repositorios que los hilos nuevos clonan |
| Entorno en la nube | Environment | El [entorno en la nube](#choose-an-environment-for-threads) en el que se ejecutan los hilos nuevos |
| Conectores | Environment | Un enlace para administrar los conectores de claude.ai que obtienen los hilos |
| Plugins | Plugins | Los plugins que se cargan en cada hilo nuevo |
| Uso | Usage | [Uso de tokens](#usage-and-cost) por hilo y por modelo |
| Memory | Memory | Los [archivos de memoria](#give-a-project-standing-context) del proyecto |
| Reiniciar Claude | General | Reinicia la conversación del proyecto cuando [Claude deja de responder allí](#claude-hasnt-responded) |
| Pausar, Archivar, Eliminar | General | Detiene, oculta, o elimina el proyecto; ver [Pausar, archivar, o eliminar un proyecto](#pause-archive-or-delete-a-project) |
Pausar, archivar, o eliminar un proyecto
Los tres controles están en la parte inferior de **Project settings > General**:
* **Pause**: detiene todo a la vez. Cada hilo en ejecución y la conversación se interrumpen, no comienzan hilos nuevos, las rutinas no se ejecutan, y el proyecto no acepta mensajes hasta que lo reanudes. Haz clic en **Resume** en el mismo lugar o en el banner arriba del cuadro de mensaje del proyecto; un hilo pausado continúa cuando le envías un mensaje después de eso.
* **Archive**: oculta el proyecto de la barra lateral y archiva sus hilos, que detiene cualquier hilo que estaba en ejecución o observando una solicitud de extracción. Las rutinas en el proyecto no se ejecutan mientras está archivado. Para traer el proyecto de vuelta, ábrelo desde la página Projects y haz clic en **Unarchive**. Sus hilos permanecen archivados hasta que los desarchives individualmente desde la lista de sesiones.
* **Delete**: elimina permanentemente el proyecto junto con sus hilos, su memoria, y sus archivos, y desactiva las rutinas del proyecto. Esto no se puede deshacer. Las ramas y solicitudes de extracción que los hilos insertaron en GitHub no se ven afectadas.
Uso y costo
El uso del proyecto cuenta contra los mismos [límites de plan](/docs/es/errors#youve-hit-your-session-limit) que tus otras sesiones de Claude Code, y un proyecto no puede gastar más allá de esos límites por su cuenta.
Un hilo que alcanza el límite de tu plan espera y continúa por su cuenta cuando el límite se reinicia, así que el trabajo que dejaste en ejecución comienza a usar tu siguiente ventana de uso sin un mensaje de ti. [Un hilo alcanzó el límite de uso](#usage-limit-reached) cubre lo que ves, cómo detenerlo, y el único caso que no espera.
El trabajo va más allá de los límites de tu plan solo si has activado [créditos de uso](/docs/es/costs#add-usage-credits-to-your-subscription) para tu cuenta. Un hilo no puede activarlos para ti.
Qué utiliza tu plan
Un proyecto utiliza tus límites más rápido que una sola sesión, y en un plan Pro en particular deberías esperar alcanzar tu límite más pronto en días que ejecutes uno. Estas son las partes de un proyecto que utilizan tu plan:
* **Hilos en ejecución**: cada uno es una sesión completa, y varios pueden ejecutarse a la vez. No hay un número fijo; Claude comienza tantos como el trabajo requiera, y un límite que [pidas](#tune-how-claude-runs-a-project) es una preferencia en lugar de un límite. El límite aplicado es 200 hilos nuevos por día en todos tus proyectos.
* **La conversación**: Claude utiliza tokens propios leyendo lo que los hilos reportan y decidiendo qué hacer a continuación.
* **Hilos observando una solicitud de extracción**: un hilo inactivo se despierta y utiliza tu plan de nuevo cuando CI falla o llega un comentario de revisión en su solicitud de extracción. Para detener eso, pídele en el hilo que deje de observar la solicitud de extracción.
Un proyecto sin hilos en ejecución, sin solicitudes de extracción observadas, y sin mensajes nuevos no utiliza tu plan mientras se sienta inactivo, y tampoco un proyecto archivado.
Ve y reduce el uso de un proyecto
Abre **Usage** en **Project settings** para ver el uso de tokens por hilo y por modelo, y cuánto fue a la conversación del proyecto. Para reducirlo:
* Un seguimiento enrutado a un hilo que ha estado inactivo más tiempo que la [vida útil del caché](/docs/es/prompt-caching#cache-lifetime), una hora en Pro y Max dentro de los límites de tu plan, vuelve a leer toda la conversación de ese hilo antes de hacer nada. Para trabajo nuevo, pedirle a Claude que comience un hilo fresco puede usar menos que revivir uno antiguo grande.
* Para trabajo que no necesita el modelo más grande, [elige un modelo más pequeño o un nivel de esfuerzo más bajo](#choose-models-and-let-claude-manage-context) para hilos, la conversación, o ambos.
* Pídele a Claude en la conversación del proyecto que ejecute menos hilos a la vez, o que responda pequeñas preguntas él mismo en lugar de comenzar un hilo.
Cómo los proyectos se relacionan con otras características de Claude Code
Varias características de Claude Code permiten que más de una sesión trabaje al mismo tiempo, así que ejecutar trabajo en paralelo no es por sí solo para qué es un proyecto. En un proyecto, Claude comienza y rastrea las sesiones en lugar de ti, cada una comienza desde los mismos repositorios, instrucciones y memoria, y el trabajo vive en la nube mientras dure. Así es como cada característica vecina se conecta a un proyecto:
* **Claude Tag**: [Claude Tag](https://claude.com/docs/claude-tag/overview) es Claude en los canales de Slack de tu equipo, en planes Team y Enterprise. Cualquiera en un canal puede darle trabajo, todos en el canal lo ven y lo dirigen, y utiliza conexiones que un administrador configuró para ese canal. Un proyecto es solo tuyo: eres el único que le envía trabajo o ve sus hilos, utiliza tu propio acceso a GitHub y conectores, y está en Pro y Max. [Cómo Claude Tag difiere de Cowork y Claude Code](https://claude.com/docs/claude-tag/concepts/how-it-works#how-claude-tag-differs-from-cowork-and-claude-code) tiene el lado a lado.
* **Sesiones en la nube**: cada hilo es una [sesión en la nube](/docs/es/claude-code-on-the-web), comenzada y rastreada por Claude en lugar de por ti. Una sesión en la nube que comenzaste tú mismo puede convertirse en un proyecto o alimentar uno a través de [**Continue as a project** o **Move to project**](#start-from-an-existing-cloud-session).
* **Routines**: cuando pides trabajo programado en un proyecto, Claude crea una [rutina](/docs/es/routines) que se ejecuta como hilos en ese proyecto y aparece en su pestaña **Routines**. Las rutinas que creas fuera de un proyecto siguen funcionando por su cuenta.
* **Sesiones locales y vista de agente**: las sesiones en tu terminal, IDE, o el entorno local de la aplicación de escritorio se ejecutan en tu máquina y no pueden ser parte de un proyecto. [Vista de agente](/docs/es/agent-view) es una pantalla para rastrear varias de esas sesiones locales; no tiene coordinador.
* **Worktrees**: un [worktree](/docs/es/worktrees) le da a cada sesión local su propia copia de trabajo de un repositorio para que las sesiones paralelas en tu máquina no se sobrescriban entre sí. Los hilos no los necesitan: cada hilo clona sus repositorios en su propia sandbox en la nube y trabaja en su propia rama.
* **Equipos de agentes**: un [equipo de agentes](/docs/es/agent-teams) es una sesión que comienza sesiones de compañeros para una sola tarea, en tu máquina o dentro de una sesión en la nube, y termina con esa tarea.
* **Projects en claude.ai chat y Cowork**: la [experiencia anterior de Projects](https://support.claude.com/en/articles/9517075-what-are-projects), que agrupa conversaciones y archivos de referencia sin hilos o coordinador. Esos proyectos siguen funcionando como lo hacen hoy hasta que la experiencia rediseñada los alcance.
[Ejecutar agentes en paralelo](/docs/es/agents) compara estas opciones lado a lado.
Limitaciones
* Los proyectos están disponibles en claude.ai/code y en la aplicación de escritorio, no en el CLI de terminal o a través de Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry. El comando [`claude project`](/docs/es/cli-reference) del CLI, que administra el estado local de Claude Code para un directorio, no está relacionado.
* Los hilos del proyecto son [sesiones en la nube](/docs/es/claude-code-on-the-web) con Anthropic como proveedor de modelo. [Seguridad](/docs/es/security) y [Uso de datos](/docs/es/data-usage) cubren cómo se aíslan las sesiones en la nube y qué se retiene.
* Una sesión local no puede ser parte de un proyecto.
* La sandbox de un hilo se pausa entre turnos y se reanuda cuando el hilo continúa. Si la sandbox no se puede reanudar, el hilo continúa desde un clon fresco, así que los cambios no confirmados pueden perderse. En tareas largas, pídele a Claude que confirme e inserte trabajo en progreso.
* Un proyecto pertenece a un usuario. No puedes compartir un proyecto o sus hilos con otro usuario, y las transcripciones de hilos no tienen la opción de compartir que tienen otras sesiones en la nube. No hay controles a nivel de organización para proyectos durante la beta.
* Un hilo pertenece al único proyecto que lo comenzó. No puedes mover o copiar un hilo a otro proyecto, o sacarlo para que esté solo. [**Move to project**](#start-from-an-existing-cloud-session) va solo en la otra dirección: trae el trabajo de una sesión en la nube a un proyecto.
Solución de problemas
Para los avisos de configuración de GitHub en el diálogo **New project**, ver [Configurar acceso a GitHub](#set-up-github-access).
Un hilo parece estar atascado
Claude no publica cada paso que toma un hilo, así que un hilo que se muestra como en ejecución sin mensajes nuevos en la conversación del proyecto generalmente aún está trabajando. Un hilo nuevo también aprovisiona su [entorno en la nube](/docs/es/cloud-environments) antes de que Claude comience, así que su primera actualización toma un momento. Abre el hilo para leer su transcripción. Si el hilo está esperando un aviso de permiso, respóndelo allí.
Los hilos adivinaron o se estancaron en lugar de preguntar
Cuando varios hilos regresan habiendo asumido algo incorrecto, trabajado alrededor del acceso faltante, o detenido con "bloqueado", la causa generalmente es la misma brecha en la configuración del proyecto en lugar de un problema con cada tarea. Ordena qué hilos son sólidos antes de arreglar nada:
1. Pídele a Claude en la conversación: "Para cada hilo abierto, enumera lo que le pediste que hiciera, qué asumió o no pudo alcanzar, y en qué está esperando." Claude lee cada hilo y responde en la conversación.
2. Para hilos que comenzaron desde una suposición incorrecta, abre el hilo desde **Overview** y márcalo resuelto desde su menú, o dile qué hacer en su lugar en su cuadro de mensaje. Su rama y cualquier solicitud de extracción permanecen en GitHub hasta que las elimines.
3. Arregla la brecha una vez, en [instrucciones del proyecto](#give-a-project-standing-context) o el [entorno](#choose-an-environment-for-threads), luego envía un hilo antes de enviar el resto del trabajo de nuevo como hilos nuevos.
Claude no ha respondido
La conversación del proyecto muestra un banner "Claude hasn't responded" cuando Claude está en ejecución pero sus respuestas no llegan al proyecto. Haz clic en **Restart Claude** en el banner, o ve a **Project settings > General** y haz clic en **Restart** en la fila **Restart Claude**. Claude se reconecta a la conversación; cualquier respuesta que estaba en medio de escribir se pierde, y los hilos no se ven afectados.
Errores de acceso al repositorio
Tres mensajes significan que un hilo o el proyecto no puede alcanzar uno de sus repositorios. Un hilo del proyecto necesita los [requisitos previos de GitHub](#check-the-prerequisites) incluso cuando tus otras sesiones en la nube clonan el mismo repositorio sin problemas.
* **"Couldn't start the session — Claude doesn't have GitHub access to this project's repository"**, reportado antes de que comience el hilo, cuando la Claude GitHub App no está instalada en ese repositorio, está suspendida, o no está vinculada a la cuenta de GitHub que conectaste.
* **"Unable to access your repository"**, reportado por un hilo cuando su clon falla: GitHub rechazó el clon, el repositorio no se encontró bajo el nombre que tiene el proyecto, o la rama desde la que se le pidió al hilo que comenzara no existe.
* **"Claude can't access"** un repositorio, mostrado cuando guardas repositorios en el diálogo **New project** o **Project settings**. El mensaje continúa con un enlace de instalación y un enlace de reconexión. Usa el enlace de instalación si la Claude GitHub App no está en ese repositorio, y el enlace de reconexión si lo está, ya que la Claude GitHub App puede estar instalada en GitHub sin estar vinculada a la cuenta que conectaste a Claude. Si el mensaje dice que la Claude GitHub App está suspendida o no incluye este repositorio, sigue su enlace a GitHub para arreglarlo.
Para arreglar cualquiera de ellos, haz clic en el botón que ofrece el mensaje, como **Install GitHub App** o **Select repositories on GitHub**, luego **Check again**. Cuando el bloqueo está del lado de la organización de GitHub, como un propietario que no ha aprobado la aplicación o una lista de permitidos de IP que excluye a Claude, el mensaje muestra un enlace **See how to fix** en su lugar. Si no hay botón, sigue [Configurar acceso a GitHub](#set-up-github-access), luego envía otro mensaje para reintentar.
Un hilo alcanzó el límite de uso
Cuando un hilo o la conversación del proyecto alcanza el límite de cinco horas o semanal de tu plan, sigue reintentando por su cuenta y continúa cuando el límite se reinicia. Mientras espera, el hilo muestra **Service is busy** con "Claude is still retrying and will continue automatically." No necesitas hacer nada para que el trabajo continúe. Si prefieres que no use tu siguiente ventana de uso, haz clic en **Stop** en el hilo, o [pausa el proyecto](#pause-archive-or-delete-a-project) para mantener cada hilo. Un hilo que una rutina comenzó no espera: su turno se detiene con un error de límite, y le envías un mensaje después de que el límite se reinicia.
[Errores de límite de uso](/docs/es/errors#youve-hit-your-session-limit) explican los límites y cuándo se reinician.
Se requieren créditos de uso adicionales
Un hilo o la conversación del proyecto hizo una solicitud que tu plan cubre solo con créditos de uso, como una a un modelo o tamaño de contexto que tu plan no incluye, y los créditos de uso no están activados para tu cuenta. [Agregar créditos de uso a tu suscripción](/docs/es/costs#add-usage-credits-to-your-subscription) cubre quién puede activarlos o comprarlos en cada plan. Una vez que los créditos estén disponibles, envía otro mensaje para reintentar.
Otros mensajes
Estos mensajes nombran su propia causa. La tabla da el próximo paso para cada uno.
| Mensaje | Qué hacer |
| :-------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| "Unable to connect to repository" con "Claude couldn't reach GitHub to fetch your repository" | Espera un momento, luego envía otro mensaje para reintentar |
| "Unable to connect to repository" con "Claude couldn't access your repository or environment" | Tu cuenta de GitHub necesita acceso de inserción al repositorio, y el entorno aún debe existir. Verifica ambos en **Project settings > Environment**, luego reintentar |
| "Couldn't show the setup proposal" | La aplicación que tienes abierta es más antigua que las **Setup recommendations** que Claude envió. Actualiza la página o reinicia la aplicación de escritorio, o pídele a Claude que proponga la configuración de nuevo |
| "The project's environment was removed" | Elige un entorno diferente en **Project settings > Environment**; el cambio se aplica a hilos nuevos |
| "Setup script failed" | Haz clic en **Edit setup script** en el error, arregla el script en el entorno, luego envía otro mensaje. [Setup script failed](/docs/es/web-quickstart#setup-script-failed) enumera las causas comunes |
| "Claude ran out of context on this turn" | El hilo llenó su ventana de contexto. Si el mensaje dice que el hilo continúa en una sesión fresca, continúa por sí solo; de lo contrario, pídele a Claude en la conversación del proyecto que comience un hilo nuevo para el trabajo restante |
| "Reached the turn limit" | El hilo alcanzó el límite de pasos para un mensaje. Envía otro mensaje con una solicitud más pequeña o más específica, o pídele a Claude que divida la tarea entre hilos |
* [Usa Claude Code en la nube](/docs/es/claude-code-on-the-web): cómo funcionan las sesiones en la nube detrás de cada hilo, incluidas las opciones de acceso a GitHub y auto-fix en solicitudes de extracción
* [Configura entornos en la nube](/docs/es/cloud-environments): cambia a qué pueden llegar los hilos en la red, dale variables de entorno y credenciales de API, e instala herramientas con un script de configuración
* [Automatiza trabajo con rutinas](/docs/es/routines): horarios, disparadores, y administración para rutinas, incluidas las que Claude crea desde un proyecto
* [Administra múltiples agentes con vista de agente](/docs/es/agent-view): ejecuta y rastrea varias sesiones en tu propia máquina cuando el trabajo necesita herramientas o servicios que solo tu máquina puede alcanzar
* [Proyectos rediseñados: de carpeta a conversación](https://claude.com/blog/projects-redesigned): el anuncio de lanzamiento, con el pensamiento detrás de hacer que un proyecto sea una conversación con Claude