6 6
7> Guías paso a paso para explorar bases de código, corregir errores, refactorizar, probar y otras tareas cotidianas con Claude Code.7> Guías paso a paso para explorar bases de código, corregir errores, refactorizar, probar y otras tareas cotidianas con Claude Code.
8 8
9Esta página cubre flujos de trabajo prácticos para el desarrollo cotidiano: explorar código desconocido, depuración, refactorización, escritura de pruebas, creación de solicitudes de extracción y gestión de sesiones. Cada sección incluye ejemplos de indicaciones que puede adaptar a sus propios proyectos. Para patrones y consejos de nivel superior, consulte [Mejores prácticas](/es/best-practices).9Esta página recopila recetas cortas para el desarrollo cotidiano. Para orientación de nivel superior sobre indicaciones y gestión de contexto, consulte [Mejores prácticas](/es/best-practices).
10 10
11## Comprender nuevas bases de código11Esta página cubre:
12 12
13### Obtener una descripción general rápida de la base de código13* [Recetas de indicaciones](#prompt-recipes) para explorar código, corregir errores, refactorizar, probar, PRs y documentación
14* [Reanudar conversaciones anteriores](#resume-previous-conversations) para que una tarea pueda abarcar múltiples sesiones
15* [Ejecutar sesiones paralelas con worktrees](#run-parallel-sessions-with-worktrees) para que las ediciones concurrentes no choquen
16* [Planificar antes de editar](#plan-before-editing) para revisar cambios antes de que toquen el disco
17* [Delegar investigación a subagentes](#delegate-research-to-subagents) para mantener su contexto principal limpio
18* [Canalizar Claude en scripts](#pipe-claude-into-scripts) para CI y procesamiento por lotes
19
20## Recetas de indicaciones
21
22Estos son patrones de indicaciones para tareas cotidianas como explorar código desconocido, depuración, refactorización, escritura de pruebas y creación de PRs. Cada uno funciona en cualquier superficie de Claude Code; adapte la redacción a su proyecto.
23
24### Comprender nuevas bases de código
25
26#### Obtener una descripción general rápida de la base de código
14 27
15Supongamos que acaba de unirse a un nuevo proyecto y necesita comprender su estructura rápidamente.28Supongamos que acaba de unirse a un nuevo proyecto y necesita comprender su estructura rápidamente.
16 29
56 * Solicite un glosario de términos específicos del proyecto69 * Solicite un glosario de términos específicos del proyecto
57</Tip>70</Tip>
58 71
59### Encontrar código relevante72#### Encontrar código relevante
60 73
61Supongamos que necesita localizar código relacionado con una característica o funcionalidad específica.74Supongamos que necesita localizar código relacionado con una característica o funcionalidad específica.
62 75
90 103
91***104***
92 105
93## Corregir errores de manera eficiente106### Corregir errores de manera eficiente
94 107
95Supongamos que ha encontrado un mensaje de error y necesita encontrar y corregir su origen.108Supongamos que ha encontrado un mensaje de error y necesita encontrar y corregir su origen.
96 109
124 137
125***138***
126 139
127## Refactorizar código140### Refactorizar código
128 141
129Supongamos que necesita actualizar código antiguo para utilizar patrones y prácticas modernas.142Supongamos que necesita actualizar código antiguo para utilizar patrones y prácticas modernas.
130 143
164 177
165***178***
166 179
167## Usar subagentes especializados180### Trabajar con pruebas
168
169Supongamos que desea utilizar subagentes de IA especializados para manejar tareas específicas de manera más efectiva.
170
171<Steps>
172 <Step title="Ver subagentes disponibles">
173 ```text theme={null}
174 /agents
175 ```
176
177 Esto muestra todos los subagentes disponibles y le permite crear otros nuevos.
178 </Step>
179
180 <Step title="Usar subagentes automáticamente">
181 Claude Code delega automáticamente tareas apropiadas a subagentes especializados:
182
183 ```text theme={null}
184 revisa mis cambios de código recientes para problemas de seguridad
185 ```
186
187 ```text theme={null}
188 ejecuta todas las pruebas y corrige cualquier fallo
189 ```
190 </Step>
191
192 <Step title="Solicitar explícitamente subagentes específicos">
193 ```text theme={null}
194 usa el subagente code-reviewer para verificar el módulo de autenticación
195 ```
196
197 ```text theme={null}
198 haz que el subagente debugger investigue por qué los usuarios no pueden iniciar sesión
199 ```
200 </Step>
201
202 <Step title="Crear subagentes personalizados para su flujo de trabajo">
203 ```text theme={null}
204 /agents
205 ```
206
207 Luego seleccione "Crear nuevo subagente" y siga las indicaciones para definir:
208
209 * Un identificador único que describa el propósito del subagente (por ejemplo, `code-reviewer`, `api-designer`).
210 * Cuándo Claude debe usar este agente
211 * Qué herramientas puede acceder
212 * Un indicador del sistema que describa el rol y comportamiento del agente
213 </Step>
214</Steps>
215
216<Tip>
217 Consejos:
218
219 * Cree subagentes específicos del proyecto en `.claude/agents/` para compartir en equipo
220 * Utilice campos `description` descriptivos para habilitar la delegación automática
221 * Limite el acceso a herramientas a lo que cada subagente realmente necesita
222 * Consulte la [documentación de subagentes](/es/sub-agents) para ejemplos detallados
223</Tip>
224
225***
226
227## Usar Plan Mode para análisis seguro de código
228
229Plan Mode instruye a Claude para crear un plan analizando la base de código con operaciones de solo lectura, perfecto para explorar bases de código, planificar cambios complejos o revisar código de manera segura. En Plan Mode, Claude utiliza [`AskUserQuestion`](/es/tools-reference) para recopilar requisitos y aclarar sus objetivos antes de proponer un plan.
230
231### Cuándo usar Plan Mode
232
233* **Implementación de múltiples pasos**: Cuando su característica requiere hacer ediciones en muchos archivos
234* **Exploración de código**: Cuando desea investigar la base de código a fondo antes de cambiar nada
235* **Desarrollo interactivo**: Cuando desea iterar en la dirección con Claude
236
237### Cómo usar Plan Mode
238
239**Activar Plan Mode durante una sesión**
240
241Puede cambiar a Plan Mode durante una sesión usando **Shift+Tab** para ciclar a través de modos de permiso.
242
243Si está en Normal Mode, **Shift+Tab** primero cambia a Auto-Accept Mode, indicado por `⏵⏵ accept edits on` en la parte inferior de la terminal. Un **Shift+Tab** posterior cambiará a Plan Mode, indicado por `⏸ plan mode on`.
244
245**Iniciar una nueva sesión en Plan Mode**
246
247Para iniciar una nueva sesión en Plan Mode, use la bandera `--permission-mode plan`:
248
249```bash theme={null}
250claude --permission-mode plan
251```
252
253**Ejecutar consultas "sin interfaz" en Plan Mode**
254
255También puede ejecutar una consulta en Plan Mode directamente con `-p` (es decir, en ["modo sin interfaz"](/es/headless)):
256
257```bash theme={null}
258claude --permission-mode plan -p "Analiza el sistema de autenticación y sugiere mejoras"
259```
260
261### Ejemplo: Planificar una refactorización compleja
262
263```bash theme={null}
264claude --permission-mode plan
265```
266
267```text theme={null}
268Necesito refactorizar nuestro sistema de autenticación para usar OAuth2. Crea un plan de migración detallado.
269```
270
271Claude analiza la implementación actual y crea un plan integral. Refine con seguimientos:
272
273```text theme={null}
274¿Qué hay sobre la compatibilidad hacia atrás?
275```
276
277```text theme={null}
278¿Cómo deberíamos manejar la migración de la base de datos?
279```
280
281<Tip>Presione `Ctrl+G` para abrir el plan en su editor de texto predeterminado, donde puede editarlo directamente antes de que Claude continúe.</Tip>
282
283Cuando acepta un plan, Claude automáticamente nombra la sesión a partir del contenido del plan. El nombre aparece en la barra de indicación y en el selector de sesión. Si ya ha establecido un nombre con `--name` o `/rename`, aceptar un plan no lo sobrescribirá.
284
285### Configurar Plan Mode como predeterminado
286
287```json theme={null}
288// .claude/settings.json
289{
290 "permissions": {
291 "defaultMode": "plan"
292 }
293}
294```
295
296Consulte la [documentación de configuración](/es/settings#available-settings) para más opciones de configuración.
297
298***
299
300## Trabajar con pruebas
301 181
302Supongamos que necesita agregar pruebas para código no cubierto.182Supongamos que necesita agregar pruebas para código no cubierto.
303 183
333 213
334***214***
335 215
336## Crear solicitudes de extracción216### Crear solicitudes de extracción
337 217
338Puede crear solicitudes de extracción pidiendo a Claude directamente ("crear una pr para mis cambios"), o guiar a Claude a través de ella paso a paso:218Puede crear solicitudes de extracción pidiendo a Claude directamente ("crear una pr para mis cambios"), o guiar a Claude a través de ella paso a paso:
339 219
357 </Step>237 </Step>
358</Steps>238</Steps>
359 239
360Cuando crea una PR usando `gh pr create`, la sesión se vincula automáticamente a esa PR. Puede reanudarla más tarde con `claude --from-pr <number>`.240Cuando crea una PR usando `gh pr create`, la sesión se vincula automáticamente a esa PR. Para regresar a ella más tarde, ejecute `claude --from-pr <number>` o pegue la URL de la PR en el selector [`/resume`](/es/sessions#use-the-session-picker).
361 241
362<Tip>242<Tip>
363 Revise la PR generada por Claude antes de enviarla y pida a Claude que destaque los riesgos potenciales o consideraciones.243 Revise la PR generada por Claude antes de enviarla y pida a Claude que destaque los riesgos potenciales o consideraciones.
364</Tip>244</Tip>
365 245
366## Manejar documentación246### Manejar documentación
367 247
368Supongamos que necesita agregar o actualizar documentación para su código.248Supongamos que necesita agregar o actualizar documentación para su código.
369 249
403 283
404***284***
405 285
406## Trabajar en notas y carpetas que no son código286### Trabajar en notas y carpetas que no son código
407 287
408Claude Code funciona en cualquier directorio. Ejecútelo dentro de una bóveda de notas, una carpeta de documentación o cualquier colección de archivos markdown para buscar, editar y reorganizar contenido de la misma manera que lo haría con código.288Claude Code funciona en cualquier directorio. Ejecútelo dentro de una bóveda de notas, una carpeta de documentación o cualquier colección de archivos markdown para buscar, editar y reorganizar contenido de la misma manera que lo haría con código.
409 289
411 291
412***292***
413 293
414## Trabajar con imágenes294### Trabajar con imágenes
415 295
416Supongamos que necesita trabajar con imágenes en su base de código y desea la ayuda de Claude para analizar el contenido de la imagen.296Supongamos que necesita trabajar con imágenes en su base de código y desea la ayuda de Claude para analizar el contenido de la imagen.
417 297
471 351
472***352***
473 353
474## Archivos y directorios de referencia354### Archivos y directorios de referencia
475 355
476Use @ para incluir rápidamente archivos o directorios sin esperar a que Claude los lea.356Use @ para incluir rápidamente archivos o directorios sin esperar a que Claude los lea.
477 357
512 392
513***393***
514 394
515## Usar pensamiento extendido (Thinking Mode)395### Ejecutar Claude en un horario
516
517[El pensamiento extendido](https://platform.claude.com/docs/es/build-with-claude/extended-thinking) está habilitado de forma predeterminada, dando a Claude espacio para razonar a través de problemas complejos paso a paso antes de responder. Este razonamiento es visible en modo detallado, que puede alternar con `Ctrl+O`. Durante el pensamiento extendido, el indicador de progreso muestra sugerencias de progreso en línea como "aún pensando" y "casi terminado de pensar" para indicar que Claude está trabajando activamente.
518
519Además, [los modelos que admiten esfuerzo](/es/model-config#adjust-effort-level) utilizan razonamiento adaptativo: en lugar de un presupuesto de token de pensamiento fijo, el modelo decide dinámicamente si y cuánto pensar basándose en su configuración de nivel de esfuerzo y la tarea en cuestión. El razonamiento adaptativo permite a Claude responder más rápido a indicaciones rutinarias y reservar un pensamiento más profundo para pasos que se benefician de él.
520
521El pensamiento extendido es particularmente valioso para decisiones arquitectónicas complejas, errores desafiantes, planificación de implementación de múltiples pasos y evaluación de compensaciones entre diferentes enfoques.
522
523<Note>
524 Frases como "think", "think hard" y "think more" se interpretan como instrucciones de indicación regulares y no asignan tokens de pensamiento.
525</Note>
526
527### Configurar Thinking Mode
528
529El pensamiento está habilitado de forma predeterminada, pero puede ajustarlo o deshabilitarlo.
530
531| Alcance | Cómo configurar | Detalles |
532| ------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
533| **Nivel de esfuerzo** | Ejecute `/effort`, ajuste en `/model`, o establezca [`CLAUDE_CODE_EFFORT_LEVEL`](/es/env-vars) | Control de profundidad de pensamiento en [modelos compatibles](/es/model-config#adjust-effort-level) |
534| **Palabra clave `ultrathink`** | Incluya "ultrathink" en cualquier lugar de su indicación | Agrega una instrucción en contexto indicando al modelo que razone más en ese turno. No cambia el nivel de esfuerzo en sí; consulte [Ajustar nivel de esfuerzo](/es/model-config#adjust-effort-level) para eso |
535| **Atajo de alternancia** | Presione `Option+T` (macOS) o `Alt+T` (Windows/Linux) | Alterne el pensamiento activado/desactivado para la sesión actual (todos los modelos). Puede requerir [configuración de terminal](/es/terminal-config) para habilitar atajos de teclado de opción |
536| **Predeterminado global** | Use `/config` para alternar Thinking Mode | Establece su predeterminado en todos los proyectos (todos los modelos).<br />Guardado como `alwaysThinkingEnabled` en `~/.claude/settings.json` |
537| **Presupuesto de token límite** | Establezca la variable de entorno [`MAX_THINKING_TOKENS`](/es/env-vars) | Limite el presupuesto de pensamiento a un número específico de tokens. En modelos con razonamiento adaptativo, solo `0` se aplica a menos que se deshabilite el razonamiento adaptativo. Ejemplo: `export MAX_THINKING_TOKENS=10000` |
538
539Para ver el proceso de pensamiento de Claude, presione `Ctrl+O` para alternar el modo detallado y ver el razonamiento interno mostrado como texto gris en cursiva.
540
541### Cómo funciona el pensamiento extendido
542
543El pensamiento extendido controla cuánto razonamiento interno realiza Claude antes de responder. Más pensamiento proporciona más espacio para explorar soluciones, analizar casos extremos y autocorregir errores.
544
545En [modelos que admiten esfuerzo](/es/model-config#adjust-effort-level), el pensamiento utiliza razonamiento adaptativo: el modelo asigna dinámicamente tokens de pensamiento basados en el nivel de esfuerzo que selecciona. Esta es la forma recomendada de ajustar la compensación entre velocidad y profundidad de razonamiento. Si desea que Claude piense más o menos de lo que su nivel de esfuerzo produciría de otra manera, también puede decirlo directamente en su indicación o en `CLAUDE.md`.
546
547Con modelos más antiguos, el pensamiento utiliza un presupuesto fijo de tokens extraído de su asignación de salida. El presupuesto varía según el modelo; consulte [`MAX_THINKING_TOKENS`](/es/env-vars) para los límites por modelo. Puede limitar el presupuesto con esa variable de entorno, o deshabilitar el pensamiento completamente a través de `/config` o el alternador `Option+T`/`Alt+T`.
548
549En modelos con razonamiento adaptativo, `MAX_THINKING_TOKENS` solo se aplica cuando se establece en `0` para deshabilitar el pensamiento, o cuando `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` revierte el modelo al presupuesto fijo. `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` se aplica solo a Opus 4.6 y Sonnet 4.6. Opus 4.7 siempre utiliza razonamiento adaptativo y no admite un presupuesto de pensamiento fijo. Consulte [variables de entorno](/es/env-vars).
550
551<Warning>
552 Se le cobra por todos los tokens de pensamiento utilizados incluso cuando los resúmenes de pensamiento se redactan. En modo interactivo, el pensamiento aparece como un resumen contraído de forma predeterminada. Establezca `showThinkingSummaries: true` en `settings.json` para mostrar resúmenes completos.
553</Warning>
554
555***
556
557## Reanudar conversaciones anteriores
558
559Cuando inicia Claude Code, puede reanudar una sesión anterior:
560
561* `claude --continue` continúa la conversación más reciente en el directorio actual
562* `claude --resume` abre un selector de conversación o reanuda por nombre
563* `claude --from-pr 123` reanuda sesiones vinculadas a una solicitud de extracción específica
564
565Desde dentro de una sesión activa, use `/resume` para cambiar a una conversación diferente.
566
567Cuando la sesión seleccionada es antigua y lo suficientemente grande como para que releerla consumiría una parte sustancial de sus límites de uso, `--resume`, `--continue` y `/resume` ofrecen reanudar desde un resumen en lugar de cargar la transcripción completa. Este mensaje no está disponible en Amazon Bedrock, Google Cloud Vertex AI o Microsoft Foundry.
568
569Las sesiones se almacenan por directorio de proyecto. De forma predeterminada, el selector `/resume` muestra sesiones interactivas del worktree actual, con atajos de teclado para ampliar la lista a otros worktrees o proyectos, buscar, obtener una vista previa y renombrar. Consulte [Usar el selector de sesión](#use-the-session-picker) a continuación para la referencia completa de atajos.
570
571Cuando selecciona una sesión de otro worktree del mismo repositorio, Claude Code la reanuda directamente sin requerir que cambie de directorio primero. Seleccionar una sesión de un proyecto no relacionado copia un comando `cd` y reanuda a su portapapeles en su lugar.
572
573Reanudar por nombre se resuelve en el repositorio actual y sus worktrees. Tanto `claude --resume <name>` como `/resume <name>` buscan una coincidencia exacta y la reanudan directamente, incluso si la sesión vive en un worktree diferente.
574
575Cuando el nombre es ambiguo, `claude --resume <name>` abre el selector con el nombre rellenado previamente como término de búsqueda. `/resume <name>` desde dentro de una sesión reporta un error en su lugar, así que ejecute `/resume` sin argumento para abrir el selector y elegir.
576
577Las sesiones creadas por `claude -p` o invocaciones de SDK no aparecen en el selector, pero aún puede reanudar una pasando su ID de sesión directamente a `claude --resume <session-id>`.
578
579### Nombrar sus sesiones
580
581Dé a las sesiones nombres descriptivos para encontrarlas más tarde. Esta es una mejor práctica cuando se trabaja en múltiples tareas o características.
582
583<Steps>
584 <Step title="Nombre la sesión">
585 Nombre una sesión al inicio con `-n`:
586
587 ```bash theme={null}
588 claude -n auth-refactor
589 ```
590
591 O use `/rename` durante una sesión, que también muestra el nombre en la barra de indicación:
592
593 ```text theme={null}
594 /rename auth-refactor
595 ```
596
597 También puede renombrar cualquier sesión desde el selector: ejecute `/resume`, navegue a una sesión y presione `Ctrl+R`.
598 </Step>
599
600 <Step title="Reanude por nombre más tarde">
601 Desde la línea de comandos:
602
603 ```bash theme={null}
604 claude --resume auth-refactor
605 ```
606
607 O desde dentro de una sesión activa:
608
609 ```text theme={null}
610 /resume auth-refactor
611 ```
612 </Step>
613</Steps>
614
615### Usar el selector de sesión
616
617El comando `/resume` (o `claude --resume` sin argumentos) abre un selector de sesión interactivo con estas características:
618
619**Atajos de teclado en el selector:**
620
621| Atajo | Acción |
622| :----------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
623| `↑` / `↓` | Navegue entre sesiones |
624| `→` / `←` | Expandir o contraer sesiones agrupadas |
625| `Enter` | Seleccione y reanude la sesión resaltada |
626| `Space` | Vista previa del contenido de la sesión. `Ctrl+V` también funciona en terminales que no lo capturan como pegado |
627| `Ctrl+R` | Renombre la sesión resaltada |
628| `/` o cualquier carácter imprimible que no sea `Space` | Ingrese al modo de búsqueda y filtre sesiones |
629| `Ctrl+A` | Muestre sesiones de todos los proyectos en esta máquina. Presione de nuevo para restaurar el repositorio actual |
630| `Ctrl+W` | Muestre sesiones de todos los worktrees del repositorio actual. Presione de nuevo para restaurar el worktree actual. Solo se muestra en repositorios con múltiples worktrees |
631| `Ctrl+B` | Filtre a sesiones de su rama de git actual. Presione de nuevo para mostrar sesiones de todas las ramas |
632| `Esc` | Salga del selector o modo de búsqueda |
633
634**Organización de sesiones:**
635
636El selector muestra sesiones con metadatos útiles:
637
638* Nombre de sesión si se establece, de lo contrario el resumen de conversación o la primera indicación del usuario
639* Tiempo transcurrido desde la última actividad
640* Recuento de mensajes
641* Rama de Git (si aplica)
642* Ruta del proyecto, mostrada después de ampliar a todos los proyectos con `Ctrl+A`
643
644Las sesiones bifurcadas (creadas con `/branch`, `/rewind`, o `--fork-session`) se agrupan bajo su sesión raíz, lo que facilita encontrar conversaciones relacionadas.
645
646<Tip>
647 Consejos:
648
649 * **Nombre sesiones temprano**: Use `/rename` cuando comience a trabajar en una tarea distinta: es mucho más fácil encontrar "payment-integration" que "explain this function" más tarde
650 * Use `--continue` para acceso rápido a su conversación más reciente en el directorio actual
651 * Use `--resume session-name` cuando sepa qué sesión necesita
652 * Use `--resume` (sin nombre) cuando necesite examinar y seleccionar
653 * Para scripts, use `claude --continue --print "prompt"` para reanudar en modo no interactivo
654 * Presione `Space` en el selector para obtener una vista previa de una sesión antes de reanudarla
655 * La conversación reanudada comienza con el mismo modelo y configuración que el original
656
657 Cómo funciona:
658
659 1. **Almacenamiento de conversación**: Todas las conversaciones se guardan automáticamente localmente con su historial de mensajes completo
660 2. **Deserialización de mensajes**: Al reanudar, se restaura el historial de mensajes completo para mantener el contexto
661 3. **Estado de herramienta**: El uso de herramientas y los resultados de la conversación anterior se conservan
662 4. **Restauración de contexto**: La conversación se reanuda con todo el contexto anterior intacto
663</Tip>
664
665***
666
667## Ejecutar sesiones paralelas de Claude Code con Git worktrees
668
669Cuando trabaja en múltiples tareas a la vez, necesita que cada sesión de Claude tenga su propia copia de la base de código para que los cambios no choquen. Los worktrees de Git resuelven esto creando directorios de trabajo separados que cada uno tiene sus propios archivos y rama, mientras comparten el mismo historial de repositorio y conexiones remotas. Esto significa que puede tener a Claude trabajando en una característica en un worktree mientras corrige un error en otro, sin que ninguna sesión interfiera con la otra.
670
671Use la bandera `--worktree` (`-w`) para crear un worktree aislado e iniciar Claude en él. El valor que pasa se convierte en el nombre del directorio worktree y el nombre de la rama:
672
673```bash theme={null}
674# Inicie Claude en un worktree llamado "feature-auth"
675# Crea .claude/worktrees/feature-auth/ con una nueva rama
676claude --worktree feature-auth
677
678# Inicie otra sesión en un worktree separado
679claude --worktree bugfix-123
680```
681
682Si omite el nombre, Claude genera uno automáticamente:
683
684```bash theme={null}
685# Auto-genera un nombre como "bright-running-fox"
686claude --worktree
687```
688
689Los worktrees se crean en `<repo>/.claude/worktrees/<name>` y se ramifican desde la rama remota predeterminada, que es donde `origin/HEAD` apunta. La rama worktree se nombra `worktree-<name>`.
690
691La rama base no es configurable a través de una bandera o configuración de Claude Code. `origin/HEAD` es una referencia almacenada en su directorio `.git` local que Git estableció una vez cuando clonó. Si la rama predeterminada del repositorio cambia más tarde en GitHub o GitLab, su `origin/HEAD` local sigue apuntando al anterior, y los worktrees se ramificarán desde allí. Para resincronizar su referencia local con lo que el remoto actualmente considera su predeterminado:
692
693```bash theme={null}
694git remote set-head origin -a
695```
696
697Este es un comando Git estándar que solo actualiza su directorio `.git` local. Nada en el servidor remoto cambia. Si desea que los worktrees se basen en una rama específica en lugar del predeterminado del remoto, establézcalo explícitamente con `git remote set-head origin your-branch-name`.
698
699Para control total sobre cómo se crean los worktrees, incluida la elección de una base diferente por invocación, configure un [hook WorktreeCreate](/es/hooks#worktreecreate). El hook reemplaza completamente la lógica predeterminada de `git worktree` de Claude Code, para que pueda obtener y ramificar desde cualquier ref que necesite.
700
701También puede pedir a Claude que "trabaje en un worktree" o "inicie un worktree" durante una sesión, y lo creará automáticamente.
702
703### Worktrees de subagente
704
705Los subagentes también pueden usar aislamiento de worktree para trabajar en paralelo sin conflictos. Pida a Claude que "use worktrees para sus agentes" o configúrelo en un [subagente personalizado](/es/sub-agents#supported-frontmatter-fields) agregando `isolation: worktree` al frontmatter del agente. Cada subagente obtiene su propio worktree que se limpia automáticamente cuando el subagente termina sin cambios.
706
707### Limpieza de worktree
708
709Cuando sale de una sesión de worktree, Claude maneja la limpieza según si realizó cambios:
710
711* **Sin cambios**: el worktree y su rama se eliminan automáticamente
712* **Cambios o commits existen**: Claude le solicita que mantenga o elimine el worktree. Mantener preserva el directorio y la rama para que pueda regresar más tarde. Eliminar elimina el directorio worktree y su rama, descartando todos los cambios sin confirmar y commits
713
714Los worktrees de subagente huérfanos por un bloqueo o una ejecución paralela interrumpida se eliminan automáticamente al inicio una vez que son más antiguos que su configuración [`cleanupPeriodDays`](/es/settings#available-settings), siempre que no tengan cambios sin confirmar, archivos sin seguimiento y commits sin enviar. Los worktrees que crea con `--worktree` nunca se eliminan por este barrido.
715
716Para limpiar worktrees fuera de una sesión de Claude, use [gestión manual de worktree](#manage-worktrees-manually).
717
718<Tip>
719 Agregue `.claude/worktrees/` a su `.gitignore` para evitar que el contenido del worktree aparezca como archivos sin seguimiento en su repositorio principal.
720</Tip>
721
722### Copiar archivos ignorados por git a worktrees
723
724Los worktrees de Git son descargas nuevas, por lo que no incluyen archivos sin seguimiento como `.env` o `.env.local` de su repositorio principal. Para copiar automáticamente estos archivos cuando Claude crea un worktree, agregue un archivo `.worktreeinclude` a la raíz de su proyecto.
725
726El archivo utiliza la sintaxis `.gitignore` para enumerar qué archivos copiar. Solo los archivos que coinciden con un patrón y también están ignorados por git se copian, por lo que los archivos rastreados nunca se duplican.
727
728```text .worktreeinclude theme={null}
729.env
730.env.local
731config/secrets.json
732```
733
734Esto se aplica a worktrees creados con `--worktree`, worktrees de subagente y sesiones paralelas en la [aplicación de escritorio](/es/desktop#work-in-parallel-with-sessions).
735
736### Gestionar worktrees manualmente
737
738Para más control sobre la ubicación del worktree y la configuración de rama, cree worktrees con Git directamente. Esto es útil cuando necesita verificar una rama existente específica o colocar el worktree fuera del repositorio.
739
740```bash theme={null}
741# Crear un worktree con una nueva rama
742git worktree add ../project-feature-a -b feature-a
743
744# Crear un worktree con una rama existente
745git worktree add ../project-bugfix bugfix-123
746
747# Inicie Claude en el worktree
748cd ../project-feature-a && claude
749
750# Limpiar cuando termine
751git worktree list
752git worktree remove ../project-feature-a
753```
754
755Obtenga más información en la [documentación oficial de Git worktree](https://git-scm.com/docs/git-worktree).
756
757<Tip>
758 Recuerde inicializar su entorno de desarrollo en cada nuevo worktree de acuerdo con la configuración de su proyecto. Dependiendo de su pila, esto podría incluir ejecutar instalación de dependencias (`npm install`, `yarn`), configurar entornos virtuales o seguir el proceso de configuración estándar de su proyecto.
759</Tip>
760
761### Control de versiones no git
762
763El aislamiento de worktree funciona con git de forma predeterminada. Para otros sistemas de control de versiones como SVN, Perforce o Mercurial, configure [hooks WorktreeCreate y WorktreeRemove](/es/hooks#worktreecreate) para proporcionar lógica personalizada de creación y limpieza de worktree. Cuando se configura, estos hooks reemplazan el comportamiento predeterminado de git cuando usa `--worktree`, por lo que [`.worktreeinclude`](#copy-gitignored-files-to-worktrees) no se procesa. Copie cualquier archivo de configuración local dentro de su script de hook en su lugar.
764
765Para la coordinación automatizada de sesiones paralelas con tareas compartidas y mensajería, consulte [equipos de agentes](/es/agent-teams).
766
767***
768
769## Reciba notificaciones cuando Claude necesite su atención
770
771Cuando inicia una tarea de larga duración y cambia a otra ventana, puede configurar notificaciones de escritorio para saber cuándo Claude termina o necesita su entrada. Esto utiliza el evento de hook `Notification` [hook event](/es/hooks-guide#get-notified-when-claude-needs-input), que se activa cada vez que Claude está esperando permiso, inactivo y listo para una nueva indicación, o completando autenticación.
772
773<Steps>
774 <Step title="Agregue el hook a su configuración">
775 Abra `~/.claude/settings.json` y agregue un hook `Notification` que llame al comando de notificación nativa de su plataforma:
776
777 <Tabs>
778 <Tab title="macOS">
779 ```json theme={null}
780 {
781 "hooks": {
782 "Notification": [
783 {
784 "matcher": "",
785 "hooks": [
786 {
787 "type": "command",
788 "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"
789 }
790 ]
791 }
792 ]
793 }
794 }
795 ```
796 </Tab>
797
798 <Tab title="Linux">
799 ```json theme={null}
800 {
801 "hooks": {
802 "Notification": [
803 {
804 "matcher": "",
805 "hooks": [
806 {
807 "type": "command",
808 "command": "notify-send 'Claude Code' 'Claude Code needs your attention'"
809 }
810 ]
811 }
812 ]
813 }
814 }
815 ```
816 </Tab>
817
818 <Tab title="Windows">
819 ```json theme={null}
820 {
821 "hooks": {
822 "Notification": [
823 {
824 "matcher": "",
825 "hooks": [
826 {
827 "type": "command",
828 "command": "powershell.exe -Command \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('Claude Code needs your attention', 'Claude Code')\""
829 }
830 ]
831 }
832 ]
833 }
834 }
835 ```
836 </Tab>
837 </Tabs>
838
839 Si su archivo de configuración ya tiene una clave `hooks`, combine la entrada `Notification` en ella en lugar de sobrescribir. También puede pedir a Claude que escriba el hook por usted describiendo lo que desea en la CLI.
840 </Step>
841
842 <Step title="Opcionalmente, reduzca el matcher">
843 De forma predeterminada, el hook se activa en todos los tipos de notificación. Para activarse solo para eventos específicos, establezca el campo `matcher` en uno de estos valores:
844
845 | Matcher | Se activa cuando |
846 | :--------------------- | :---------------------------------------------------------- |
847 | `permission_prompt` | Claude necesita que apruebe un uso de herramienta |
848 | `idle_prompt` | Claude está hecho y esperando su próxima indicación |
849 | `auth_success` | La autenticación se completa |
850 | `elicitation_dialog` | Un servidor MCP abre un formulario de elicitación |
851 | `elicitation_complete` | Un formulario de elicitación de MCP se envía o se descarta |
852 | `elicitation_response` | Una respuesta de elicitación de MCP se devuelve al servidor |
853 </Step>
854
855 <Step title="Verifique el hook">
856 Escriba `/hooks` y seleccione `Notification` para confirmar que el hook aparece. Seleccionarlo muestra el comando que se ejecutará. Para probarlo de extremo a extremo, pida a Claude que ejecute un comando que requiera permiso y cambie de la terminal, o pida a Claude que active una notificación directamente.
857 </Step>
858</Steps>
859
860Para el esquema de evento completo y tipos de notificación, consulte la [referencia de Notification](/es/hooks#notification).
861
862***
863
864## Usar Claude como una utilidad de estilo unix
865
866### Agregue Claude a su proceso de verificación
867
868Supongamos que desea usar Claude Code como un linter o revisor de código.
869
870**Agregue Claude a su script de compilación:**
871
872```json theme={null}
873// package.json
874{
875 ...
876 "scripts": {
877 ...
878 "lint:claude": "claude -p 'you are a linter. please look at the changes vs. main and report any issues related to typos. report the filename and line number on one line, and a description of the issue on the second line. do not return any other text.'"
879 }
880}
881```
882
883<Tip>
884 Consejos:
885
886 * Use Claude para revisión de código automatizada en su canalización CI/CD
887 * Personalice la indicación para verificar problemas específicos relevantes para su proyecto
888 * Considere crear múltiples scripts para diferentes tipos de verificación
889</Tip>
890
891### Canalizar entrada, canalizar salida
892
893Supongamos que desea canalizar datos a Claude y obtener datos en un formato estructurado.
894
895**Canalizar datos a través de Claude:**
896
897```bash theme={null}
898cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt
899```
900
901<Tip>
902 Consejos:
903
904 * Use tuberías para integrar Claude en scripts de shell existentes
905 * Combine con otras herramientas Unix para flujos de trabajo poderosos
906 * Considere usar `--output-format` para salida estructurada
907</Tip>
908
909### Controlar el formato de salida
910
911Supongamos que necesita la salida de Claude en un formato específico, especialmente cuando integra Claude Code en scripts u otras herramientas.
912
913<Steps>
914 <Step title="Usar formato de texto (predeterminado)">
915 ```bash theme={null}
916 cat data.txt | claude -p 'summarize this data' --output-format text > summary.txt
917 ```
918
919 Esto genera solo la respuesta de texto sin formato de Claude (comportamiento predeterminado).
920 </Step>
921
922 <Step title="Usar formato JSON">
923 ```bash theme={null}
924 cat code.py | claude -p 'analyze this code for bugs' --output-format json > analysis.json
925 ```
926
927 Esto genera una matriz JSON de mensajes con metadatos incluidos costo y duración.
928 </Step>
929
930 <Step title="Usar formato JSON de transmisión">
931 ```bash theme={null}
932 cat log.txt | claude -p 'parse this log file for errors' --output-format stream-json
933 ```
934
935 Esto genera una serie de objetos JSON en tiempo real mientras Claude procesa la solicitud. Cada mensaje es un objeto JSON válido, pero la salida completa no es JSON válido si se concatena.
936 </Step>
937</Steps>
938
939<Tip>
940 Consejos:
941
942 * Use `--output-format text` para integraciones simples donde solo necesita la respuesta de Claude
943 * Use `--output-format json` cuando necesite el registro de conversación completo
944 * Use `--output-format stream-json` para salida en tiempo real de cada turno de conversación
945</Tip>
946
947***
948
949## Ejecutar Claude en un horario
950 396
951Supongamos que desea que Claude maneje una tarea automáticamente de forma recurrente, como revisar PRs abiertas cada mañana, auditar dependencias semanalmente o verificar fallas de CI durante la noche.397Supongamos que desea que Claude maneje una tarea automáticamente de forma recurrente, como revisar PRs abiertas cada mañana, auditar dependencias semanalmente o verificar fallas de CI durante la noche.
952 398
965 411
966***412***
967 413
968## Pregunte a Claude sobre sus capacidades414### Pregunte a Claude sobre sus capacidades
969 415
970Claude tiene acceso integrado a su documentación y puede responder preguntas sobre sus propias características y limitaciones.416Claude tiene acceso integrado a su documentación y puede responder preguntas sobre sus propias características y limitaciones.
971 417
972### Preguntas de ejemplo418#### Preguntas de ejemplo
973 419
974```text theme={null}420```text theme={null}
975¿puede Claude Code crear solicitudes de extracción?421¿puede Claude Code crear solicitudes de extracción?
1009 455
1010***456***
1011 457
458## Reanudar conversaciones anteriores
459
460Cuando una tarea abarca múltiples sesiones, continúe donde lo dejó en lugar de volver a explicar el contexto. Claude Code guarda cada conversación localmente.
461
462```bash theme={null}
463claude --continue
464```
465
466Esto reanuda la sesión más reciente en el directorio actual; si aún no existe una, imprime `No conversation found to continue` y sale. Use `claude --resume` para elegir de una lista, o `/resume` desde dentro de una sesión en ejecución. Consulte [Gestionar sesiones](/es/sessions) para nombrar, ramificar y la referencia completa del selector.
467
468## Ejecutar sesiones paralelas con worktrees
469
470Trabaje en una característica en una terminal mientras Claude corrige un error en otra, sin que los cambios choquen. Cada worktree es un checkout separado en su propia rama.
471
472```bash theme={null}
473claude --worktree feature-auth
474```
475
476Ejecute el mismo comando con un nombre diferente en una segunda terminal para iniciar una sesión paralela aislada. Consulte [Worktrees](/es/worktrees) para limpieza, `.worktreeinclude` y soporte de VCS que no sea git. Para monitorear sesiones paralelas desde una pantalla en lugar de terminales separadas, consulte [agentes de fondo](/es/agent-view).
477
478## Planificar antes de editar
479
480Para cambios que desea revisar antes de que toquen el disco, cambie al modo de plan. Claude lee archivos y propone un plan pero no realiza ediciones hasta que apruebe.
481
482```bash theme={null}
483claude --permission-mode plan
484```
485
486También puede presionar `Shift+Tab` durante una sesión para cambiar al modo de plan. Consulte [Plan mode](/es/permission-modes#analyze-before-you-edit-with-plan-mode) para el flujo de aprobación y editar el plan en su editor de texto.
487
488## Delegar investigación a subagentes
489
490Explorar una base de código grande llena su contexto con lecturas de archivos. Delegue la exploración para que solo los hallazgos regresen.
491
492```text theme={null}
493usa un subagente para investigar cómo nuestro sistema de autenticación maneja la actualización de tokens
494```
495
496El subagente lee archivos en su propia ventana de contexto e informa un resumen. Consulte [Subagentes](/es/sub-agents) para definir agentes personalizados con sus propias herramientas e indicaciones.
497
498## Canalizar Claude en scripts
499
500Ejecute Claude de forma no interactiva para CI, hooks de pre-commit o procesamiento por lotes. Stdin y stdout funcionan como cualquier herramienta Unix.
501
502```bash theme={null}
503git log --oneline -20 | claude -p "summarize these recent commits"
504```
505
506Consulte [Modo no interactivo](/es/headless) para formatos de salida, banderas de permiso y patrones de distribución.
507
1012## Próximos pasos508## Próximos pasos
1013 509
1014<CardGroup cols={2}>510<CardGroup cols={2}>
1016 Patrones para obtener lo máximo de Claude Code512 Patrones para obtener lo máximo de Claude Code
1017 </Card>513 </Card>
1018 514
1019 <Card title="Cómo funciona Claude Code" icon="gear" href="/es/how-claude-code-works">515 <Card title="Gestionar sesiones" icon="rotate-left" href="/es/sessions">
1020 Comprenda el bucle agente y la gestión de contexto516 Reanudar, nombrar y ramificar conversaciones
1021 </Card>517 </Card>
1022 518
1023 <Card title="Extender Claude Code" icon="puzzle-piece" href="/es/features-overview">519 <Card title="Worktrees" icon="code-branch" href="/es/worktrees">
1024 Agregue skills, hooks, MCP, subagentes y plugins520 Ejecutar sesiones paralelas aisladas
1025 </Card>521 </Card>
1026 522
1027 <Card title="Implementación de referencia" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">523 <Card title="Extender Claude Code" icon="puzzle-piece" href="/es/features-overview">
1028 Clone la implementación de referencia del contenedor de desarrollo524 Agregar skills, hooks, MCP, subagentes y plugins
1029 </Card>525 </Card>
1030</CardGroup>526</CardGroup>
