1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Flujos de trabajo comunes

6 

7> Guías paso a paso para explorar bases de código, corregir errores, refactorizar, probar y otras tareas cotidianas con Claude Code.

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).

10 

11## Comprender nuevas bases de código

12 

13### Obtener una descripción general rápida de la base de código

14 

15Supongamos que acaba de unirse a un nuevo proyecto y necesita comprender su estructura rápidamente.

16 

17<Steps>

18 <Step title="Navegue al directorio raíz del proyecto">

19 ```bash theme={null}

20 cd /path/to/project

21 ```

22 </Step>

23 

24 <Step title="Inicie Claude Code">

25 ```bash theme={null}

26 claude

27 ```

28 </Step>

29 

30 <Step title="Solicite una descripción general de alto nivel">

31 ```text theme={null}

32 dame una descripción general de esta base de código

33 ```

34 </Step>

35 

36 <Step title="Profundice en componentes específicos">

37 ```text theme={null}

38 explica los patrones de arquitectura principales utilizados aquí

39 ```

40 

41 ```text theme={null}

42 ¿cuáles son los modelos de datos clave?

43 ```

44 

45 ```text theme={null}

46 ¿cómo se maneja la autenticación?

47 ```

48 </Step>

49</Steps>

50 

51<Tip>

52 Consejos:

53 

54 * Comience con preguntas amplias, luego reduzca a áreas específicas

55 * Pregunte sobre convenciones de codificación y patrones utilizados en el proyecto

56 * Solicite un glosario de términos específicos del proyecto

57</Tip>

58 

59### Encontrar código relevante

60 

61Supongamos que necesita localizar código relacionado con una característica o funcionalidad específica.

62 

63<Steps>

64 <Step title="Pida a Claude que encuentre archivos relevantes">

65 ```text theme={null}

66 encuentra los archivos que manejan la autenticación de usuarios

67 ```

68 </Step>

69 

70 <Step title="Obtenga contexto sobre cómo interactúan los componentes">

71 ```text theme={null}

72 ¿cómo funcionan juntos estos archivos de autenticación?

73 ```

74 </Step>

75 

76 <Step title="Comprenda el flujo de ejecución">

77 ```text theme={null}

78 rastrear el proceso de inicio de sesión de front-end a base de datos

79 ```

80 </Step>

81</Steps>

82 

83<Tip>

84 Consejos:

85 

86 * Sea específico sobre lo que está buscando

87 * Utilice el lenguaje del dominio del proyecto

