Saltar al contenido principal
Cada tarea en este documento incluye instrucciones claras, comandos de ejemplo y mejores prácticas para ayudarte a obtener el máximo provecho de Claude Code.

​
Comprender nuevas bases de código

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

Supongamos que acabas de unirte a un nuevo proyecto y necesitas comprender su estructura rápidamente.
1

Navega al directorio raíz del proyecto

cd /path/to/project
2

Inicia Claude Code

claude
3

Solicita una descripción general de alto nivel

> give me an overview of this codebase
4

Profundiza en componentes específicos

> explain the main architecture patterns used here 

> what are the key data models?

> how is authentication handled?
Consejos:
  • Comienza con preguntas amplias, luego reduce a áreas específicas
  • Pregunta sobre convenciones de codificación y patrones utilizados en el proyecto
  • Solicita un glosario de términos específicos del proyecto

​
Encontrar código relevante

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

Pide a Claude que encuentre archivos relevantes

> find the files that handle user authentication
2

Obtén contexto sobre cómo interactúan los componentes

> how do these authentication files work together?
3

Comprende el flujo de ejecución

> trace the login process from front-end to database
Consejos:
  • Sé específico sobre lo que estás buscando
  • Utiliza lenguaje de dominio del proyecto

​
Corregir errores de manera eficiente

Supongamos que has encontrado un mensaje de error y necesitas encontrar y corregir su origen.
1

Comparte el error con Claude

> I'm seeing an error when I run npm test
2

Solicita recomendaciones de corrección

> suggest a few ways to fix the @ts-ignore in user.ts
3

Aplica la corrección

> update user.ts to add the null check you suggested
Consejos:
  • Dile a Claude el comando para reproducir el problema y obtener un seguimiento de pila
  • Menciona cualquier paso para reproducir el error
  • Hazle saber a Claude si el error es intermitente o consistente

​
Refactorizar código

Supongamos que necesitas actualizar código antiguo para usar patrones y prácticas modernas.
1

Identifica código heredado para refactorización

> find deprecated API usage in our codebase
2

Obtén recomendaciones de refactorización

> suggest how to refactor utils.js to use modern JavaScript features
3

Aplica los cambios de manera segura

> refactor utils.js to use ES2024 features while maintaining the same behavior
4

Verifica la refactorización

> run tests for the refactored code
Consejos:
  • Pide a Claude que explique los beneficios del enfoque moderno
  • Solicita que los cambios mantengan compatibilidad hacia atrás cuando sea necesario
  • Realiza la refactorización en incrementos pequeños y comprobables

​
Usar subagentes especializados

Supongamos que deseas usar subagentes de IA especializados para manejar tareas específicas de manera más efectiva.
1

Ver subagentes disponibles

> /agents
Esto muestra todos los subagentes disponibles y te permite crear otros nuevos.
2

Usar subagentes automáticamente

Claude Code delegará automáticamente tareas apropiadas a subagentes especializados:
> review my recent code changes for security issues

> run all tests and fix any failures
3

Solicitar explícitamente subagentes específicos

> use the code-reviewer subagent to check the auth module

> have the debugger subagent investigate why users can't log in
4

Crear subagentes personalizados para tu flujo de trabajo

> /agents
Luego selecciona “Create New subagent” y sigue las indicaciones para definir:
  • Tipo de subagente (por ejemplo, api-designer, performance-optimizer)
  • Cuándo usarlo
  • Qué herramientas puede acceder
  • Su indicación de sistema especializada
Consejos:
  • Crea subagentes específicos del proyecto en .claude/agents/ para compartir con el equipo
  • Usa campos description descriptivos para habilitar delegación automática
  • Limita el acceso a herramientas a lo que cada subagente realmente necesita
  • Consulta la documentación de subagentes para ejemplos detallados

​
Usar Plan Mode para análisis seguro de código

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

​
Cuándo usar Plan Mode

  • Implementación de múltiples pasos: Cuando tu característica requiere hacer ediciones en muchos archivos
  • Exploración de código: Cuando deseas investigar la base de código a fondo antes de cambiar nada
  • Desarrollo interactivo: Cuando deseas iterar sobre la dirección con Claude

​
Cómo usar Plan Mode

