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>