88 * Instale un [plugin de inteligencia de código](/es/discover-plugins#code-intelligence) para su lenguaje para dar a Claude una navegación precisa de "ir a definición" y "buscar referencias"

89</Tip>

90 

91***

92 

93## Corregir errores de manera eficiente

94 

95Supongamos que ha encontrado un mensaje de error y necesita encontrar y corregir su origen.

96 

97<Steps>

98 <Step title="Comparta el error con Claude">

99 ```text theme={null}

100 estoy viendo un error cuando ejecuto npm test

101 ```

102 </Step>

103 

104 <Step title="Solicite recomendaciones de corrección">

105 ```text theme={null}

106 sugiere algunas formas de corregir el @ts-ignore en user.ts

107 ```

108 </Step>

109 

110 <Step title="Aplique la corrección">

111 ```text theme={null}

112 actualiza user.ts para agregar la verificación nula que sugeriste

113 ```

114 </Step>

115</Steps>

116 

117<Tip>

118 Consejos:

119 

120 * Dígale a Claude el comando para reproducir el problema y obtener un seguimiento de pila

121 * Mencione cualquier paso para reproducir el error

122 * Hágale saber a Claude si el error es intermitente o consistente

123</Tip>

124 

125***

126 

127## Refactorizar código

128 

129Supongamos que necesita actualizar código antiguo para utilizar patrones y prácticas modernas.

130 

131<Steps>

132 <Step title="Identifique código heredado para refactorización">

133 ```text theme={null}

134 encuentra el uso de API obsoleta en nuestra base de código

135 ```

136 </Step>

137 

138 <Step title="Obtenga recomendaciones de refactorización">

139 ```text theme={null}

140 sugiere cómo refactorizar utils.js para usar características modernas de JavaScript

141 ```

142 </Step>

143 

144 <Step title="Aplique los cambios de manera segura">

145 ```text theme={null}

146 refactoriza utils.js para usar características de ES2024 manteniendo el mismo comportamiento

147 ```

148 </Step>

149 

150 <Step title="Verifique la refactorización">

151 ```text theme={null}

152 ejecuta pruebas para el código refactorizado

153 ```

154 </Step>

155</Steps>

156 

157<Tip>

158 Consejos:

159 

160 * Pida a Claude que explique los beneficios del enfoque moderno

161 * Solicite que los cambios mantengan la compatibilidad hacia atrás cuando sea necesario

162 * Realice la refactorización en incrementos pequeños y comprobables

163</Tip>

164 

165***

166 

167## Usar subagentes especializados

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 

302Supongamos que necesita agregar pruebas para código no cubierto.

303 

304<Steps>

305 <Step title="Identifique código no probado">

306 ```text theme={null}

307 encuentra funciones en NotificationsService.swift que no están cubiertas por pruebas

308 ```

309 </Step>

310 

311 <Step title="Genere andamiaje de prueba">

312 ```text theme={null}

313 agrega pruebas para el servicio de notificaciones

314 ```

315 </Step>

316 

317 <Step title="Agregue casos de prueba significativos">

318 ```text theme={null}

319 agrega casos de prueba para condiciones de borde en el servicio de notificaciones

320 ```

321 </Step>

322 

323 <Step title="Ejecute y verifique las pruebas">

324 ```text theme={null}

325 ejecuta las nuevas pruebas y corrige cualquier fallo

326 ```

327 </Step>

328</Steps>

329 

330Claude puede generar pruebas que sigan los patrones y convenciones existentes de su proyecto. Al solicitar pruebas, sea específico sobre qué comportamiento desea verificar. Claude examina sus archivos de prueba existentes para coincidir con el estilo, marcos y patrones de afirmación ya en uso.

331 

332Para una cobertura integral, pida a Claude que identifique casos extremos que podría haber perdido. Claude puede analizar sus rutas de código y sugerir pruebas para condiciones de error, valores límite e entradas inesperadas que son fáciles de pasar por alto.

333 

334***

335 

336## Crear solicitudes de extracción

337 

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:

339 

340<Steps>

341 <Step title="Resuma sus cambios">

342 ```text theme={null}

343 resume los cambios que he hecho en el módulo de autenticación

344 ```

345 </Step>

346 

347 <Step title="Genere una solicitud de extracción">

348 ```text theme={null}

349 crear una pr

350 ```

351 </Step>

352 

353 <Step title="Revise y refine">

354 ```text theme={null}

355 mejora la descripción de la PR con más contexto sobre las mejoras de seguridad

356 ```

357 </Step>

358</Steps>

359 

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

361 

362<Tip>

363 Revise la PR generada por Claude antes de enviarla y pida a Claude que destaque los riesgos potenciales o consideraciones.

364</Tip>

365 

366## Manejar documentación

367 

368Supongamos que necesita agregar o actualizar documentación para su código.

369 

370<Steps>

371 <Step title="Identifique código sin documentar">

372 ```text theme={null}

373 encuentra funciones sin comentarios JSDoc adecuados en el módulo de autenticación

374 ```

375 </Step>

376 

377 <Step title="Genere documentación">

378 ```text theme={null}

379 agrega comentarios JSDoc a las funciones sin documentar en auth.js

380 ```

381 </Step>

382 

383 <Step title="Revise y mejore">

384 ```text theme={null}

385 mejora la documentación generada con más contexto y ejemplos

386 ```

387 </Step>

388 

389 <Step title="Verifique la documentación">

390 ```text theme={null}

391 verifica si la documentación sigue nuestros estándares de proyecto

392 ```

393 </Step>

394</Steps>

395 

396<Tip>

397 Consejos:

398 

399 * Especifique el estilo de documentación que desea (JSDoc, docstrings, etc.)

400 * Solicite ejemplos en la documentación

401 * Solicite documentación para API públicas, interfaces y lógica compleja

402</Tip>

403 

404***

405 

406## Trabajar en notas y carpetas que no son código

407 

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.

409 

410El directorio `.claude/` y `CLAUDE.md` se encuentran junto a los directorios de configuración de otras herramientas sin conflicto. Claude lee archivos nuevos en cada llamada de herramienta, por lo que ve las ediciones que realiza en otra aplicación la próxima vez que lee ese archivo.

411 

412***

413 

414## Trabajar con imágenes

415 

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.

417 

418<Steps>

419 <Step title="Agregue una imagen a la conversación">

420 Puede usar cualquiera de estos métodos:

421 

422 1. Arrastre y suelte una imagen en la ventana de Claude Code

423 2. Copie una imagen y péguela en la CLI con ctrl+v (No use cmd+v)

424 3. Proporcione una ruta de imagen a Claude. Por ejemplo, "Analiza esta imagen: /path/to/your/image.png"

425 </Step>

426 

427 <Step title="Pida a Claude que analice la imagen">

428 ```text theme={null}

429 ¿Qué muestra esta imagen?

430 ```

431 

432 ```text theme={null}

433 Describe los elementos de la interfaz de usuario en esta captura de pantalla

434 ```

435 

436 ```text theme={null}

437 ¿Hay algún elemento problemático en este diagrama?

438 ```

439 </Step>

440 

441 <Step title="Usar imágenes para contexto">

442 ```text theme={null}

443 Aquí hay una captura de pantalla del error. ¿Qué lo está causando?

444 ```

445 

446 ```text theme={null}

447 Este es nuestro esquema de base de datos actual. ¿Cómo deberíamos modificarlo para la nueva característica?

448 ```

449 </Step>

450 

451 <Step title="Obtenga sugerencias de código del contenido visual">

452 ```text theme={null}

453 Generar CSS para coincidir con este mockup de diseño

454 ```

455 

456 ```text theme={null}

457 ¿Qué estructura HTML recrearía este componente?

458 ```

459 </Step>

460</Steps>

461 

462<Tip>

463 Consejos:

464 

465 * Use imágenes cuando las descripciones de texto serían poco claras o engorrosas

466 * Incluya capturas de pantalla de errores, diseños de interfaz de usuario o diagramas para mejor contexto

467 * Puede trabajar con múltiples imágenes en una conversación

468 * El análisis de imágenes funciona con diagramas, capturas de pantalla, mockups y más

469 * Cuando Claude hace referencia a imágenes (por ejemplo, `[Image #1]`), `Cmd+Click` (Mac) o `Ctrl+Click` (Windows/Linux) el enlace para abrir la imagen en su visor predeterminado

470</Tip>

471 

472***

473 

474## Archivos y directorios de referencia

475 

476Use @ para incluir rápidamente archivos o directorios sin esperar a que Claude los lea.

477 

478<Steps>

479 <Step title="Haga referencia a un archivo único">

480 ```text theme={null}

481 Explica la lógica en @src/utils/auth.js

482 ```

483 

484 Esto incluye el contenido completo del archivo en la conversación.

485 </Step>

486 

487 <Step title="Haga referencia a un directorio">

488 ```text theme={null}

489 ¿Cuál es la estructura de @src/components?

490 ```

491 

492 Esto proporciona un listado de directorio con información de archivo.

493 </Step>

494 

495 <Step title="Haga referencia a recursos MCP">

496 ```text theme={null}

497 Muéstrame los datos de @github:repos/owner/repo/issues

498 ```

499 

500 Esto obtiene datos de servidores MCP conectados usando el formato @server:resource. Consulte [recursos MCP](/es/mcp#use-mcp-resources) para más detalles.

501 </Step>

502</Steps>

503 

504<Tip>

505 Consejos:

506 

507 * Las rutas de archivo pueden ser relativas o absolutas

508 * Las referencias de archivo @ agregan `CLAUDE.md` en el directorio del archivo y directorios principales al contexto

509 * Las referencias de directorio muestran listados de archivos, no contenidos

510 * Puede hacer referencia a múltiples archivos en un solo mensaje (por ejemplo, "@file1.js y @file2.js")

511</Tip>

512 

513***

514 

515## Usar pensamiento extendido (Thinking Mode)

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 

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.

952 

953Elija una opción de programación según dónde desee que se ejecute la tarea:

954 

955| Opción | Dónde se ejecuta | Mejor para |

956| :-------------------------------------------------------------- | :-------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

957| [Routines](/es/routines) | Infraestructura administrada por Anthropic | Tareas que deben ejecutarse incluso cuando su computadora está apagada. También puede activarse en llamadas API o eventos de GitHub además de un horario. Configure en [claude.ai/code/routines](https://claude.ai/code/routines). |

958| [Tareas programadas de escritorio](/es/desktop-scheduled-tasks) | Su máquina, a través de la aplicación de escritorio | Tareas que necesitan acceso directo a archivos locales, herramientas o cambios sin confirmar. |

959| [GitHub Actions](/es/github-actions) | Su canalización de CI | Tareas vinculadas a eventos de repositorio como PRs abiertos, o horarios cron que deben vivir junto con su configuración de flujo de trabajo. |

960| [`/loop`](/es/scheduled-tasks) | La sesión CLI actual | Sondeo rápido mientras una sesión está abierta. Las tareas se cancelan cuando comienza una nueva conversación; `--resume` y `--continue` restauran las no expiradas. |

961 

962<Tip>

963 Al escribir indicaciones para tareas programadas, sea explícito sobre qué se ve como éxito y qué hacer con los resultados. La tarea se ejecuta de forma autónoma, por lo que no puede hacer preguntas aclaratorias. Por ejemplo: "Revise PRs abiertas etiquetadas con `needs-review`, deje comentarios en línea sobre cualquier problema y publique un resumen en el canal `#eng-reviews` de Slack."

964</Tip>

965 

966***

967 

968## Pregunte a Claude sobre sus capacidades

969 

970Claude tiene acceso integrado a su documentación y puede responder preguntas sobre sus propias características y limitaciones.

971 

972### Preguntas de ejemplo

973 

974```text theme={null}

975¿puede Claude Code crear solicitudes de extracción?

976```

977 

978```text theme={null}

979¿cómo maneja Claude Code los permisos?

980```

981 

982```text theme={null}

983¿qué skills están disponibles?

984```

985 

986```text theme={null}

987¿cómo uso MCP con Claude Code?

988```

989 

990```text theme={null}

991¿cómo configuro Claude Code para Amazon Bedrock?

992```

993 

994```text theme={null}

995¿cuáles son las limitaciones de Claude Code?

996```

997 

998<Note>

999 Claude proporciona respuestas basadas en documentación a estas preguntas. Para demostraciones prácticas, ejecute `/powerup` para lecciones interactivas con demostraciones animadas, o consulte las secciones de flujo de trabajo específicas anteriores.

1000</Note>

1001 

1002<Tip>

1003 Consejos:

1004 

1005 * Claude siempre tiene acceso a la documentación más reciente de Claude Code, independientemente de la versión que esté utilizando

1006 * Haga preguntas específicas para obtener respuestas detalladas

1007 * Claude puede explicar características complejas como integración MCP, configuraciones empresariales y flujos de trabajo avanzados

1008</Tip>

1009 

1010***

1011 

1012## Próximos pasos

1013 

1014<CardGroup cols={2}>

1015 <Card title="Mejores prácticas" icon="lightbulb" href="/es/best-practices">

1016 Patrones para obtener lo máximo de Claude Code

1017 </Card>

1018 

1019 <Card title="Cómo funciona Claude Code" icon="gear" href="/es/how-claude-code-works">

1020 Comprenda el bucle agente y la gestión de contexto

1021 </Card>

1022 

1023 <Card title="Extender Claude Code" icon="puzzle-piece" href="/es/features-overview">

1024 Agregue skills, hooks, MCP, subagentes y plugins

1025 </Card>

1026 

1027 <Card title="Implementación de referencia" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">

1028 Clone la implementación de referencia del contenedor de desarrollo

1029 </Card>

1030</CardGroup>