Activar Plan Mode durante una sesión Puedes cambiar a Plan Mode durante una sesión usando Shift+Tab para ciclar a través de modos de permisos. Si estás en Normal Mode, Shift+Tab primero cambiará 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. Iniciar una nueva sesión en Plan Mode Para iniciar una nueva sesión en Plan Mode, usa la bandera --permission-mode plan: 
claude --permission-mode plan
Ejecutar consultas “headless” en Plan Mode También puedes ejecutar una consulta en Plan Mode directamente con -p (es decir, en “modo headless”): 
claude --permission-mode plan -p "Analyze the authentication system and suggest improvements"

​
Ejemplo: Planificar una refactorización compleja

claude --permission-mode plan

> I need to refactor our authentication system to use OAuth2. Create a detailed migration plan.
Claude analizará la implementación actual y creará un plan integral. Refina con seguimientos: 
> What about backward compatibility?
> How should we handle database migration?

​
Configurar Plan Mode como predeterminado

// .claude/settings.json
{
  "permissions": {
    "defaultMode": "plan"
  }
}
Consulta la documentación de configuración para más opciones de configuración.

​
Trabajar con pruebas

Supongamos que necesitas agregar pruebas para código no cubierto.
1

Identifica código sin pruebas

> find functions in NotificationsService.swift that are not covered by tests
2

Genera andamiaje de pruebas

> add tests for the notification service
3

Agrega casos de prueba significativos

> add test cases for edge conditions in the notification service
4

Ejecuta y verifica pruebas

> run the new tests and fix any failures
Consejos:
  • Solicita pruebas que cubran casos extremos y condiciones de error
  • Solicita pruebas unitarias e integración cuando sea apropiado
  • Pide a Claude que explique la estrategia de pruebas

​
Crear solicitudes de extracción

Supongamos que necesitas crear una solicitud de extracción bien documentada para tus cambios.
1

Resume tus cambios

> summarize the changes I've made to the authentication module
2

Genera un PR con Claude

> create a pr
3

Revisa y refina

> enhance the PR description with more context about the security improvements
4

Agrega detalles de pruebas

> add information about how these changes were tested
Consejos:
  • Pide a Claude directamente que haga un PR para ti
  • Revisa el PR generado por Claude antes de enviarlo
  • Pide a Claude que destaque riesgos potenciales o consideraciones

​
Manejar documentación

Supongamos que necesitas agregar o actualizar documentación para tu código.
1

Identifica código sin documentar

> find functions without proper JSDoc comments in the auth module
2

Genera documentación

> add JSDoc comments to the undocumented functions in auth.js
3

Revisa y mejora

> improve the generated documentation with more context and examples
4

Verifica documentación

> check if the documentation follows our project standards
Consejos:
  • Especifica el estilo de documentación que deseas (JSDoc, docstrings, etc.)
  • Solicita ejemplos en la documentación
  • Solicita documentación para APIs públicas, interfaces y lógica compleja

​
Trabajar con imágenes

Supongamos que necesitas trabajar con imágenes en tu base de código y deseas la ayuda de Claude para analizar el contenido de la imagen.
1

Agrega una imagen a la conversación

Puedes usar cualquiera de estos métodos:
  1. Arrastra y suelta una imagen en la ventana de Claude Code
  2. Copia una imagen y pégala en la CLI con ctrl+v (No uses cmd+v)
  3. Proporciona una ruta de imagen a Claude. Por ejemplo, “Analyze this image: /path/to/your/image.png”
2

Pide a Claude que analice la imagen

> What does this image show?

> Describe the UI elements in this screenshot

> Are there any problematic elements in this diagram?
3

Usa imágenes para contexto

> Here's a screenshot of the error. What's causing it?

> This is our current database schema. How should we modify it for the new feature?
4

Obtén sugerencias de código del contenido visual

> Generate CSS to match this design mockup

> What HTML structure would recreate this component?
Consejos:
  • Usa imágenes cuando las descripciones de texto serían poco claras o engorrosas
  • Incluye capturas de pantalla de errores, diseños de UI o diagramas para mejor contexto
  • Puedes trabajar con múltiples imágenes en una conversación
  • El análisis de imágenes funciona con diagramas, capturas de pantalla, maquetas y más

​
Referenciar archivos y directorios

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

Referencia un archivo único

> Explain the logic in @src/utils/auth.js
Esto incluye el contenido completo del archivo en la conversación.
2

Referencia un directorio

> What's the structure of @src/components?
Esto proporciona un listado de directorio con información de archivos.
3

Referencia recursos MCP

> Show me the data from @github:repos/owner/repo/issues
Esto obtiene datos de servidores MCP conectados usando el formato @server:resource. Consulta recursos MCP para detalles.
Consejos:
  • Las rutas de archivo pueden ser relativas o absolutas
  • Las referencias de archivo @ agregan CLAUDE.md en el directorio del archivo y directorios padre al contexto
  • Las referencias de directorio muestran listados de archivos, no contenidos
  • Puedes referenciar múltiples archivos en un único mensaje (por ejemplo, “@file1.js and @file2.js”)

​
Usar pensamiento extendido

Supongamos que estás trabajando en decisiones arquitectónicas complejas, errores desafiantes o planificando implementaciones de múltiples pasos que requieren razonamiento profundo.
El pensamiento extendido está deshabilitado por defecto en Claude Code. Puedes habilitarlo bajo demanda usando Tab para alternar Thinking, o usando indicaciones como “think” o “think hard”. También puedes habilitarlo permanentemente configurando la variable de entorno MAX_THINKING_TOKENS en tu configuración.
1

Proporciona contexto y pide a Claude que piense

> I need to implement a new authentication system using OAuth2 for our API. Think deeply about the best approach for implementing this in our codebase.
Claude reunirá información relevante de tu base de código y usará pensamiento extendido, que será visible en la interfaz.
2

Refina el pensamiento con indicaciones de seguimiento

> think about potential security vulnerabilities in this approach 

> think hard about edge cases we should handle
Consejos para obtener el máximo valor del pensamiento extendido:El pensamiento extendido es más valioso para tareas complejas tales como:
  • Planificar cambios arquitectónicos complejos
  • Depurar problemas intrincados
  • Crear planes de implementación para nuevas características
  • Comprender bases de código complejas
  • Evaluar compensaciones entre diferentes enfoques
Usa Tab para alternar Thinking activado y desactivado durante una sesión.La forma en que solicitas resultados de pensamiento resulta en niveles variados de profundidad de pensamiento:
  • “think” activa pensamiento extendido básico
  • intensificar frases tales como “keep hard”, “think more”, “think a lot”, o “think longer” activa pensamiento más profundo
Para más consejos de indicación de pensamiento extendido, consulta Consejos de pensamiento extendido.
Claude mostrará su proceso de pensamiento como texto gris en cursiva encima de la respuesta.

​
Reanudar conversaciones anteriores

Supongamos que has estado trabajando en una tarea con Claude Code y necesitas continuar donde lo dejaste en una sesión posterior. Claude Code proporciona dos opciones para reanudar conversaciones anteriores:
  • --continue para continuar automáticamente la conversación más reciente
  • --resume para mostrar un selector de conversación
1

Continúa la conversación más reciente

claude --continue
Esto reanuda inmediatamente tu conversación más reciente sin ningún aviso.
2

Continúa en modo no interactivo

claude --continue --print "Continue with my task"
Usa --print con --continue para reanudar la conversación más reciente en modo no interactivo, perfecto para scripts o automatización.
3

Mostrar selector de conversación

claude --resume
Esto muestra un selector de conversación interactivo con una vista de lista limpia mostrando:
  • Resumen de sesión (o indicación inicial)
  • Metadatos: tiempo transcurrido, conteo de mensajes y rama git
Usa las teclas de flecha para navegar y presiona Enter para seleccionar una conversación. Presiona Esc para salir.
Consejos:
  • El historial de conversación se almacena localmente en tu máquina
  • Usa --continue para acceso rápido a tu conversación más reciente
  • Usa --resume cuando necesites seleccionar una conversación pasada específica
  • Al reanudar, verás todo el historial de conversación antes de continuar
  • La conversación reanudada comienza con el mismo modelo y configuración que el original
Cómo funciona:
  1. Almacenamiento de conversación: Todas las conversaciones se guardan automáticamente localmente con su historial de mensajes completo
  2. Deserialización de mensajes: Al reanudar, todo el historial de mensajes se restaura para mantener el contexto
  3. Estado de herramientas: El uso de herramientas y resultados de la conversación anterior se preservan
  4. Restauración de contexto: La conversación se reanuda con todo el contexto anterior intacto
Ejemplos:
# Continúa la conversación más reciente
claude --continue

# Continúa la conversación más reciente con una indicación específica
claude --continue --print "Show me our progress"

# Mostrar selector de conversación
claude --resume

# Continúa la conversación más reciente en modo no interactivo
claude --continue --print "Run the tests again"

​
Ejecutar sesiones paralelas de Claude Code con Git worktrees

Supongamos que necesitas trabajar en múltiples tareas simultáneamente con aislamiento completo de código entre instancias de Claude Code.
1

Comprende Git worktrees

Los worktrees de Git te permiten verificar múltiples ramas del mismo repositorio en directorios separados. Cada worktree tiene su propio directorio de trabajo con archivos aislados, mientras comparte el mismo historial de Git. Aprende más en la documentación oficial de Git worktree.
2

Crea un nuevo worktree

# Crea un nuevo worktree con una rama nueva 
git worktree add ../project-feature-a -b feature-a

# O crea un worktree con una rama existente
git worktree add ../project-bugfix bugfix-123
Esto crea un nuevo directorio con una copia de trabajo separada de tu repositorio.
3

Ejecuta Claude Code en cada worktree

# Navega a tu worktree 
cd ../project-feature-a

# Ejecuta Claude Code en este entorno aislado
claude
4

Ejecuta Claude en otro worktree

cd ../project-bugfix
claude
5

Gestiona tus worktrees

# Lista todos los worktrees
git worktree list

# Elimina un worktree cuando hayas terminado
git worktree remove ../project-feature-a
Consejos:
  • Cada worktree tiene su propio estado de archivo independiente, lo que lo hace perfecto para sesiones paralelas de Claude Code
  • Los cambios realizados en un worktree no afectarán a otros, evitando que las instancias de Claude interfieran entre sí
  • Todos los worktrees comparten el mismo historial de Git y conexiones remotas
  • Para tareas de larga duración, puedes tener a Claude trabajando en un worktree mientras continúas el desarrollo en otro
  • Usa nombres de directorio descriptivos para identificar fácilmente para qué tarea es cada worktree
  • Recuerda inicializar tu entorno de desarrollo en cada nuevo worktree de acuerdo con la configuración de tu proyecto. Dependiendo de tu stack, esto podría incluir:
    • Proyectos JavaScript: Ejecutar instalación de dependencias (npm install, yarn)
    • Proyectos Python: Configurar entornos virtuales o instalar con gestores de paquetes
    • Otros lenguajes: Seguir el proceso de configuración estándar de tu proyecto

​
Usar Claude como una utilidad de estilo unix

​
Agrega Claude a tu proceso de verificación

Supongamos que deseas usar Claude Code como un linter o revisor de código. Agrega Claude a tu script de compilación: 
// package.json
{
    ...
    "scripts": {
        ...
        "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.'"
    }
}
Consejos:
  • Usa Claude para revisión de código automatizada en tu pipeline de CI/CD
  • Personaliza la indicación para verificar problemas específicos relevantes para tu proyecto
  • Considera crear múltiples scripts para diferentes tipos de verificación

​
Canalizar entrada, canalizar salida

Supongamos que deseas canalizar datos a Claude y obtener datos en un formato estructurado. Canaliza datos a través de Claude: 
cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt
Consejos:
  • Usa canalizaciones para integrar Claude en scripts de shell existentes
  • Combina con otras herramientas Unix para flujos de trabajo poderosos
  • Considera usar —output-format para salida estructurada

​
Controlar formato de salida

Supongamos que necesitas la salida de Claude en un formato específico, especialmente al integrar Claude Code en scripts u otras herramientas.
1

Usa formato de texto (predeterminado)

cat data.txt | claude -p 'summarize this data' --output-format text > summary.txt
Esto genera solo la respuesta de texto plano de Claude (comportamiento predeterminado).
2

Usa formato JSON

cat code.py | claude -p 'analyze this code for bugs' --output-format json > analysis.json
Esto genera una matriz JSON de mensajes con metadatos incluyendo costo y duración.
3

Usa formato JSON de transmisión

cat log.txt | claude -p 'parse this log file for errors' --output-format stream-json
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.
Consejos:
  • Usa --output-format text para integraciones simples donde solo necesitas la respuesta de Claude
  • Usa --output-format json cuando necesites el registro de conversación completo
  • Usa --output-format stream-json para salida en tiempo real de cada turno de conversación

​
Crear comandos de barra diagonal personalizados

Claude Code admite comandos de barra diagonal personalizados que puedes crear para ejecutar rápidamente indicaciones o tareas específicas. Para más detalles, consulta la página de referencia de Comandos de barra diagonal.

​
Crear comandos específicos del proyecto

Supongamos que deseas crear comandos de barra diagonal reutilizables para tu proyecto que todos los miembros del equipo puedan usar.
1

Crea un directorio de comandos en tu proyecto

mkdir -p .claude/commands
2

Crea un archivo Markdown para cada comando

echo "Analyze the performance of this code and suggest three specific optimizations:" > .claude/commands/optimize.md
3

Usa tu comando personalizado en Claude Code

> /optimize
Consejos:
  • Los nombres de comando se derivan del nombre de archivo (por ejemplo, optimize.md se convierte en /optimize)
  • Puedes organizar comandos en subdirectorios (por ejemplo, .claude/commands/frontend/component.md crea /component con “(project:frontend)” mostrado en la descripción)
  • Los comandos del proyecto están disponibles para todos los que clonan el repositorio
  • El contenido del archivo Markdown se convierte en la indicación enviada a Claude cuando se invoca el comando

​
Agregar argumentos de comando con $ARGUMENTS

Supongamos que deseas crear comandos de barra diagonal flexibles que puedan aceptar entrada adicional de los usuarios.
1

Crea un archivo de comando con el marcador de posición $ARGUMENTS

echo 'Find and fix issue #$ARGUMENTS. Follow these steps: 1.
Understand the issue described in the ticket 2. Locate the relevant code in
our codebase 3. Implement a solution that addresses the root cause 4. Add
appropriate tests 5. Prepare a concise PR description' >
.claude/commands/fix-issue.md
2

Usa el comando con un número de problema

En tu sesión de Claude, usa el comando con argumentos.
> /fix-issue 123
Esto reemplazará $ARGUMENTS con “123” en la indicación.
Consejos:
  • El marcador de posición $ARGUMENTS se reemplaza con cualquier texto que siga al comando
  • Puedes posicionar $ARGUMENTS en cualquier lugar en tu plantilla de comando
  • Otras aplicaciones útiles: generar casos de prueba para funciones específicas, crear documentación para componentes, revisar código en archivos particulares, o traducir contenido a idiomas especificados

​
Crear comandos de barra diagonal personales

Supongamos que deseas crear comandos de barra diagonal personales que funcionen en todos tus proyectos.
1

Crea un directorio de comandos en tu carpeta de inicio

mkdir -p ~/.claude/commands
2

Crea un archivo Markdown para cada comando

echo "Review this code for security vulnerabilities, focusing on:" >
~/.claude/commands/security-review.md
3

Usa tu comando personalizado personal

> /security-review
Consejos:
  • Los comandos personales muestran “(user)” en su descripción cuando se enumeran con /help
  • Los comandos personales solo están disponibles para ti y no se comparten con tu equipo
  • Los comandos personales funcionan en todos tus proyectos
  • Puedes usar estos para flujos de trabajo consistentes en diferentes bases de código

​
Pregunta a Claude sobre sus capacidades

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

​
Preguntas de ejemplo

> can Claude Code create pull requests?

> how does Claude Code handle permissions?

> what slash commands are available?

> how do I use MCP with Claude Code?

> how do I configure Claude Code for Amazon Bedrock?

> what are the limitations of Claude Code?
Claude proporciona respuestas basadas en documentación a estas preguntas. Para ejemplos ejecutables y demostraciones prácticas, consulta las secciones de flujo de trabajo específicas anteriormente.
Consejos:
  • Claude siempre tiene acceso a la documentación más reciente de Claude Code, independientemente de la versión que estés usando
  • Haz preguntas específicas para obtener respuestas detalladas
  • Claude puede explicar características complejas como integración de MCP, configuraciones empresariales y flujos de trabajo avanzados

​
Próximos pasos

Implementación de referencia de Claude Code

Clona nuestra implementación de referencia de contenedor de desarrollo.