Claude Code opera como un sistema agéntico, no como una interfaz de chat con conocimientos de programación. El CLI lee su base de código, ejecuta comandos, modifica archivos, gestiona flujos de trabajo de git, se conecta a servicios externos mediante MCP y delega tareas complejas a subagentes especializados. Todo fluye a través de una interfaz de línea de comandos que se integra en la forma en que los desarrolladores realmente trabajan.

La diferencia entre un uso casual y uno efectivo de Claude Code se reduce a cinco sistemas fundamentales. Domínelos y Claude Code se convertirá en un multiplicador de fuerza:

1. Jerarquía de configuración — controla el comportamiento
2. Sistema de permisos — regula las operaciones
3. Sistema de hooks — habilita la automatización determinística
4. Protocolo MCP — extiende las capacidades
5. Sistema de subagentes — maneja tareas complejas de múltiples pasos

Pasé meses llevando Claude Code al límite en bases de código de producción, pipelines de CI/CD y despliegues empresariales. Esta guía destila esa experiencia en la referencia completa que desearía haber tenido cuando empecé. Cada función incluye sintaxis real, ejemplos de configuración prácticos y los casos límite que confunden incluso a usuarios experimentados.

Cómo Funciona Claude Code: El Modelo Mental

Antes de profundizar en las funciones, es importante comprender cómo la arquitectura de Claude Code determina todo lo que puede hacer con él. El sistema opera en tres capas:

┌─────────────────────────────────────────────────────────┐
│                    CLAUDE CODE LAYERS                    │
├─────────────────────────────────────────────────────────┤
│  EXTENSION LAYER                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │   MCP   │  │  Hooks  │  │ Skills  │  │ Plugins │    │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘    │
│  External tools, deterministic automation, domain       │
│  expertise, packaged extensions                          │
├─────────────────────────────────────────────────────────┤
│  DELEGATION LAYER                                        │
│  ┌─────────────────────────────────────────────────────┐    │
│  │              Subagents (up to 10 parallel)       │    │
│  │   Explore | Plan | General-purpose | Custom      │    │
│  └─────────────────────────────────────────────────────┘    │
│  Isolated contexts for focused work, returns summaries  │
├─────────────────────────────────────────────────────────┤
│  CORE LAYER                                              │
│  ┌─────────────────────────────────────────────────────┐    │
│  │         Main Conversation Context                │    │
│  │   Tools: Read, Edit, Bash, Glob, Grep, etc.     │    │
│  └─────────────────────────────────────────────────────┘    │
│  Your primary interaction; limited context; costs money │
└─────────────────────────────────────────────────────────┘

Capa Central (Core Layer): Su conversación principal. Cada mensaje, lectura de archivo y salida de herramienta consume contexto de una ventana compartida de 200K tokens (1M con premium). Cuando el contexto se llena, Claude pierde el seguimiento de decisiones anteriores y la calidad se degrada. Esta capa tiene costo por token.

Capa de Delegación (Delegation Layer): Los subagents se generan con contextos limpios, realizan trabajo enfocado y devuelven resúmenes. Los resultados de exploración no inflan su conversación principal—solo las conclusiones regresan. Use subagents Haiku para exploración (económicos, rápidos) y Sonnet para implementación.

Capa de Extensión (Extension Layer): MCP conecta servicios externos (bases de datos, GitHub, Sentry). Los hooks garantizan la ejecución de comandos de shell independientemente del comportamiento del modelo. Los skills codifican experiencia de dominio que Claude aplica automáticamente. Los plugins empaquetan todo esto para distribución.

La idea clave: La mayoría de los usuarios trabajan completamente en la Capa Central, observando cómo el contexto se infla y los costos aumentan. Los usuarios avanzados delegan la exploración y el trabajo especializado a la Capa de Delegación, mantienen la Capa de Extensión configurada para su flujo de trabajo, y usan la Capa Central solo para orquestación y decisiones finales.

Tabla de Contenidos

1. ¿Cómo Instalo Claude Code?
2. Modos de Interacción Principales
3. Sistema de Configuración a Fondo
4. ¿Qué Modelo Debo Elegir?
5. ¿Cómo Funciona el Sistema de Permisos?
6. ¿Cómo Funcionan los Hooks?
7. ¿Qué Es MCP (Model Context Protocol)?
8. ¿Qué Son los Subagents?
9. ¿Qué Es el Modo Extended Thinking?
10. Estilos de Salida
11. Comandos Slash
12. ¿Cómo Funcionan los Skills?
13. Sistema de Plugins
14. ¿Cómo Funciona la Memoria?
15. Imágenes y Entrada Multimodal
16. ¿Cómo Funciona la Integración con Git?
17. ¿Cómo Uso Claude Code en Mi IDE?
18. Patrones de Uso Avanzado
19. ¿Qué Es Claude Code Remote?
20. ¿Qué Son los Background Agents?
21. Claude in Chrome
22. Claude Code in Slack
23. ¿Cuánto Cuesta Claude Code?
24. Optimización de Rendimiento
25. ¿Cómo Depuro Problemas?
26. Implementación Empresarial
27. Referencia de Atajos de Teclado
28. Mejores Prácticas

¿Cómo Instalo Claude Code?

Requisitos del Sistema

Claude Code funciona en macOS 10.15+, Ubuntu 20.04+/Debian 10+, y Windows 10+ a través de WSL o Git Bash. El sistema requiere un mínimo de 4 GB de RAM y una conexión activa a internet. La compatibilidad de shell funciona mejor con Bash, Zsh o Fish.

Para Windows, tanto WSL 1 como WSL 2 funcionan. Git Bash también funciona si prefiere Windows nativo. Alpine Linux y otros sistemas basados en musl requieren paquetes adicionales:

apk add libgcc libstdc++ ripgrep
export USE_BUILTIN_RIPGREP=0

Métodos de Instalación

Instalación nativa (recomendada)

El binario nativo proporciona la experiencia más limpia sin dependencia de Node.js:

# macOS and Linux
curl -fsSL https://claude.ai/install.sh | bash

# Homebrew alternative
brew install --cask claude-code

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

# Windows CMD
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Para instalación de versión específica:

# Install specific version
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58

# Install latest explicitly
curl -fsSL https://claude.ai/install.sh | bash -s latest

# Windows PowerShell - specific version
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 1.0.58

Instalación NPM (obsoleta)

Nota: A partir de la versión v2.1.15, las instalaciones mediante npm muestran un aviso de obsolescencia. El binario nativo es ahora el método de instalación recomendado. Migre con claude install.

Para entornos heredados donde npm todavía es necesario:

npm install -g @anthropic-ai/claude-code

Nunca use sudo con la instalación de npm—crea problemas de permisos que complican todo posteriormente.

Migración desde instalación existente

Si tiene una instalación anterior basada en npm, migre al binario nativo:

claude install

Opciones de Autenticación

Claude Code admite tres rutas de autenticación, cada una con diferentes ventajas y desventajas:

Claude Console (facturación por API)

Conéctese directamente a la API de Anthropic a través de platform.claude.com (anteriormente console.anthropic.com). Cree una cuenta, configure la facturación y autentíquese a través del CLI. Esto proporciona facturación basada en uso con acceso completo a la API. Se crea automáticamente un workspace dedicado “Claude Code”—no puede crear claves API para este workspace, pero puede monitorear el uso.

Suscripción Claude Pro o Max

Use las credenciales de su cuenta claude.ai. La suscripción cubre tanto la interfaz web como el uso del CLI bajo un único plan mensual. Esto simplifica la facturación para usuarios individuales que desean costos predecibles.

Plataformas empresariales

AWS Bedrock, Google Vertex AI y Microsoft Foundry proporcionan acceso de nivel empresarial con relaciones de facturación en la nube existentes:

# AWS Bedrock
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1
export AWS_PROFILE=your-profile

# Google Vertex AI
export CLAUDE_CODE_USE_VERTEX=1
export CLOUD_ML_REGION=us-east5
export ANTHROPIC_VERTEX_PROJECT_ID=your-project

# Microsoft Foundry
export CLAUDE_CODE_USE_FOUNDRY=1
export ANTHROPIC_FOUNDRY_RESOURCE=your-resource-name
# Optional: API key auth (otherwise uses Entra ID)
export ANTHROPIC_FOUNDRY_API_KEY=your-key

Para implementaciones empresariales detrás de proxies o a través de gateways LLM:

# Corporate proxy
export HTTPS_PROXY='https://proxy.example.com:8080'

# LLM gateway (skip native auth)
export CLAUDE_CODE_USE_BEDROCK=1
export ANTHROPIC_BEDROCK_BASE_URL='https://your-gateway.com/bedrock'
export CLAUDE_CODE_SKIP_BEDROCK_AUTH=1

Verificación

claude doctor

Esto informa el tipo de instalación, versión, configuración del sistema y cualquier problema detectado.

Actualizaciones

Claude Code se actualiza automáticamente por defecto, verificando al inicio y periódicamente durante las sesiones. Las actualizaciones se descargan en segundo plano y se aplican en el próximo inicio.

Deshabilitar actualizaciones automáticas:

export DISABLE_AUTOUPDATER=1

O en settings.json:

{
  "env": {
    "DISABLE_AUTOUPDATER": "1"
  }
}

Actualización manual:

claude update

Desinstalación

Instalación nativa (macOS/Linux/WSL):

rm -f ~/.local/bin/claude
rm -rf ~/.claude-code

Instalación nativa (Windows PowerShell):

Remove-Item -Path "$env:LOCALAPPDATA\Programs\claude-code" -Recurse -Force
Remove-Item -Path "$env:LOCALAPPDATA\Microsoft\WindowsApps\claude.exe" -Force

Limpiar configuración (elimina toda la configuración):

rm -rf ~/.claude
rm ~/.claude.json
rm -rf .claude
rm -f .mcp.json

Modos de interacción principales

REPL interactivo

Inicie Claude Code sin argumentos para entrar al bucle interactivo de lectura-evaluación-impresión (REPL):

cd your-project
claude

El REPL mantiene el contexto de la conversación entre turnos. Escriba sus consultas directamente, reciba respuestas y continúe hasta salir con /exit o Ctrl+D.

Comience con un prompt inicial para enfocar la sesión:

claude "explain the authentication flow in this project"

Consejo avanzado: El REPL persiste el estado entre eventos de compactación. Cuando el contexto crece demasiado, Claude resume automáticamente la conversación más antigua mientras preserva las decisiones clave y los fragmentos de código. Puede activar esto manualmente con /compact o agregar instrucciones personalizadas sobre qué preservar.

Modo no interactivo

El modo de impresión (-p) ejecuta una sola consulta y finaliza:

# Direct query
claude -p "list all TODO comments in this project"

# Process piped input
cat error.log | claude -p "identify the root cause of these failures"

# Chain with other tools
claude -p "generate a README" > README.md

Para obtener una salida estructurada adecuada para el análisis en scripts:

claude -p "count lines by file type" --output-format json

La salida JSON incluye todo lo necesario para la automatización:

{
  "type": "result",
  "subtype": "success",
  "total_cost_usd": 0.0034,
  "is_error": false,
  "duration_ms": 2847,
  "duration_api_ms": 1923,
  "num_turns": 4,
  "result": "Response text here...",
  "session_id": "abc-123-def"
}

Para el procesamiento en tiempo real de la salida en streaming:

claude -p "build the application" --output-format stream-json | while read line; do
  echo "$line" | jq -r '.result // empty'
done

Gestión de sesiones

Las sesiones persisten el historial de conversación para su continuación. Esto es esencial para trabajos complejos que abarcan múltiples sesiones:

# Continue most recent session
claude -c

# Continue with additional prompt
claude -c -p "now add error handling"

# Resume specific session by ID
claude -r "abc123" "implement the remaining tests"

# Fork a session for parallel exploration
claude -r "base-session" --fork-session "try a different approach"

Cree sesiones reproducibles con IDs explícitos:

claude --session-id "feature-auth-$(date +%s)"

Consejo avanzado: Use IDs de sesión que codifiquen contexto: feature-${branch}-${timestamp} o bug-JIRA-123. Cuando regrese días después, el ID le indicará de qué se trataba la sesión. Vea las sesiones disponibles dentro del REPL usando /resume.

Las sesiones se almacenan como transcripciones JSONL. La ejecución del agente recibe valores únicos de agentId con transcripciones almacenadas como agent-{agentId}.jsonl. Al reanudar, se preserva el contexto completo de las conversaciones anteriores.

Sesiones con nombre (dic. 2025): Nombre y gestione sesiones más fácilmente:

# Name current session
> /rename my-feature-work

# Resume by name or number
> /resume 1                    # Resume first session
> /resume my-feature-work      # Resume by name
claude --resume 3              # Resume from terminal

# Fork with custom session ID
claude --session-id "new-exploration" --resume "base-session" --fork-session

Análisis profundo del sistema de configuración

Claude Code utiliza un sistema de configuración por capas. Comprender la jerarquía es esencial porque los niveles superiores anulan a los inferiores, y la configuración empresarial no puede eludirse en absoluto.

Jerarquía de configuración

Consejo avanzado: Use .claude/settings.local.json para preferencias personales en proyectos compartidos; debe estar en .gitignore. Use .claude/settings.json para la configuración de todo el equipo que se registra en el control de versiones.

Referencia completa de settings.json

Una configuración integral que demuestra todas las opciones principales:

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "model": "claude-sonnet-4-5-20250929",
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm run:*)",
      "Bash(git:*)",
      "Bash(make:*)",
      "Edit(src/**)",
      "Write(src/**)",
      "mcp__github"
    ],
    "deny": [
      "Read(.env*)",
      "Read(secrets/**)",
      "Bash(rm -rf:*)",
      "Bash(sudo:*)",
      "Edit(package-lock.json)",
      "Edit(.git/**)"
    ],
    "ask": [
      "WebFetch",
      "Bash(curl:*)",
      "Bash(docker:*)"
    ],
    "additionalDirectories": [
      "../shared-lib",
      "../docs"
    ],
    "defaultMode": "acceptEdits"
  },
  "env": {
    "NODE_ENV": "development",
    "DEBUG": "app:*"
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\""
          }
        ]
      }
    ]
  },
  "sandbox": {
    "enabled": false,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"]
  },
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  },
  "includeCoAuthoredBy": true,
  "cleanupPeriodDays": 30,
  "outputStyle": "Explanatory",
  "language": "en",
  "respectGitignore": true,
  "showTurnDuration": true,
  "plansDirectory": ".claude/plans",
  "spinnerVerbs": ["Thinking", "Processing", "Analyzing"]
}

Referencia de variables de entorno

Autenticación y API:

ANTHROPIC_API_KEY=sk-ant-...                    # Direct API authentication
ANTHROPIC_AUTH_TOKEN=token                      # Custom authorization header
ANTHROPIC_CUSTOM_HEADERS="X-Key: val"           # Additional request headers

Configuración del modelo:

ANTHROPIC_MODEL=claude-opus-4-5                 # Override default model
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-5-20251101
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-5-20250929-v1:0
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Model for subagents
MAX_THINKING_TOKENS=10000                       # Enable extended thinking
CLAUDE_CODE_MAX_OUTPUT_TOKENS=4000              # Limit output length

Configuración de proveedores en la nube:

CLAUDE_CODE_USE_BEDROCK=1                       # Use AWS Bedrock
CLAUDE_CODE_USE_VERTEX=1                        # Use Google Vertex AI
CLAUDE_CODE_USE_FOUNDRY=1                       # Use Microsoft Foundry
ANTHROPIC_BEDROCK_BASE_URL=https://...          # Custom Bedrock endpoint
CLAUDE_CODE_SKIP_BEDROCK_AUTH=1                 # Skip Bedrock auth (for gateways)
CLAUDE_CODE_SKIP_VERTEX_AUTH=1                  # Skip Vertex auth
AWS_BEARER_TOKEN_BEDROCK=token                  # Bedrock bearer token
VERTEX_REGION_CLAUDE_3_7_SONNET=us-west1        # Override Vertex region

Control de comportamiento:

DISABLE_AUTOUPDATER=1                           # Prevent automatic updates
DISABLE_TELEMETRY=1                             # Opt out of usage telemetry
DISABLE_ERROR_REPORTING=1                       # Disable Sentry
DISABLE_BUG_COMMAND=1                           # Disable /bug command
DISABLE_COST_WARNINGS=1                         # Hide cost warnings
DISABLE_PROMPT_CACHING=1                        # Disable prompt caching globally
DISABLE_PROMPT_CACHING_SONNET=1                 # Disable for Sonnet only
DISABLE_PROMPT_CACHING_OPUS=1                   # Disable for Opus only
DISABLE_NON_ESSENTIAL_MODEL_CALLS=1             # Skip non-critical API calls

Configuración de herramientas:

BASH_DEFAULT_TIMEOUT_MS=30000                   # Bash command timeout (30s)
BASH_MAX_TIMEOUT_MS=600000                      # Maximum bash timeout (10min)
BASH_MAX_OUTPUT_LENGTH=50000                    # Bash output limit
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1     # Reset CWD after each bash
MCP_TIMEOUT=5000                                # MCP server startup timeout
MCP_TOOL_TIMEOUT=30000                          # MCP tool execution timeout
MAX_MCP_OUTPUT_TOKENS=25000                     # MCP output limit
SLASH_COMMAND_TOOL_CHAR_BUDGET=15000            # Slash command context limit

Red y proxy:

HTTP_PROXY=http://proxy:8080                    # HTTP proxy
HTTPS_PROXY=https://proxy:8080                  # HTTPS proxy
NO_PROXY=localhost,example.com                  # Bypass proxy for domains
CLAUDE_CODE_CLIENT_CERT=/path/to/cert           # mTLS certificate
CLAUDE_CODE_CLIENT_KEY=/path/to/key             # mTLS private key
CLAUDE_CODE_CLIENT_KEY_PASSPHRASE=pass          # mTLS passphrase

Interfaz y terminal:

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Don't update terminal title
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # Skip IDE extension install
CLAUDE_CODE_SHELL=/bin/zsh                      # Override shell detection
USE_BUILTIN_RIPGREP=1                           # Use included ripgrep (default)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Custom config directory
IS_DEMO=1                                       # Hide sensitive UI elements[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Disable background tasks and Ctrl+B[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Override temp directory[^50]

Depuración:

ANTHROPIC_LOG=debug                             # Enable API request logging

¿Qué modelo debería elegir?

Elegir el modelo adecuado para cada tarea impacta significativamente tanto el costo como la calidad. Claude Code proporciona cambio flexible de modelos en múltiples niveles.

Modelos disponibles

Por qué importan estas diferencias de precio: Una sesión típica de programación consume 50K-200K tokens de entrada y 10K-50K tokens de salida. Con Haiku, eso representa $0.10-$0.45 por sesión. Con Opus, la misma sesión cuesta $0.50-$2.25—5 veces más. Reserve Opus para problemas genuinamente difíciles.¹

Cuándo usar cada modelo

Haiku: Úselo para subagents que realizan exploración, búsquedas simples de archivos, preguntas rápidas. Es 10-20 veces más económico que Opus y responde más rápido. Perfecto para tareas en segundo plano donde no necesita razonamiento profundo.

Sonnet: El caballo de batalla para el desarrollo diario. Maneja bien la mayoría de las tareas de programación: implementar funciones, corregir errores, escribir pruebas, revisión de código. Use este como su predeterminado.

Opus: Resérvelo para razonamiento genuinamente complejo: decisiones arquitectónicas, depuración difícil, comprensión de sistemas complejos, análisis de seguridad. La diferencia de calidad es real para problemas difíciles, pero también lo es el costo. Opus 4.5 alcanza 80.9% en SWE-bench Verified mientras reduce el uso de tokens a la mitad en comparación con predecesores.⁴⁵ Nota: Los usuarios con suscripción Pro ahora tienen acceso a Opus 4.5 como parte de su suscripción.²⁰

Opusplan: Un modo híbrido que usa Opus para planificación (donde la calidad del razonamiento importa más) y Sonnet para ejecución (donde la velocidad importa). Excelente para refactorización compleja donde desea el mejor plan pero no necesita razonamiento nivel Opus para cada edición individual.

Cambiar de modelo

Durante la sesión:

> /model opus
> /model sonnet
> /model haiku

Al iniciar:

claude --model opus

Mediante variable de entorno:

export ANTHROPIC_MODEL=opus

En settings.json:

{
  "model": "claude-sonnet-4-5-20250929"
}

Para subagents específicamente:

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Contexto extendido

Para bases de código grandes o sesiones prolongadas, habilite el contexto de 1M tokens:

claude --model sonnet[1m]

O dentro de una sesión:

> /model anthropic.claude-sonnet-4-5-20250929-v1:0[1m]

El contexto extendido cuesta más por token. Úselo cuando realmente lo necesite, no como predeterminado.

Verificar el modelo actual

> /status

Esto muestra el modelo actual, información de la cuenta, configuraciones aplicadas y otro estado de la sesión.

Marcos de decisión

Saber que existen las funciones no es suficiente—necesita saber cuándo usar cada una. Estos árboles de decisión transforman el conocimiento en acción.

¿Qué modelo debería usar?

INICIO → ¿Es la tarea simple? (búsqueda de archivos, pregunta rápida, formato)
         │
         ├── SÍ → Use Haiku
         │        Costo: ~$0.03/tarea
         │        Velocidad: La más rápida
         │
         └── NO → ¿Requiere razonamiento profundo?
                  (arquitectura, depuración compleja, análisis de seguridad)
                  │
                  ├── SÍ → Use Opus
                  │        Costo: ~$2.00/tarea
                  │        Calidad: La más alta
                  │
                  └── NO → Use Sonnet (predeterminado)
                           Costo: ~$0.75/tarea
                           Equilibrio: El mejor en general

Regla general: Comience con Sonnet. Baje a Haiku para subagents. Escale a Opus solo cuando la respuesta de Sonnet se sienta superficial.

¿Comando, skill o subagent?

¿Desea control explícito sobre cuándo se ejecuta?
│
├── SÍ → Use Slash Command
│        Ejemplo: /deploy, /test, /security-review
│        Usted lo invoca. Usted controla el momento.
│
└── NO → ¿Debería la experiencia aplicarse automáticamente según el contexto?
         │
         ├── SÍ → Use Skill
         │        Ejemplo: Patrones de seguridad, reglas de dominio, estándares de código
         │        Claude reconoce el contexto y aplica la experiencia.
         │
         └── NO → ¿El trabajo necesita contexto aislado?
                  │
                  ├── SÍ → Use Subagent
                  │        Ejemplo: Exploración profunda, análisis paralelo
                  │        Evita la sobrecarga de contexto en la conversación principal.
                  │
                  └── NO → Simplemente pregunte directamente
                           No todo necesita abstracción.

¿Hook o prompt?

¿Debe la acción ocurrir SIEMPRE, independientemente del juicio de Claude?
│
├── SÍ → Use Hook (determinístico)
│        Ejemplos:
│        - Formatear código después de cada edición
│        - Registrar todos los comandos bash
│        - Bloquear acceso a archivos .env
│        Claude no puede omitirlo, olvidarlo o decidir lo contrario.
│
└── NO → Use Prompt (probabilístico)
         Ejemplos:
         - "Considere agregar pruebas"
         - "Piense en casos extremos"
         - "Revise por seguridad si es relevante"
         Claude decide según el contexto.

¿Cuándo usar extended thinking?

¿Es este un problema genuinamente difícil?
│
├── Decisión arquitectónica con muchas compensaciones → SÍ, use thinking
├── Depuración compleja con causa raíz poco clara → SÍ, use thinking
├── Análisis de seguridad que requiere razonamiento cuidadoso → SÍ, use thinking
├── Comprender una base de código desconocida → SÍ, use thinking
│
├── Corrección de error rutinaria → NO, omita thinking
├── Refactorización simple → NO, omita thinking
├── Formato de código → NO, omita thinking
└── Preguntas rápidas → NO, omita thinking

Alterne con Tab durante la sesión. Los presupuestos más altos de thinking cuestan más—comience con el mínimo y aumente solo si las respuestas se sienten apresuradas.

¿Cómo funciona el sistema de permisos?

El sistema de permisos de Claude Code proporciona control detallado sobre qué operaciones pueden ejecutarse. Comprenderlo es esencial tanto para la seguridad como para la eficiencia del flujo de trabajo.

Niveles de permisos

Herramientas de solo lectura (aprobadas automáticamente): - Read - Leer contenido de archivos - Glob - Encontrar archivos por patrón - Grep - Buscar contenido en archivos - WebSearch - Buscar en la web - LSP - Inteligencia de código (ir a definición, encontrar referencias, documentación al pasar el cursor)²⁵

Capacidades de la herramienta LSP (v2.0.74+): La herramienta LSP proporciona inteligencia de código similar a un IDE: - Ir a definición: Saltar a donde se define un símbolo - Encontrar referencias: Listar todos los usos de un símbolo en toda la base de código - Documentación al pasar el cursor: Obtener información de tipos y documentación para cualquier símbolo - Funciona con TypeScript, Python, Go, Rust y otros lenguajes con soporte LSP - Requiere que el servidor de lenguaje esté disponible (típicamente instalado con su cadena de herramientas)

Herramientas de modificación (requieren aprobación): - Edit - Modificar archivos existentes - Write - Crear archivos nuevos - Bash - Ejecutar comandos de shell - WebFetch - Obtener contenido de URL - NotebookEdit - Modificar notebooks de Jupyter

La primera vez que se ejecuta una herramienta de modificación, Claude Code solicita aprobación. Las aprobaciones persisten durante la sesión a menos que se configure explícitamente de otra manera.

Modos de permisos

Modo YOLO (v2.0.68+): Para operación completamente autónoma, use la bandera --dangerously-skip-permissions. Esto dice sí a todo—ediciones de archivos, comandos bash, todas las llamadas de herramientas. La palabra “dangerous” es intencional. Use en entornos aislados o cuando confíe completamente en la base de código.⁶¹

claude --dangerously-skip-permissions

Establezca el modo mediante CLI:

claude --permission-mode acceptEdits

Alterne durante la sesión:

Shift+Tab  # Cicla entre modos

En settings.json:

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Sintaxis de reglas de permisos

Las reglas detalladas controlan operaciones específicas. Las reglas se evalúan en orden: la primera coincidencia gana.

Patrones de comandos Bash:

{
  "allow": [
    "Bash(npm run build)",
    "Bash(npm run test:*)",
    "Bash(git commit:*)",
    "Bash(make:*)"
  ],
  "deny": [
    "Bash(rm -rf:*)",
    "Bash(sudo:*)",
    "Bash(curl|wget:*)"
  ]
}

El asterisco proporciona coincidencia de prefijos: Bash(npm run test:*) permite npm run test, npm run test:unit y npm run test:integration.

Limitación importante: Los patrones de Bash coinciden solo con prefijos, no con regex. Un patrón como Bash(curl http:*) no coincidirá con curl -X GET http://... porque las opciones vienen antes de la URL. Para bloqueo robusto, deniegue el comando completamente: Bash(curl:*).

Patrones de operaciones de archivos:

{
  "allow": [
    "Edit(src/**)",
    "Write(src/**)",
    "Read(docs/**)"
  ],
  "deny": [
    "Read(.env*)",
    "Read(secrets/**)",
    "Edit(.git/**)",
    "Edit(node_modules/**)"
  ]
}

Sintaxis de rutas: - Rutas relativas: Edit(src/**) - relativo al directorio de trabajo - Absoluta desde archivo de configuración: Edit(/build/**) - relativo a la ubicación del archivo de configuración - Absoluta verdadera: Edit(//tmp/**) - comienza con // - Directorio home: Read(~/.zshrc)

Patrones de herramientas MCP:

{
  "allow": [
    "mcp__github",
    "mcp__database__query",
    "mcp__myserver__*"
  ],
  "deny": [
    "mcp__dangerous_server",
    "mcp__untrusted__*"
  ]
}

Use la sintaxis de comodín mcp__server__* para permitir o denegar todas las herramientas de un servidor MCP específico.³⁹ Esto es útil para habilitar rápidamente todas las herramientas de servidores confiables o bloquear servidores completos de fuentes no confiables.

Patrones de WebFetch:

{
  "allow": [
    "WebFetch(domain:github.com)",
    "WebFetch(domain:api.example.com)"
  ]
}

Directorios adicionales

Extienda el acceso de Claude más allá del proyecto actual:

{
  "permissions": {
    "additionalDirectories": [
      "../shared-lib",
      "../docs",
      "~/reference-projects/design-system"
    ]
  }
}

Esto es esencial para monorepos o cuando Claude necesita referenciar código en directorios hermanos.

Modo sandbox

Habilite el aislamiento del sistema de archivos y la red:

> /sandbox

O configure en settings:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"],
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"],
      "allowLocalBinding": true
    }
  }
}

Cuando está en modo sandbox: - Acceso al sistema de archivos restringido al directorio del proyecto - Acceso a la red controlado - Ciertos comandos excluidos de las restricciones del sandbox - Comandos Bash auto-aprobados si autoAllowBashIfSandboxed es verdadero

Consejo de experto: El modo sandbox es excelente para ejecutar Claude en bases de código no confiables. Habilítelo cuando explore proyectos desconocidos o cuando desee una capa extra de protección. Las pruebas internas de Anthropic encontraron que el sandboxing reduce las solicitudes de permisos en un 84%.⁴⁵

¿Cómo Funcionan los Hooks?

Los hooks ejecutan comandos de shell determinísticos en puntos específicos del flujo de trabajo de Claude Code. A diferencia de indicarle a Claude que realice acciones, los hooks garantizan la ejecución independientemente del comportamiento del modelo. Son esenciales para hacer cumplir los estándares del equipo y automatizar tareas repetitivas.

Por qué hooks en lugar de prompts: Decirle a Claude “siempre ejecuta Prettier después de editar archivos” funciona a veces. Pero Claude podría olvidarlo, priorizar la velocidad o decidir que el cambio es “muy pequeño”. Los hooks garantizan la ejecución—cada Edit o Write activa su formateador, cada vez, sin excepciones. Para cumplimiento, seguridad y estándares del equipo, lo determinístico supera a lo probabilístico.⁷

Eventos Disponibles

Configuración de Hooks

Defina hooks en settings.json o en un archivo hooks.json dedicado:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\""
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/validate-bash.sh"
          }
        ]
      }
    ],
    "UserPromptSubmit": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/inject-context.sh"
          }
        ]
      }
    ]
  }
}

Matchers

El campo matcher determina qué herramientas activan un hook:

{"matcher": "*"}              // Match all tools
{"matcher": "Bash"}           // Match Bash only
{"matcher": "Edit|Write"}     // Match Edit or Write
{"matcher": "mcp__github"}    // Match MCP server tools
{"matcher": ""}               // Match for events without tools (like UserPromptSubmit)

Protocolo de Entrada/Salida de Hooks

Los hooks reciben JSON en stdin:

{
  "tool_name": "Bash",
  "tool_input": {
    "command": "npm test",
    "description": "Run test suite"
  },
  "session_id": "abc-123"
}

Los códigos de salida controlan el comportamiento: - 0: Éxito—la operación continúa. La salida estándar se muestra en modo verbose (Ctrl+O). Para UserPromptSubmit y SessionStart, la salida estándar se agrega al contexto. - 2: Error bloqueante—la operación se detiene. El stderr se convierte en el mensaje de error que se envía a Claude. - 1, 3, etc.: Error no bloqueante—la operación continúa. El stderr se muestra como advertencia en modo verbose.

Para control avanzado, los hooks pueden generar JSON:

{
  "decision": "allow",
  "message": "Command validated and modified",
  "modifications": {
    "tool_input": {
      "command": "npm test -- --coverage"
    }
  }
}

Hooks PreToolUse con permiso ask (v2.1.0+): Los hooks PreToolUse ahora pueden devolver updatedInput cuando usan la decisión de permiso “ask”, permitiendo que los hooks actúen como middleware mientras aún solicitan el consentimiento del usuario.³⁹

{
  "decision": "ask",
  "message": "Modified command requires approval",
  "updatedInput": {
    "command": "npm test -- --coverage --ci"
  }
}

Hooks PreToolUse con additionalContext (v2.1.9+): Los hooks pueden inyectar contexto al modelo devolviendo additionalContext. Esto es útil para proporcionar información dinámica (documentación de API, esquemas de base de datos, estado del entorno) que el modelo debería considerar.⁵¹

{
  "decision": "allow",
  "additionalContext": "Note: This database has a 5-second query timeout. Complex joins may need optimization."
}

La cadena additionalContext se agrega al contexto del modelo para ese turno, haciéndola disponible para razonamiento sin modificar permanentemente la conversación.

Ejemplos Prácticos de Hooks

Auto-formatear archivos TypeScript después de editar:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c '[[ \"$FILE_PATH\" == *.ts ]] && npx prettier --write \"$FILE_PATH\" || true'"
          }
        ]
      }
    ]
  }
}

Registrar todos los comandos bash:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.command' >> ~/.claude/bash-history.log"
          }
        ]
      }
    ]
  }
}

Bloquear acceso a archivos sensibles:

#!/bin/bash
# .claude/hooks/protect-files.sh
data=$(cat)
path=$(echo "$data" | jq -r '.tool_input.file_path // empty')

if [[ "$path" == *".env"* ]] || [[ "$path" == *"secrets/"* ]] || [[ "$path" == *".pem"* ]]; then
  echo "Blocked: Cannot access sensitive file $path" >&2
  exit 1
fi
exit 0

Ejecutar pruebas después de cambios de código:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c '[[ \"$FILE_PATH\" == *.test.ts ]] || npm run test:affected'"
          }
        ]
      }
    ]
  }
}

Sistema de notificaciones personalizado:

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Waiting for your input'"
          }
        ]
      }
    ]
  }
}

Inyectar contexto dinámico en prompts:

#!/bin/bash
# .claude/hooks/inject-context.sh
# Add current git branch and recent commits to every prompt

branch=$(git branch --show-current 2>/dev/null)
commits=$(git log --oneline -3 2>/dev/null | tr '\n' ' ')

if [ -n "$branch" ]; then
  echo "[Context: Branch '$branch', Recent: $commits]"
fi
exit 0

Depuración de Hooks

Habilite el modo debug para solucionar problemas con hooks:

claude --debug

Esto registra: - Tiempos de ejecución de hooks - Datos de entrada/salida - Mensajes de error y stack traces - Resultados de decisiones (allow/reject/ask)

Hooks con Alcance de Componente (v2.1.0+)

Los hooks pueden definirse directamente en Skills, subagents y slash commands usando frontmatter. Estos hooks tienen alcance al ciclo de vida del componente y solo se ejecutan cuando ese componente está activo.⁴¹

Skill con hooks integrados:

---
name: secure-deployment
description: Deployment skill with security validation
hooks:
  PreToolUse:
    - matcher: Bash
      command: ".claude/hooks/validate-deploy.sh"
  PostToolUse:
    - matcher: Bash
      command: ".claude/hooks/log-deploy.sh"
  Stop:
    - command: ".claude/hooks/cleanup.sh"
      once: true  # Run only once per session
---

Eventos soportados: PreToolUse, PostToolUse, Stop

La opción once (solo para skills y slash commands) asegura que el hook se ejecute solo una vez por sesión—útil para tareas de limpieza o finalización.

Estrategia para Sesiones de Larga Duración

Para sesiones de Claude Code nocturnas o desatendidas, configure hooks para mantener a Claude encaminado sin intervención manual. La idea clave: use hooks de linting y pruebas como barreras que obliguen a Claude a corregir problemas antes de continuar.⁶⁴

El Patrón “No Detenerse Hasta que Pasen las Pruebas”:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint && npm run typecheck",
            "timeout": 60000
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "npm test || echo 'Tests failing - Claude should fix before stopping'"
          }
        ]
      }
    ]
  }
}

Estrategia para sesiones nocturnas:

1. Verificación previa: Use un hook Setup para verificar que el entorno esté listo
2. Validación continua: Los hooks PostToolUse ejecutan pruebas después de cada cambio
3. Control de finalización: Los hooks Stop verifican que todos los criterios de aceptación se cumplan antes de que Claude declare “terminado”
4. Notificación: Los hooks Stop pueden notificarle vía Slack/Pushover cuando Claude termina o se queda atascado

Combine con --dangerously-skip-permissions en un contenedor aislado para ejecuciones nocturnas completamente autónomas. Claude seguirá iterando hasta que las pruebas pasen o agote sus opciones.

¿Qué es MCP (Model Context Protocol)?

MCP extiende Claude Code con acceso a herramientas externas, bases de datos, APIs y servicios a través de un protocolo estandarizado. El ecosistema ha crecido exponencialmente: MCP ahora cuenta con 100 millones de descargas mensuales y más de 3.000 servidores indexados en MCP.so (enero de 2026), consolidando su posición como el estándar de la industria para conectar IA con herramientas y datos.³⁵⁴ Comprender MCP es esencial para integrar Claude en su cadena de herramientas existente.

Por qué MCP es importante para los desarrolladores: Sin MCP, Claude Code solo puede leer archivos y ejecutar comandos bash. Con MCP, Claude puede consultar su base de datos de producción, crear tickets en Jira, revisar PRs en GitHub, verificar errores en Sentry e interactuar con cualquier API que su equipo utilice, todo desde solicitudes en lenguaje natural. El protocolo estandariza cómo las herramientas de IA se conectan a servicios externos, evitando la dependencia de un solo proveedor.

Soporte para MCP remoto (junio de 2025)

Claude Code ahora admite servidores MCP remotos con autenticación OAuth nativa.²⁸ Conéctese a herramientas y fuentes de datos sin gestionar servidores locales: autentíquese una vez y Claude Code se encarga de la renovación de tokens automáticamente.

# Connect to remote MCP server with OAuth
claude mcp add --transport http linear https://mcp.linear.app/sse
# Browser opens for OAuth flow, tokens stored securely

MCP Tool Search (v2.1.7+)

A medida que los servidores MCP crecieron en capacidad (algunos exponiendo más de 50 herramientas), las descripciones de herramientas comenzaron a consumir contexto de forma excesiva. MCP Tool Search resuelve esto cargando dinámicamente las descripciones de herramientas solo cuando se necesitan, una forma de carga diferida para herramientas de IA.⁵⁴

Impacto en el rendimiento: Las pruebas internas muestran mejoras significativas en precisión: - Opus 4: 49% → 74% en evaluaciones MCP - Opus 4.5: 79,5% → 88,1% en evaluaciones MCP - Reducción de consumo de tokens: 85%

Cómo funciona: Cuando las descripciones de herramientas MCP superan el 10% de la ventana de contexto (umbral predeterminado), Claude Code difiere la carga de las descripciones completas hasta que realmente se necesitan. Claude ve los nombres de las herramientas pero obtiene las descripciones bajo demanda.

Configuración:

{
  "mcpToolSearchAutoEnable": "auto:15"  // Enable when tools exceed 15% of context
}

Valores: - true - Siempre habilitar la búsqueda de herramientas - false - Siempre deshabilitar (cargar todas las descripciones de herramientas de forma anticipada) - auto:N - Habilitar cuando las herramientas superen el N% del contexto (0-100)

Consejo avanzado: Con Tool Search habilitado, puede conectar muchos más servidores MCP sin preocuparse por los límites de contexto. La reducción del 95% en contexto significa que los servidores que antes competían por contexto ahora coexisten sin problemas.

Asistente interactivo de configuración MCP

Ejecute claude mcp add sin argumentos para iniciar una interfaz paso a paso para agregar servidores MCP. El asistente lo guía a través de la selección del tipo de transporte, la autenticación y la configuración.¹⁵

Tipos de transporte

HTTP (recomendado para servidores remotos):

claude mcp add --transport http github https://api.githubcopilot.com/mcp/

# With authentication
claude mcp add --transport http api https://api.example.com/mcp \
  --header "Authorization: Bearer $API_TOKEN"

SSE (obsoleto pero funcional):

claude mcp add --transport sse asana https://mcp.asana.com/sse \
  --header "X-API-Key: your-key"

Stdio (servidores locales):

# PostgreSQL
claude mcp add --transport stdio postgres \
  --env "DATABASE_URL=postgresql://user:pass@localhost/db" \
  -- npx -y @anthropic-ai/mcp-server-postgres

# Custom server
claude mcp add --transport stdio custom -- python /path/to/server.py --port 8000

Windows requiere un envoltorio cmd para stdio:

claude mcp add --transport stdio my-server -- cmd /c npx -y @some/package

Gestión de alcance

Los servidores MCP existen en tres niveles de alcance con precedencia clara (local anula proyecto, proyecto anula usuario):

Especifique el alcance durante la instalación:

claude mcp add --scope project --transport http github https://...
claude mcp add --scope user --transport stdio personal-tool -- ./my-tool

Formato del archivo de configuración

El archivo .mcp.json define los servidores a nivel de proyecto:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "database": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${SENTRY_API_KEY}"
      }
    },
    "internal-api": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": {
        "X-API-Key": "${INTERNAL_API_KEY}"
      }
    }
  }
}

Las variables de entorno se expanden usando la sintaxis ${VAR} con valores predeterminados opcionales: ${VAR:-default}.

Comandos de gestión MCP

claude mcp list                      # View all configured servers
claude mcp get github                # Get specific server details
claude mcp remove github             # Remove a server
claude mcp reset-project-choices     # Reset project-scoped approvals
claude mcp add-from-claude-desktop   # Import from Claude Desktop
claude mcp add-json weather '{"type":"http","url":"..."}'  # Add from JSON

# Within Claude Code REPL
> /mcp                               # Interactive MCP management

Autenticación OAuth

Para servidores que requieren OAuth:

> /mcp
# Follow browser-based OAuth flow
# Tokens stored securely and auto-refreshed
# Use "Clear authentication" to revoke access

Uso de recursos y prompts MCP

Referencia a recursos:

@github:issue://123
@postgres:schema://users
@docs:file://api/authentication

Prompts MCP como comandos slash:

/mcp__github__list_prs
/mcp__github__pr_review 456
/mcp__jira__create_issue "Bug title" high

Límites de salida

La salida de MCP está limitada para prevenir el desbordamiento de contexto: - Umbral de advertencia: 10.000 tokens - Máximo predeterminado: 25.000 tokens

Aumente si es necesario:

export MAX_MCP_OUTPUT_TOKENS=50000

Servidores MCP populares

Patrones prácticos de MCP

Flujo de trabajo con GitHub:

> Review PR #456
> List all open issues assigned to me
> Create a bug issue for the authentication failure we found

Consultas a base de datos:

> What's our total revenue this quarter?
> Show the schema for the users table
> Find customers with no purchases in 90 days

Monitoreo de errores:

> What errors occurred in production today?
> Show the stack trace for error ABC123
> Which deployment introduced these errors?

Configuración MCP empresarial

Los administradores del sistema pueden aplicar políticas MCP mediante managed-mcp.json:

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "sentry" },
    { "serverCommand": ["npx", "-y", "@approved/server"] }
  ],
  "deniedMcpServers": [
    { "serverName": "dangerous-server" }
  ]
}

Ubicación: - macOS: /Library/Application Support/ClaudeCode/managed-mcp.json - Linux: /etc/claude-code/managed-mcp.json - Windows: C:\ProgramData\ClaudeCode\managed-mcp.json

La lista de denegación tiene precedencia absoluta. Los comandos deben coincidir exactamente, incluyendo el orden de los argumentos.

MCP Apps (enero de 2026)

Anthropic lanzó MCP Apps, una extensión del Model Context Protocol que habilita interfaces de herramientas interactivas directamente dentro de la interfaz de Claude.⁷⁸ MCP Apps permite a los usuarios visualizar, editar e interactuar con contenido de servicios externos sin salir de Claude, incluyendo Asana, Box, Canva, Figma, Hex, monday.com y Slack. Cualquier servidor MCP puede proporcionar una interfaz interactiva que se renderiza dentro de Claude. Aunque MCP Apps actualmente aparece en la interfaz web de claude.ai, las extensiones subyacentes del protocolo MCP son relevantes para el ecosistema MCP de Claude Code a medida que los servidores adoptan las nuevas capacidades interactivas.

Plataforma API: Code Execution Tool v2 (enero de 2026)

Anthropic lanzó la v2 del Code Execution Tool en beta pública, reemplazando el sandbox original exclusivo de Python con ejecución de comandos Bash y manipulación directa de archivos.⁷⁹ Cambios clave: - Ejecutar comandos Bash (no solo Python) en contenedores aislados - Escribir y ejecutar código en cualquier lenguaje - Llamadas programáticas a herramientas (también en beta pública): Claude puede invocar herramientas desde dentro de la ejecución de código, reduciendo la latencia y el consumo de tokens en flujos de trabajo con múltiples herramientas

Esto afecta principalmente a los usuarios de la API, pero señala la dirección de las capacidades de ejecución en la nube de Claude Code.

¿Qué son los Subagents?

Los subagents son instancias especializadas de Claude que manejan tareas complejas de forma independiente. Son una de las características más poderosas de Claude Code y una de las menos comprendidas. Dominar los subagents expande dramáticamente lo que puede lograr.

Por qué existen los subagents: La conversación principal de Claude Code tiene una única ventana de contexto. Todo lo que discute, cada archivo que Claude lee, cada salida de herramienta—todo consume ese contexto. En sesiones largas, el contexto se llena, Claude pierde el seguimiento de decisiones anteriores y el rendimiento se degrada. Los subagents resuelven esto aislando el trabajo: los resultados de exploración no inflan su conversación principal, solo el resumen retorna. Claude también puede ejecutar hasta 10 subagents en paralelo, habilitando trabajo concurrente que sería imposible secuencialmente.²

Cómo funcionan los Subagents

Cuando Claude encuentra una tarea que se beneficia de atención enfocada—exploración profunda, análisis de múltiples pasos, trabajo especializado—puede generar un subagent. El subagent:

1. Comienza con un contexto limpio (sin contaminación de la conversación principal)
2. Tiene acceso a herramientas especificadas
3. Opera con un modelo específico (frecuentemente más económico/rápido)
4. Retorna resultados a la conversación principal

Esta arquitectura previene el desbordamiento de contexto mientras habilita flujos de trabajo complejos.

Tipos de Subagents integrados

Explore (rápido, solo lectura): - Modelo: Haiku (ultra-rápido) - Modo: Estrictamente solo lectura - Herramientas: Glob, Grep, Read, y comandos bash seguros (ls, git status, git log, git diff, find, cat, head, tail) - Niveles de exhaustividad: Quick, Medium, Very thorough - Usar para: Exploración de código base, encontrar archivos, entender estructura

General-purpose: - Modelo: Sonnet - Modo: Lectura/escritura completa - Herramientas: Todas las herramientas disponibles - Usar para: Tareas complejas de investigación + modificación

Plan: - Modelo: Sonnet (u Opus con opusplan) - Modo: Solo lectura - Herramientas: Read, Glob, Grep, Bash - Usar para: Planificar implementaciones complejas antes de la ejecución

Activando Subagents

Claude delega automáticamente a subagents según el tipo de tarea. También puede solicitarlos explícitamente:

> Use the explore agent to find all authentication-related files

> Have a subagent analyze the database schema thoroughly

> Spawn an agent to research how error handling works in this codebase

Consejo experto: Para tareas complejas, solicite explícitamente la delegación a subagents. “Use an explore agent to find…” previene la inflación de contexto en su conversación principal.

Creando Subagents personalizados

Defina subagents en .claude/agents/ (proyecto) o ~/.claude/agents/ (personal):

---
name: security-reviewer
description: Expert security code reviewer. Use PROACTIVELY after any code changes to authentication, authorization, or data handling.
tools: Read, Grep, Glob, Bash
model: opus
permissionMode: plan
---

You are a senior security engineer reviewing code for vulnerabilities.

When invoked:
1. Identify the files that were recently changed
2. Analyze for OWASP Top 10 vulnerabilities
3. Check for secrets, hardcoded credentials, SQL injection
4. Report findings with severity levels and remediation steps

Focus on actionable security findings, not style issues.

Campos de configuración:

Gestionando Subagents

> /agents                    # Gestión interactiva
> /agents create             # Crear nuevo subagent
> /agents edit               # Modificar existente
> /agents delete             # Eliminar subagent
> /agents list               # Ver todos

Ejecutando Agents en segundo plano

Para tareas de larga duración:

> Run a thorough security review in the background

> /agents  # Check status of running agents

Recupere los resultados más tarde con el ID del agent.

Patrones avanzados

Subagents encadenados:

> First use the code-analyzer subagent to find performance issues, then use the optimizer subagent to fix them

Exploración paralela:

> Have three explore agents search in parallel:
> 1. Authentication code
> 2. Database models
> 3. API routes

Agents reanudables: Los agents pueden reanudarse con su ID para continuar el trabajo previo:

> Resume agent abc123 and continue the analysis

Subagents asíncronos (diciembre 2025)

Los subagents asíncronos habilitan multitarea y ejecución paralela para proyectos de gran escala:

> Run security review in the background while I continue frontend work
> /tasks                    # Check status of running agents

Los agents asíncronos retornan resultados mediante el TaskOutputTool unificado, habilitando flujos de trabajo eficientes estilo pipeline.

Resiliencia ante denegación de permisos (v2.1.0+)

A partir de v2.1.0, los subagents continúan trabajando después de denegaciones de permisos en lugar de detenerse completamente. Cuando un subagent encuentra una barrera de permisos, intenta enfoques alternativos automáticamente. Esto hace que los flujos de trabajo autónomos sean más resilientes y reduce la necesidad de intervención humana.⁴⁷

Agent Skills (diciembre 2025)

Los Agent Skills son carpetas organizadas de instrucciones, scripts y recursos que los agents descubren y cargan dinámicamente.³¹ Proporcionan experiencia de dominio componible y portable:

.claude/skills/
├── security-review/
│   ├── skill.md           # Instructions and prompts
│   ├── checklist.md       # Security checklist
│   └── common-vulns.sh    # Detection scripts
└── performance-audit/
    ├── skill.md
    └── profiling-guide.md

Los skills difieren de los comandos: los comandos se invocan explícitamente, mientras que los skills se auto-activan según el contexto de la tarea. El Claude Agent SDK (renombrado desde Claude Code SDK) proporciona el marco para construir agents personalizados con soporte de skills.³²

¿Qué es el modo Extended Thinking?

Extended thinking le da a Claude más tiempo para razonar a través de problemas complejos antes de responder. Es particularmente valioso para decisiones arquitectónicas, depuración de problemas difíciles y tareas que requieren análisis cuidadoso.

Estado actual (enero 2026)

Extended thinking ahora está habilitado por defecto con un presupuesto de 31,999 tokens—el presupuesto máximo que anteriormente se activaba con “ultrathink”.⁷⁰ Este cambio se realizó porque extended thinking mejora significativamente el rendimiento en tareas complejas de planificación y razonamiento.

Importante: Los activadores en lenguaje natural como “think”, “think hard”, “think harder” y “ultrathink” ya no funcionan. Estas palabras clave ahora se interpretan como instrucciones regulares del prompt y no asignan tokens de pensamiento. El presupuesto de pensamiento se controla exclusivamente mediante la variable de entorno MAX_THINKING_TOKENS o vía /config.⁷⁰

Modelos compatibles

• Claude Opus 4.5
• Claude Sonnet 4.5
• Claude Haiku 4.5

Controlando Extended Thinking

Alternar rápido durante la sesión:

Press Alt+T to toggle thinking on/off

Nota: El alternar de pensamiento se cambió de Tab a Alt+T para evitar activaciones accidentales.³⁹

Vía /config: Navegue a /config → Extended Thinking para habilitar/deshabilitar o ajustar el presupuesto.

Variable de entorno (permanente):

# Set custom budget (default is 31,999)
export MAX_THINKING_TOKENS=8000
claude

# Double the default for complex tasks
export MAX_THINKING_TOKENS=63999
claude

Deshabilitar para ahorrar costos: Para tareas más simples donde no se necesita razonamiento profundo, puede reducir costos deshabilitando thinking en /config o bajando el presupuesto:

export MAX_THINKING_TOKENS=8000  # Reduce from default 31,999

Presupuestos de tokens de pensamiento

Consideración de costos: Los tokens de pensamiento se facturan como tokens de salida. El presupuesto por defecto de 31,999 funciona bien para la mayoría de tareas, pero para operaciones simples puede ahorrar costos reduciendo el presupuesto o deshabilitando thinking completamente.

Cómo funciona

Cuando thinking está habilitado, la respuesta de Claude incluye razonamiento interno que no se muestra en la salida pero influye en la respuesta. El pensamiento está encriptado y se retorna en un campo signature para verificación.

En conversaciones de múltiples turnos con uso de herramientas, los bloques de pensamiento deben pasarse de vuelta a la API para preservar la continuidad del razonamiento. Claude Code maneja esto automáticamente.

Cuándo considerar deshabilitar/reducir

Extended thinking es ahora el valor por defecto, pero considere reducir el presupuesto o deshabilitar para: - Ediciones simples de archivos - Refactorización rutinaria - Preguntas rápidas - Formateo de código - Operaciones de alto volumen donde los costos se acumulan

Comportamiento del caché

El caché del prompt del sistema se preserva cuando los parámetros de thinking cambian. El caché de mensajes se invalida cuando el presupuesto de thinking o el estado habilitado cambian entre turnos.

Estilos de salida

Los estilos de salida personalizan cómo Claude presenta la información—útil para aprendizaje, documentación o preferencias específicas del equipo.¹⁹

Estilos integrados

Configurando el estilo de salida

> /output-style Explanatory
> /output-style Learning

O vía configuración:

{
  "outputStyle": "Explanatory"
}

Estilos de salida personalizados

Cree en .claude/styles/:

# my-style

## Instructions
- Always explain the WHY behind each decision
- Include relevant documentation links
- Format code examples with comments
- End with a "What to do next" section

## Format
Use markdown headers for organization.
Keep explanations under 200 words per section.

Invoque con /output-style my-style.

Comandos de Barra (Slash Commands)

Los comandos de barra proporcionan acceso rápido a las funciones de Claude Code y permiten flujos de trabajo personalizados. Son más rápidos que escribir indicaciones completas para operaciones comunes.

Referencia de Comandos Integrados

Creación de Comandos Personalizados

Cree comandos reutilizables en .claude/commands/ (proyecto) o ~/.claude/commands/ (personal):

---
description: Security-focused code review
allowed-tools: Read, Grep, Glob
model: claude-sonnet-4-5
---

Review this code for security vulnerabilities:

1. Injection attacks (SQL, command, XSS)
2. Authentication and authorization flaws
3. Sensitive data exposure
4. Insecure dependencies

Focus on actionable findings with specific line references.

Guárdelo como .claude/commands/security-review.md, invóquelo con /security-review.

Opciones de Frontmatter de Comandos

---
description: Brief description for /help
allowed-tools: Read, Edit, Bash(npm:*)
model: opus
argument-hint: [arg1] [arg2]
disable-model-invocation: false
---

Interpolación de Argumentos

Todos los argumentos como cadena única:

---
description: Fix GitHub issue
argument-hint: [issue-number]
---

Fix GitHub issue #$ARGUMENTS following our coding standards.

Uso: /fix-issue 123

Argumentos numerados:

---
description: Create component
argument-hint: [name] [type]
---

Create a new $2 component named $1 in src/components/.

Uso: /create-component Button functional

Ejecución de Bash en Línea

Ejecute comandos bash dentro de indicaciones de comando:

---
description: Git status summary
allowed-tools: Bash(git:*)
---

Current branch: !`git branch --show-current`
Recent commits: !`git log --oneline -5`
Changed files: !`git status --short`

Summarize the current state of this repository.

Referencias de Archivos

Incluya contenido de archivos en comandos:

---
description: Compare implementations
---

Compare these files:
@src/v1/handler.ts
@src/v2/handler.ts

Which implementation is more maintainable?

Espacio de Nombres de Comandos

Organice comandos en subdirectorios:

.claude/commands/
├── backend/
│   ├── test.md
│   └── deploy.md
├── frontend/
│   ├── test.md
│   └── build.md
└── review.md

Los comandos con el mismo nombre muestran su espacio de nombres en la ayuda: /test (project:backend) vs /test (project:frontend).

¿Cómo Funcionan los Skills?

Los skills representan un enfoque fundamentalmente diferente para extender Claude Code. A diferencia de los comandos de barra que usted invoca explícitamente, los skills son invocados por el modelo—Claude los descubre y usa automáticamente según el contexto. Usted incorpora experiencia de dominio en un skill, y Claude recurre a esa experiencia cuando la situación lo requiere, sin que usted necesite recordar preguntar.

Por qué los skills cambian todo: Considere la experiencia de dominio—las reglas de procesamiento de pagos, los requisitos de cumplimiento, los patrones arquitectónicos que su equipo ha refinado durante años. Sin skills, usted re-explica este contexto en cada sesión o espera que Claude lo infiera de los comentarios del código. Con skills, lo codifica una vez. Claude lee la definición del skill y aplica esa experiencia automáticamente cuando sea relevante. Sus desarrolladores junior reciben orientación de nivel senior sin pedirla. Sus patrones de seguridad se aplican sin recordar invocarlos.

Esta distinción importa. Un comando de barra es un atajo que usted recuerda usar. Un skill es conocimiento que Claude siempre tiene disponible. Cuando crea un skill de revisión de seguridad con los patrones de vulnerabilidad específicos de su equipo y los requisitos de cumplimiento, Claude aplica esa experiencia cada vez que encuentra código relevante—durante revisiones de PR, refactorización, o cualquier tarea donde la seguridad importa. Usted no invoca /security-review; Claude reconoce el contexto y aplica el skill automáticamente.

Skills vs Comandos vs Subagentes

Comprender cuándo usar cada mecanismo de extensión previene duplicación y maximiza la efectividad:

Use comandos de barra cuando quiera control explícito: /deploy, /test, /review PR 456. Usted decide cuándo ejecutarlos.

Use skills cuando la experiencia debe estar disponible automáticamente: patrones de seguridad, aplicación de estilo de código, conocimiento específico de dominio. Claude decide cuándo aplicarlos.

Use subagentes cuando las tareas necesitan aislamiento: exploración en segundo plano, análisis paralelo, razonamiento especializado que no debe contaminar su conversación principal.

Estructura y Ubicación de Skills

Los skills residen en directorios dedicados que contienen un archivo SKILL.md requerido más recursos de soporte opcionales:

Skills personales (disponibles en todos sus proyectos):

~/.claude/skills/
├── code-reviewer/
│   ├── SKILL.md
│   ├── SECURITY_PATTERNS.md
│   └── PERFORMANCE_CHECKLIST.md
├── sql-analyst/
│   ├── SKILL.md
│   └── QUERY_PATTERNS.md
└── api-designer/
    └── SKILL.md

Skills de proyecto (compartidos con el equipo vía git):

.claude/skills/
├── domain-expert/
│   ├── SKILL.md
│   ├── BUSINESS_RULES.md
│   └── DATA_MODELS.md
└── deployment/
    ├── SKILL.md
    └── RUNBOOKS.md

Los skills de proyecto se guardan en control de versiones. Cuando los compañeros de equipo hacen pull, obtienen sus skills automáticamente—sin instalación, sin configuración. Así es como estandariza la experiencia en un equipo.

Formato de SKILL.md

Cada skill requiere un archivo SKILL.md con frontmatter YAML:

---
name: code-reviewer
description: Review code for security vulnerabilities, performance issues, and best practice violations. Use when examining code changes, reviewing PRs, analyzing code quality, or when asked to review or audit code.
allowed-tools: Read, Grep, Glob
---

# Code Review Expertise

## Security Analysis

When reviewing code, check for:

### Input Validation
- All user input sanitized before use
- Parameterized queries for database operations
- Output encoding for rendered content

### Authentication & Authorization
- Session tokens properly validated
- Permission checks before sensitive operations
- No hardcoded credentials or API keys

### Data Exposure
- Sensitive data not logged
- PII properly masked in error messages
- API responses don't leak internal details

## Performance Patterns

### Database
- N+1 query detection
- Missing indexes on filtered columns
- Unbounded result sets

### Memory
- Large object lifecycle management
- Stream processing for big files
- Connection pool exhaustion risks

## Formato de Salida de Revisión

Para cada hallazgo:
- **Archivo**: path/to/file.ts:123
- **Gravedad**: Crítica | Alta | Media | Baja
- **Categoría**: Seguridad | Rendimiento | Mantenibilidad
- **Problema**: Descripción clara del problema
- **Recomendación**: Corrección específica con ejemplo de código
- **Justificación**: Por qué esto es importante

Consulte [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md) para patrones detallados de vulnerabilidades.
Consulte [PERFORMANCE_CHECKLIST.md](PERFORMANCE_CHECKLIST.md) para directrices de optimización.

Referencia de Frontmatter

Sustituciones de Cadenas (v2.1.9+): Los skills pueden acceder al contexto de sesión usando la sustitución ${CLAUDE_SESSION_ID}. Útil para registro, seguimiento o generación de salidas específicas de sesión.⁵¹

El campo description es crítico. Claude descubre skills comparando sus solicitudes con las descripciones de skills. Una descripción vaga significa que Claude no reconocerá cuándo usar el skill. Una descripción específica con condiciones de activación claras significa activación confiable.

Descripción deficiente:

description: Helps with code

Descripción efectiva:

description: Review code for security vulnerabilities, performance issues, and best practice violations. Use when examining code changes, reviewing PRs, analyzing code quality, or when asked to review, audit, or check code.

La descripción efectiva incluye: - Qué hace el skill (revisar código para problemas específicos) - Cuándo usarlo (examinar cambios, PRs, análisis de calidad) - Frases de activación (review, audit, check)

Restricciones de Herramientas

El campo allowed-tools limita lo que Claude puede hacer cuando un skill está activo. Esto es esencial para skills que deben ser de solo lectura o de alcance limitado:

---
name: security-auditor
description: Audit code for security vulnerabilities without making changes
allowed-tools: Read, Grep, Glob
---

Con esta configuración, Claude puede analizar código pero no puede editar archivos, ejecutar comandos bash ni realizar modificaciones. El skill impone comportamiento de solo lectura.

Patrones comunes de restricción:

Archivos de Soporte

Los skills pueden incluir múltiples archivos. Claude lee el SKILL.md principal al activarse, luego accede a los archivos de soporte según sea necesario—divulgación progresiva que gestiona el contexto eficientemente.

Patrón de estructura:

my-skill/
├── SKILL.md           # Requerido: resumen + referencia rápida
├── DETAILED_GUIDE.md  # Documentación detallada
├── EXAMPLES.md        # Ejemplos concretos
├── PATTERNS.md        # Patrones de referencia
├── templates/         # Plantillas reutilizables
│   └── component.tsx
└── scripts/           # Utilidades auxiliares
    └── validate.py

Referenciar archivos de soporte desde SKILL.md:

For detailed security patterns, see [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md).

Use this template for new components:
@templates/component.tsx

Validate configurations with:
```bash
python scripts/validate.py config.json

**Consejo experto:** Coloque la información esencial directamente en SKILL.md. Reserve los archivos de soporte para material de referencia profunda. Claude lee SKILL.md inmediatamente pero solo accede a los archivos de soporte cuando es necesario. Si la información crítica está enterrada en un archivo de soporte, Claude podría no encontrarla.

### Ejemplo Completo: Skill de Experto en Dominio

Aquí hay un skill de calidad de producción para una aplicación fintech:

**Estructura de directorios:**

.claude/skills/payments-domain/ ├── SKILL.md ├── BUSINESS_RULES.md ├── COMPLIANCE.md └── DATA_MODELS.md

**SKILL.md:**
```markdown
---
name: payments-domain
description: Expert knowledge of payment processing domain including transaction flows, compliance requirements, and business rules. Use when working with payment code, transaction handling, refunds, disputes, or financial calculations.
---

# Payments Domain Expertise

## Core Concepts

### Transaction States

PENDING → AUTHORIZED → CAPTURED → SETTLED ↘ VOIDED AUTHORIZED → DECLINED CAPTURED → REFUNDED (partial or full) SETTLED → CHARGEBACK → REPRESENTED

### Money Handling Rules
- ALL monetary values stored as integers (cents, not dollars)
- Currency always explicitly tracked (never assume USD)
- Rounding: HALF_EVEN for calculations, HALF_UP for display
- Never use floating point for money

### Idempotency Requirements
Every payment operation MUST be idempotent:
```typescript
// Required pattern
async function processPayment(idempotencyKey: string, amount: number) {
  const existing = await findByIdempotencyKey(idempotencyKey);
  if (existing) return existing; // Return cached result

  const result = await executePayment(amount);
  await storeWithIdempotencyKey(idempotencyKey, result);
  return result;
}

Quick Reference

Fee Calculations

• Interchange: 1.5% + $0.10 (debit), 2.1% + $0.10 (credit)
• Platform fee: 2.9% + $0.30 (standard), 2.2% + $0.30 (enterprise)
• International: +1% cross-border fee
• Currency conversion: mid-market rate + 1%

Compliance Thresholds

• $3,000: Enhanced due diligence trigger
• $10,000: CTR filing required
• $25,000: Additional verification required

Refund Windows

• Full refund: 120 days from capture
• Partial refund: 180 days from capture
• Chargeback window: 120 days (Visa), 180 days (Mastercard)

Key Files

• src/payments/processor.ts - Core payment logic
• src/payments/refunds.ts - Refund handling
• src/compliance/aml.ts - AML checks
• src/models/transaction.ts - Transaction model

See BUSINESS_RULES.md for detailed business logic. See COMPLIANCE.md for regulatory requirements. See DATA_MODELS.md for schema documentation.

Con este skill implementado, Claude aplica automáticamente la experiencia del dominio de pagos cuando trabaja en código de transacciones, pregunta sobre lógica de reembolsos o depura flujos de pago. No invoca nada—la experiencia simplemente está ahí.

### Creando Skills Efectivos

**Comience con la descripción.** Escriba la descripción primero, luego construya el contenido del skill para que coincida. La descripción determina cuándo Claude usa el skill, así que hágalo bien:

1. Indique qué proporciona el skill
2. Liste condiciones de activación específicas
3. Incluya palabras clave y frases relevantes

**Mantenga los skills enfocados.** Un skill debe cubrir un dominio o capacidad:

| Bueno (enfocado) | Malo (demasiado amplio) |
|------------------|-------------------------|
| `security-auditor` | `code-helper` |
| `react-patterns` | `frontend-stuff` |
| `postgres-optimization` | `database-expert` |
| `api-documentation` | `docs-generator` |

Si un skill intenta cubrir demasiado, su descripción se vuelve vaga y Claude no reconocerá confiablemente cuándo usarlo.

**Use divulgación progresiva.** Coloque la información más importante directamente en SKILL.md. Referencie archivos de soporte para profundidad:

```markdown

## Quick Reference
[Essential patterns here - Claude sees this immediately]

## Deep Dive
For comprehensive coverage, see [DETAILED_GUIDE.md](DETAILED_GUIDE.md).

Incluya ejemplos concretos. Las descripciones abstractas son menos útiles que los patrones concretos:

## Input Validation

### Pattern
```typescript
// Good: Explicit validation with typed errors
const validated = PaymentSchema.safeParse(input);
if (!validated.success) {
  throw new ValidationError(validated.error.issues);
}

// Bad: Implicit coercion
const amount = Number(input.amount); // Silent NaN on invalid input

**Pruebe con solicitudes realistas.** Después de crear un skill, pruebe si Claude lo activa:

Review this payment processing code for issues

Should activate payments-domain skill

How should I handle refunds?

Should activate payments-domain skill

What’s the weather like?

Should NOT activate payments-domain skill

Si Claude no activa el skill cuando se espera, revise la descripción para incluir las frases de activación que está usando.

### Estrategias de Compartición en Equipo

**Compartición basada en Git (recomendada para skills de proyecto):**
```bash
# Add skill to project
mkdir -p .claude/skills/team-standard
# Create SKILL.md and supporting files

# Commit
git add .claude/skills/
git commit -m "Add team coding standards skill"
git push

# Teammates get it automatically
git pull
claude  # Skill now available

Compartición entre proyectos mediante enlaces simbólicos:

# Create canonical skill location
mkdir -p ~/shared-skills/security-reviewer
# Create SKILL.md

# Symlink into projects
ln -s ~/shared-skills/security-reviewer ~/.claude/skills/security-reviewer
# Now available in all your projects

Distribución mediante plugins: Para distribución más amplia, empaquete skills en plugins:

my-plugin/
├── .claude-plugin/
│   └── plugin.json
└── skills/
    └── my-skill/
        └── SKILL.md

Los skills incluidos en plugins quedan disponibles cuando los usuarios instalan el plugin.

Depuración de Skills

El skill no se activa:

1. Verifique que la descripción coincida con su solicitud: yaml # If you're saying "check this code" but description says "review" description: Review OR check code for issues...

2. Verifique la ubicación del archivo: ```bash # Personal ls ~/.claude/skills/my-skill/SKILL.md

# Project ls .claude/skills/my-skill/SKILL.md ```

1. Valide el frontmatter YAML:
2. La primera línea debe ser exactamente ---
3. --- de cierre antes del contenido markdown
4. Sin tabulaciones en YAML (use espacios)

5. El campo name debe ser minúsculas solo con guiones

6. Ejecute en modo de depuración: bash claude --debug # Watch for skill loading messages

El skill se activa inesperadamente:

Reduzca la descripción. Si su skill se activa cuando no debería, la descripción es demasiado amplia:

# Too broad - activates on any "code" mention
description: Help with code

# Specific - activates only for security contexts
description: Audit code for security vulnerabilities including injection attacks, authentication flaws, and data exposure. Use when specifically asked about security, vulnerabilities, or when reviewing code for security issues.

Archivos de soporte no encontrados:

• Use rutas relativas desde la ubicación de SKILL.md
• Solo barras diagonales (incluso en Windows)
• Verifique que el archivo realmente existe: ls .claude/skills/my-skill/REFERENCED.md

Cuándo Crear un Skill

Cree un skill cuando: - La experiencia del dominio debe estar disponible automáticamente - Múltiples miembros del equipo necesitan el mismo conocimiento - Está explicando repetidamente los mismos patrones o reglas - El contexto debe inyectarse sin invocación explícita - El conocimiento abarca múltiples archivos y necesita organización

No cree un skill cuando: - Quiere control explícito sobre la invocación (use comando slash) - La tarea necesita contexto separado (use subagent) - Es un prompt de una sola vez (simplemente escríbalo) - El “skill” es realmente solo una plantilla única (use comando slash)

Consejo experto: Si se encuentra escribiendo repetidamente /security-review antes de trabajar en código de autenticación, conviértalo en un skill. La experiencia debe ser ambiental, no invocada explícitamente. Si quiere invocación explícita, manténgalo como comando.

Sistema de Plugins

Los plugins empaquetan extensiones de Claude Code para su distribución. Un plugin puede incluir comandos personalizados, subagentes, skills, hooks y servidores MCP. Anthropic lanzó oficialmente el marketplace de plugins en diciembre de 2025 con 36 plugins curados.⁴⁷

Estructura de Plugins

my-plugin/
├── .claude-plugin/
│   └── plugin.json              # Required: metadata
├── commands/                     # Slash commands
│   └── hello.md
├── agents/                       # Subagents
│   └── helper.md
├── skills/                       # Skills
│   └── my-skill/
│       └── SKILL.md
├── hooks/                        # Event handlers
│   └── hooks.json
└── .mcp.json                     # MCP servers

Manifiesto del Plugin

plugin.json mínimo:

{
  "name": "my-plugin",
  "description": "What this plugin does",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

Gestión de Plugins

> /plugin                              # Interactive interface
> /plugin install name@marketplace     # Install
> /plugin enable name@marketplace      # Enable
> /plugin disable name@marketplace     # Disable
> /plugin uninstall name@marketplace   # Remove
> /plugin marketplace add ./local      # Add local marketplace
> /plugin marketplace list             # View marketplaces

Desarrollo Local

Cree un marketplace local para pruebas:

mkdir dev-marketplace && cd dev-marketplace
mkdir my-plugin
# Create plugin structure

cd ..
claude
> /plugin marketplace add ./dev-marketplace
> /plugin install my-plugin@dev-marketplace

Componentes de Plugins

• Commands: Disponibles como comandos slash (/plugin-command)
• Agents: Aparecen en la lista /agents
• Skills: Se cargan automáticamente según la configuración del skill
• Hooks: Se combinan con los hooks de usuario/proyecto, se ejecutan en paralelo
• MCP Servers: Se inician automáticamente cuando el plugin está habilitado

¿Cómo Funciona la Memoria?

El sistema de memoria de Claude Code permite contexto persistente entre sesiones. La gestión efectiva de la memoria es la diferencia entre que Claude comprenda su proyecto profundamente y que trate cada sesión como un inicio desde cero.

Jerarquía de CLAUDE.md

Estructura Efectiva de CLAUDE.md

# Project Context

## Architecture
- Monorepo with packages in /packages
- React frontend in /packages/ui
- Node.js API in /packages/api
- Shared types in /packages/types
- PostgreSQL database via Prisma

## Code Standards
- TypeScript strict mode everywhere
- ESLint + Prettier enforced (pre-commit hooks)
- No default exports
- JSDoc on all public APIs
- Tests required for all new code

## Commands
- `npm test` - Run all tests
- `npm run test:watch` - Watch mode
- `npm run lint` - Check linting
- `npm run lint:fix` - Auto-fix lint issues
- `npm run build` - Production build
- `npm run dev` - Start dev servers
- `npm run db:migrate` - Run migrations
- `npm run db:seed` - Seed database

## Patterns

### API Endpoints
Create in packages/api/src/routes/
Use Zod for request/response validation
All endpoints need OpenAPI documentation

### React Components
Create in packages/ui/src/components/
Use React Query for server state
Prefer composition over inheritance

### Database
Prisma schema in packages/api/prisma/
Always create migration for schema changes
Use transactions for multi-table operations

## Important Notes
- NEVER commit .env files
- API runs on :3000, UI on :3001
- Local DB: postgres://localhost:5432/myapp
- Feature flags in packages/api/src/flags.ts

## Recent Decisions
- 2025-12-01: Migrated to React Query v5
- 2025-11-15: Adopted Zod for all validation
- 2025-11-01: Moved to ESM modules

# Summary Instructions
When using compact, focus on:
- Recent code changes
- Test results
- Architecture decisions made this session

Importación de Archivos

Haga referencia a otros archivos dentro de CLAUDE.md:

See @README.md for project overview
Coding standards: @docs/STYLE_GUIDE.md
API documentation: @docs/API.md
Personal preferences: @~/.claude/preferences.md

Sintaxis de importación: - Relativa: @docs/file.md - Absoluta desde el proyecto: @/absolute/path.md - Directorio home: @~/.claude/file.md - Profundidad máxima: 5 niveles de importaciones

Directorio de Reglas de Memoria

Para una memoria más organizada, use .claude/rules/ para almacenar archivos de reglas categorizados:¹⁸

.claude/rules/
├── testing.md          # Testing conventions
├── security.md         # Security requirements
├── api-patterns.md     # API design patterns
└── deployments.md      # Deployment procedures

Las reglas se cargan automáticamente y proporcionan contexto estructurado sin saturar CLAUDE.md.

Adición Rápida de Memoria

Use el prefijo # para agregar notas durante una sesión:

# Always run tests before committing
# The payment module is especially fragile
# Use the new logger from packages/api/src/logger.ts

Se le pedirá que seleccione en qué archivo de memoria almacenar la nota.

Comandos de Gestión de Contexto

Ver uso del contexto:

> /context

Muestra una cuadrícula visual de la asignación de contexto entre el prompt del sistema, la conversación, las herramientas y el contenido de archivos.

Compactar conversación:

> /compact
> /compact focus on the authentication changes
> /compact preserve test output and error messages

Resume inteligentemente la conversación anterior mientras preserva la información clave.

Instrucciones de compactación personalizadas (en CLAUDE.md):

# Summary Instructions
When using compact, focus on:
- Test output and failures
- Code changes made this session
- Architecture decisions

Pensamiento extendido para contexto:

export MAX_THINKING_TOKENS=10000

Más tokens de pensamiento significa mayor capacidad de razonamiento pero costos más altos.

Estrategias de Optimización de Contexto

1. Use referencias de archivos específicas en lugar de pedir a Claude que busque
2. Limpie conversaciones no relacionadas con /clear entre tareas
3. Compacte proactivamente durante sesiones largas
4. Use subagentes para aislar trabajo exploratorio
5. Divida tareas complejas en interacciones enfocadas
6. Reanude sesiones para trabajo en curso en lugar de volver a explicar

Entrada de Imágenes y Multimodal

Claude Code puede analizar imágenes—capturas de pantalla, diagramas, mockups, mensajes de error, esquemas de bases de datos.

Métodos de Entrada

1. Arrastrar y soltar: Arrastre archivos de imagen a la ventana de Claude Code
2. Pegar: Ctrl+V (no Cmd+V en Mac) para pegar desde el portapapeles
3. Referencia de ruta: “Analiza esta imagen: /path/to/screenshot.png”

Visualización de Imágenes Adjuntas

Cuando Claude hace referencia a una imagen en su respuesta, los enlaces de imagen clicables permiten la visualización directa:³⁴

[Image #1]   # Click to open in default image viewer
[Image #2]   # Navigate attached screenshots

Esto es útil al revisar capturas de pantalla o depurar problemas visuales—haga clic en la referencia para ver exactamente lo que Claude analizó.

Casos de Uso

• Depurar problemas de UI: “Aquí hay una captura de pantalla del error, ¿qué lo está causando?”
• Implementar diseños: “Construye este componente basándote en el mockup”
• Analizar diagramas: “Explica este diagrama de arquitectura”
• Esquemas de bases de datos: “Crea modelos de Prisma que coincidan con este ERD”
• Análisis de errores: “¿Qué significa esta captura de pantalla de error?”

Consejo experto: Al implementar desde mockups, incluya múltiples capturas de pantalla mostrando diferentes estados (predeterminado, hover, cargando, error). Cuanto más contexto visual, mejor la implementación.

¿Cómo Funciona la Integración con Git?

Claude Code tiene una integración profunda con git con protocolos de seguridad incorporados.

Protocolos de Seguridad

• Respeta .gitignore automáticamente
• No modificará ramas sin permiso
• Muestra diffs antes de los commits
• Sigue las convenciones de commit del proyecto
• Nunca hace force push sin solicitud explícita
• Verifica la autoría antes de enmendar commits

Flujos de Trabajo Comunes

Crear commits:

> commit these changes
> create a commit with a meaningful message

Claude: 1. Ejecutará git status y git diff 2. Analizará los cambios 3. Generará un mensaje de commit convencional 4. Esperará aprobación antes de hacer commit

Crear pull requests:

> create a PR for this feature
> summarize the changes and create a PR

Revisar código:

> review the changes in this PR
> what could go wrong with these changes?

Integración con GitHub Actions

Automatice Claude en CI/CD con la action oficial:

Configuración rápida:

> /install-github-app

Archivo de workflow manual:

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: "Review this PR for bugs, security issues, and performance problems"
          claude_args: "--max-turns 5"

Para Bedrock (con OIDC):

- name: Configure AWS
  uses: aws-actions/configure-aws-credentials@v4
  with:
    role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}
    aws-region: us-west-2

- uses: anthropics/claude-code-action@v1
  with:
    use_bedrock: "true"
    claude_args: '--model us.anthropic.claude-sonnet-4-5-20250929-v1:0'

¿Cómo Uso Claude Code en Mi IDE?

Extensión de VS Code

Requisitos: VS Code 1.98.0+

Instalación: Busque “Claude Code” en el marketplace de Extensions

Características: - Panel lateral (ícono de Spark) - Modo plan con vista previa de diff - Alternador de auto-aceptar ediciones - Alternador de pensamiento extendido - Adjuntar archivos y pegar imágenes - Historial de conversaciones - Múltiples sesiones simultáneas

Nota de Seguridad: Una vulnerabilidad de bypass de autenticación WebSocket (CVE-2025-52882) fue parcheada en las extensiones de IDE v1.0.24+. Asegúrese de que su extensión esté actualizada—todas las versiones vulnerables han sido removidas de las tiendas de extensiones.³⁸

Configuración de proveedores de terceros (en .claude/settings.json):

{
  "env": {
    "CLAUDE_CODE_USE_BEDROCK": "1",
    "AWS_REGION": "us-east-1",
    "AWS_PROFILE": "your-profile"
  }
}

Plugin de JetBrains

Soportados: IntelliJ IDEA, PyCharm, WebStorm, GoLand, PhpStorm, DataGrip

Instalación: Settings → Plugins → Buscar “Claude Code” → Install → Reiniciar

Atajos de teclado: - Cmd+Esc (Mac) / Ctrl+Esc (Windows): Inicio rápido - Cmd+Option+K (Mac) / Alt+Ctrl+K (Windows): Agregar referencia de archivo

Características: - Visualización de diff en el visor de diff del IDE - Compartición automática de contexto de selección - Integración de diagnósticos - Múltiples sesiones

Configuración WSL2: Configure el comando de Claude como:

wsl -d Ubuntu -- bash -lic "claude"

Integración de Terminal

Conecte un terminal externo a su IDE:

> /ide

Claude Code detecta automáticamente VS Code, Cursor, Windsurf e IDEs de JetBrains.

Integración con Slack (Diciembre 2025)

Claude Code ahora se integra directamente con Slack, permitiendo a los desarrolladores delegar tareas de codificación desde hilos de chat.¹⁴

Cómo funciona: 1. Mencione @Claude en un canal o hilo de Slack 2. Claude revisa el mensaje para determinar si es una tarea de codificación 3. Una sesión de Claude Code se inicia automáticamente en la infraestructura de Anthropic 4. Claude recopila contexto de mensajes recientes del canal/hilo 5. Las actualizaciones de progreso se publican en su hilo de Slack 6. Se proporcionan enlaces para revisar cambios y abrir PRs al completar

Casos de uso: - Investigación de bugs a partir de reportes publicados en Slack - Revisiones rápidas de código basadas en feedback del equipo - Implementaciones pequeñas de características a partir de solicitudes de funciones

Requisitos: - App de Claude instalada vía Slack App Marketplace - Plan de Slack de pago - Acceso a Claude Code en la web

Privacidad: Claude respeta la estructura de permisos existente de Slack. No puede acceder a conversaciones o repositorios para los que usted no esté autorizado. Las conversaciones no se utilizan para entrenar el modelo.

Patrones de uso avanzado

Modo headless y CI

Ejecute Claude Code en scripts y pipelines de CI:

#!/bin/bash
# Automated code review

result=$(claude -p "Review this code for quality issues" \
  --output-format json \
  --allowedTools "Read,Grep,Glob" \
  --permission-mode plan \
  --disable-slash-commands \
  --max-turns 5)

if echo "$result" | jq -e '.result | test("critical|high severity")' > /dev/null; then
  echo "Issues found:"
  echo "$result" | jq -r '.result'
  exit 1
fi

echo "Review passed"
exit 0

Piping y encadenamiento

# Analyze logs
cat production.log | claude -p "summarize errors" > error-summary.md

# Process multiple files
find . -name "*.ts" -exec cat {} \; | claude -p "find security issues"

# Chain with jq
claude -p "generate config" --output-format json | jq -r '.result' > config.json

Tareas en segundo plano

Ejecute operaciones prolongadas sin bloquear:

> start the build in the background

O presione Ctrl+B durante la ejecución de un comando.

Administre tareas en segundo plano:

> /bashes                    # List running tasks
> get output from task xyz   # Retrieve output

Sesiones paralelas con Git Worktrees

# Create worktrees for parallel work
git worktree add ../project-feature-a -b feature-a
git worktree add ../project-bugfix bugfix-123

# Run Claude in each
cd ../project-feature-a && claude --session-id "feature-a"
cd ../project-bugfix && claude --session-id "bugfix-123"

Cada worktree es un directorio de proyecto independiente con su propia sesión.

Análisis de salida JSON

result=$(claude -p "analyze this code" --output-format json)

# Extract fields
echo "Result: $(echo $result | jq -r '.result')"
echo "Cost: $(echo $result | jq -r '.total_cost_usd')"
echo "Session: $(echo $result | jq -r '.session_id')"
echo "Duration: $(echo $result | jq -r '.duration_ms')ms"

Gestión programática de sesiones

# Named sessions for tracking
claude --session-id "feature-$(git branch --show-current)-$(date +%s)"

# Continue previous work
claude -c "continue implementing the tests"

# Fork for parallel exploration
claude -r "main-session" --fork-session "try alternative approach"

¿Qué es Claude Code Remote?

Claude Code Remote conecta la web con la terminal, permitiéndole iniciar tareas en la nube y continuarlas localmente, o viceversa. Esta función transforma la forma en que trabaja entre dispositivos.

El concepto central

La interfaz web en claude.ai/code ejecuta Claude Code en la nube. Las tareas se ejecutan en segundo plano mientras usted está lejos de su terminal. Cuando esté listo para continuar, teletransporte la sesión a su máquina local y retome exactamente donde Claude se detuvo.

Esto habilita flujos de trabajo que antes no eran posibles: - Inicie una refactorización compleja desde su teléfono, déjela ejecutarse mientras viaja al trabajo y luego finalícela en su estación de trabajo - Ponga en cola múltiples tareas en la interfaz web y revise los resultados cuando regrese a su escritorio - Delegue operaciones de larga duración a la nube cuando necesite cerrar su computadora portátil

El prefijo &

Envíe una tarea para que se ejecute en Claude Code web en segundo plano:

& Build a comprehensive REST API for user management with authentication, CRUD operations, and proper error handling

El prefijo & envía su prompt a la nube. Claude trabaja en ello de forma asíncrona: puede cerrar su terminal, cambiar de dispositivo o continuar con otro trabajo. La interfaz web en claude.ai/code muestra sus sesiones en ejecución y completadas.

La flag --teleport

Traiga una sesión de la nube a su terminal local:

claude --teleport session_abc123

Esto recupera el estado de la sesión desde la web y la reanuda localmente. Obtiene el historial completo de la conversación, cualquier archivo que Claude haya modificado, y puede continuar la interacción como si hubiera estado presente todo el tiempo.

El ID de sesión aparece en la interfaz web. Haga clic en cualquier sesión para ver su ID y estado actual.

Requisitos

Claude Code Remote está disponible para suscriptores de Pro, Max, Team (asientos premium) y Enterprise (asientos premium).⁷³ La interfaz web se ejecuta en la infraestructura de Anthropic, ejecutando las mismas capacidades de Claude Code que tiene localmente—operaciones de archivos, comandos bash, integraciones MCP—pero en un entorno administrado en la nube. El acceso para Team y Enterprise se amplió en enero de 2026: los administradores de cuentas pueden activar el acceso en la configuración de Claude.

Aplicación iOS (noviembre 2025): Claude Code también está disponible en la aplicación iOS de Claude, lo que le permite iniciar tareas de codificación en cualquier lugar y monitorear el progreso del agente desde su teléfono.²² Puede iniciar tareas mientras está lejos de su escritorio y luego teletransportarlas a su terminal cuando esté listo para revisarlas.

Flujo de trabajo práctico

En el trayecto matutino:

& Review all PRs assigned to me and prepare summaries with recommendations

En su escritorio:

# Check what completed
# Visit claude.ai/code to see session list

# Pull the session locally to review and act on recommendations
claude --teleport pr-review-session-xyz

Antes de salir del trabajo:

& Run the full test suite, fix any failures, and prepare a summary of what was changed

A la mañana siguiente:

claude --teleport test-fixes-session-abc
# Review what Claude did overnight, make final adjustments

Estado actual

Claude Code Remote se encuentra actualmente en versión preliminar de investigación. Espere que la función evolucione a medida que Anthropic recopila retroalimentación. El flujo de trabajo central—ejecución en la nube con teletransportación local—permite el desarrollo continuo con IA: Claude trabaja mientras usted está lejos de su teclado, y retoma exactamente donde lo dejó.

Limitación actual: La teletransportación de sesiones actualmente es solo unidireccional: puede traer sesiones web a su terminal, pero no puede enviar una sesión de terminal existente a la web. Aún no existe la posibilidad de continuar una sesión local en una máquina remota (por ejemplo, una instancia de AWS vía SSH).

¿Qué son los agentes en segundo plano?

Los agentes en segundo plano se ejecutan mientras usted continúa trabajando, sin necesidad de esperar a que las tareas de larga duración se completen.¹⁷

Cómo funcionan los agentes en segundo plano

En lugar de bloquear su terminal mientras Claude ejecuta una tarea compleja, los agentes en segundo plano: 1. Se ejecutan de forma independiente en un proceso separado 2. Continúan trabajando incluso si cierra su terminal 3. Informan los resultados cuando terminan mediante una notificación 4. Pueden ser monitoreados y administrados mientras se ejecutan

Iniciar un agente en segundo plano

Usando Ctrl+B: Mientras Claude está trabajando, presione Ctrl+B para enviar la tarea actual al segundo plano. Su terminal queda disponible inmediatamente.

Usando el prefijo &:

& Run all tests and fix any failures
& Refactor the authentication module to use JWT
& Generate comprehensive API documentation

El prefijo & envía la tarea a Claude Code Remote (ejecución en la nube). Para ejecución local en segundo plano, use Ctrl+B en una tarea que ya esté en ejecución.

Monitoreo de tareas en segundo plano

> /tasks                    # List all running tasks
> /task status abc123       # Check specific task
> /task cancel abc123       # Stop a task
> /task output abc123       # View task output so far

Flujos de trabajo paralelos en segundo plano

Ejecute múltiples agentes simultáneamente:

& Fix all failing tests in src/
& Update documentation for the API module
& Run security scan on the codebase

Cada uno se ejecuta de forma independiente. Monitoree el progreso con /tasks y obtenga los resultados a medida que se completan.

Claude in Chrome (diciembre 2025)

Claude Code ahora se integra con su navegador a través de la extensión Claude in Chrome, permitiendo el control directo del navegador desde su terminal.²⁴

Configuración

1. Instale la extensión de Chrome desde https://claude.ai/chrome
2. Inicie Claude Code y la integración se detecta automáticamente
3. Use lenguaje natural para controlar su navegador

Capacidades

Automatización del navegador desde la terminal:

> Navigate to github.com and open my repositories
> Fill out this form with the test user data
> Take a screenshot of the current page
> Click the submit button and wait for the page to load

Web scraping y pruebas:

> Extract all product prices from this e-commerce page
> Run through the signup flow and report any issues
> Check if the mobile menu works correctly

Casos de uso

• Pruebas E2E: Ejecute pruebas de integración directamente desde Claude Code
• Web scraping: Extraiga datos de páginas sin escribir código de automatización de navegador
• Llenado de formularios: Automatice flujos de trabajo web repetitivos
• Verificación visual: Capture pantallas y analice diseños de página

La integración con Chrome se ejecuta dentro de su sesión de navegador existente, accediendo a su estado de inicio de sesión y cookies, lo cual es útil para probar flujos autenticados.

Claude Code en Slack (diciembre 2025)

Anthropic lanzó Claude Code en Slack, permitiendo a los desarrolladores delegar tareas de codificación directamente desde hilos de chat.²⁶

Cómo funciona

1. Etiquete a @Claude en cualquier canal o hilo de Slack
2. Describa la tarea de codificación con contexto
3. Claude analiza los mensajes de Slack para determinar el repositorio
4. Las actualizaciones de progreso aparecen en el hilo
5. Claude comparte enlaces para revisar el trabajo y abrir PRs

Ejemplo de flujo de trabajo

@Claude The login form validation is broken on mobile devices.
Can you fix it? Check the bug report from earlier in this thread.

Claude realizará lo siguiente: 1. Leerá el hilo en busca de contexto 2. Identificará el repositorio relevante 3. Clonará y analizará el código base 4. Publicará actualizaciones de progreso 5. Creará un PR con la corrección 6. Compartirá el enlace del PR para revisión

Beneficios

• Reconocimiento de contexto: Claude lee el historial de Slack en busca de reportes de errores, solicitudes de funciones y discusiones
• Visibilidad del equipo: Las actualizaciones de progreso en los hilos mantienen a todos informados
• Baja fricción: No se requiere terminal ni IDE—comience desde el chat
• Integración con GitHub: Los PRs se crean automáticamente con descripciones adecuadas

Requisitos

• Espacio de trabajo de Slack con la integración de Claude habilitada
• Repositorio de GitHub conectado
• Permisos apropiados para que Claude pueda crear ramas/PRs

Esta función se encuentra actualmente en versión preliminar de investigación para usuarios Pro, Max, Team y Enterprise.

¿Cuánto cuesta Claude Code?

Comprender y controlar los costos es esencial para un uso sostenible de Claude Code.

Visualización de costos

> /cost

Resultado:

Total cost:            $0.55
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes:    247 lines added, 89 lines removed

Planes de suscripción

Límites de uso (agosto 2025): Anthropic introdujo límites de uso semanales para suscriptores de pago. Los suscriptores Max pueden comprar uso adicional más allá del límite a tarifas estándar de API.²¹

Precios de tokens de API (enero 2026)⁵⁷

Para usuarios facturados por API, precio por millón de tokens:

Prompt caching reduce significativamente los costos de entrada repetida: las escrituras en caché cuestan 1,25× la tarifa base (caché de 5 min) o 2× (caché de 1 hora), pero las lecturas de caché cuestan solo 0,1×—un ahorro del 90%. Para sistemas RAG y asistentes de código con contexto repetido, el almacenamiento en caché puede reducir costos entre 88-95%.

Batch API ofrece descuentos del 50% con entrega en 24 horas para tareas no urgentes como suites de pruebas nocturnas.

Política de cuentas múltiples⁵⁹

¿Puede tener múltiples cuentas de Claude? Sí, para casos de uso legítimos. Anthropic permite explícitamente múltiples cuentas cuando sirven propósitos distintos.

Lo que está permitido:

Límites técnicos: - Hasta 3 cuentas pueden verificarse con el mismo número de teléfono - Múltiples suscripciones pagadas desde la misma IP/red están explícitamente soportadas - Las cuentas son completamente separadas—no hay transferencia de chats o proyectos entre ellas

Lo que está prohibido (según la Política de uso): - Crear cuentas para evadir suspensiones después de haber sido suspendido - Coordinar actividad maliciosa entre cuentas para evitar detección - Usar múltiples cuentas para eludir límites de uso o créditos del nivel gratuito

Nota del mundo real: En enero de 2026, el usuario avanzado Jeffrey Emanuel (@doodlestein) tuvo 22 cuentas Max marcadas automáticamente y suspendidas temporalmente. El empleado de Anthropic Thariq (@trq212) lo resolvió en 4 horas después de confirmar uso legítimo. Si está usando Claude Code extensivamente tanto para trabajo como para proyectos personales con múltiples cuentas, eso es exactamente para lo que el servicio está diseñado—simplemente no intente manipular el sistema.

En caso de duda: Contacte al Soporte de Anthropic para confirmar su configuración específica por escrito.

Factores de costo

Ejemplos de costos reales

Información para ahorrar costos: Usar Haiku para subagents de exploración y Sonnet para implementación típicamente reduce costos 40-50% comparado con usar Sonnet para todo.

Gestión de costos de equipo

TPM/RPM recomendados por tamaño de equipo:

Tarifas ocultas de herramientas

Más allá del precio por token, algunas herramientas incurren en cargos separados:¹⁶

Estos se acumulan en bucles de agentes. Un ciclo de depuración de 100 iteraciones con Bash cuesta ~24.500 tokens de entrada extra solo en overhead.

Estrategias para ahorrar costos

1. Use Haiku para subagents: La mayoría de la exploración no necesita Sonnet
2. Habilite prompt caching: Predeterminado, pero verifique que no esté deshabilitado
3. Establezca turnos máximos: claude --max-turns 5 previene conversaciones descontroladas
4. Use plan mode para exploración: Sin ejecución = sin operaciones costosas accidentales
5. Compacte proactivamente: Menor contexto = menos tokens
6. Limite la salida: export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. Batch API para trabajo no urgente: 50% de descuento en tokens de entrada y salida

Monitoreo de uso

• Claude Console: platform.claude.com (requiere rol Admin o Billing)
• Límites de workspace: Establezca límites de gasto por workspace
• Bedrock/Vertex: Use monitoreo nativo de costos en la nube
• LiteLLM: Para seguimiento detallado por usuario con proveedores externos

Uso de tokens en segundo plano

Algunas operaciones consumen tokens en segundo plano: - Resumen de conversación para /resume - Comandos /cost y /status - Auto-compactación

Típicamente menos de $0,04 por sesión.

Claude Code Analytics API (Team/Enterprise)⁵³

Acceda programáticamente a las analíticas de uso de Claude Code y métricas de productividad de su organización a través de la Admin API.

Endpoint: GET /v1/organizations/usage_report/claude_code

Requisitos: - Clave de Admin API (sk-ant-admin...) - Plan Team o Enterprise - Rol Admin, Billing o Developer

Métricas disponibles:

Ejemplo de solicitud:

curl "https://api.anthropic.com/v1/organizations/usage_report/claude_code?starting_at=2026-01-15" \
  -H "x-api-key: sk-ant-admin..." \
  -H "anthropic-version: 2023-06-01"

Casos de uso: - Análisis de productividad del desarrollador (sesiones, commits, PRs) - Métricas de uso de herramientas (tasas de aceptación/rechazo para Edit, Write, etc.) - Seguimiento de costos y asignación entre equipos - Justificación de ROI para herramientas de codificación con IA

Nota: Los datos aparecen dentro de 1 hora de completar la actividad. Solo se incluyen datos con más de 1 hora de antigüedad en las respuestas para mantener consistencia.

Optimización de rendimiento

Reducción de latencia

Selección de modelo: - Haiku: Respuestas más rápidas, menor costo - Sonnet: Buen equilibrio - Opus: Mejor calidad, mayor latencia

Streaming: Todas las respuestas se transmiten por defecto—ve la salida mientras se genera.

Prompt caching: Habilitado por defecto. Reduce la latencia para contexto repetido (system prompts, definiciones de herramientas).

Estrategias de caché

Los system prompts y definiciones de herramientas se almacenan en caché automáticamente: - Duración del caché: 5 minutos (efímero) - Acierto de caché: Tokens de entrada reducidos y respuesta más rápida

Los bloques de pensamiento de turnos anteriores se almacenan en caché en conversaciones de múltiples turnos.

Deshabilite el caché por modelo si es necesario:

export DISABLE_PROMPT_CACHING_SONNET=1
export DISABLE_PROMPT_CACHING_OPUS=1
export DISABLE_PROMPT_CACHING_HAIKU=1

Operaciones paralelas

Paralelización de subagents: Múltiples subagents pueden ejecutarse simultáneamente. Cada uno opera independientemente sin contaminar el contexto principal.

Bash en segundo plano: Los comandos de larga duración no bloquean la conversación:

> run the full test suite in the background

Git worktrees: Habilitan sesiones verdaderamente paralelas en ramas separadas.

Optimización de memoria

• Referencias de archivo específicas: @src/auth.ts en lugar de “find the auth file”
• Búsquedas dirigidas: “search in src/api” no “search everywhere”
• Sesiones nuevas: /clear entre tareas no relacionadas
• Compactación personalizada: Añada instrucciones a CLAUDE.md sobre qué preservar

¿Cómo depuro problemas?

Problemas de instalación

Problemas de ruta en WSL:

npm config set os linux
npm install -g @anthropic-ai/claude-code --force --no-os-check
which npm  # Debería comenzar con /usr no /mnt/c

Conflictos de versión de Node (nvm): Añada a ~/.bashrc o ~/.zshrc:

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

Errores de permisos: Use instalación nativa en lugar de npm:

curl -fsSL https://claude.ai/install.sh | bash

Problemas de autenticación

# Reinicio completo
/logout
rm -rf ~/.config/claude-code/auth.json
claude  # Inicio de sesión nuevo

Problemas de rendimiento

Alto uso de CPU/memoria: - Use /compact para reducir el contexto - Reinicie entre tareas importantes - Añada directorios grandes a .gitignore - Ejecute claude doctor

Búsqueda lenta: Instale ripgrep del sistema:

# macOS
brew install ripgrep

# Windows
winget install BurntSushi.ripgrep.MSVC

# Linux
sudo apt install ripgrep

Luego:

export USE_BUILTIN_RIPGREP=0

Lento en WSL: - Mueva el proyecto al sistema de archivos Linux (no /mnt/c/) - Use filtros de directorio específicos en las búsquedas

Problemas de integración con IDE

JetBrains no detectado (WSL2):

Opción 1 - Windows Firewall:

wsl hostname -I  # Obtener IP de WSL
New-NetFirewallRule -DisplayName "Allow WSL2" -Direction Inbound -Protocol TCP -Action Allow -RemoteAddress 172.21.0.0/16

Opción 2 - Red en espejo (añadir a ~/.wslconfig):

[wsl2]
networkingMode=mirrored

Luego: wsl --shutdown

Tecla Escape no funciona en JetBrains: Settings → Tools → Terminal → Desmarque “Move focus to the editor with Escape”

Modo de depuración

claude --debug                    # Salida completa de depuración
ANTHROPIC_LOG=debug claude       # Registro de solicitudes API
claude doctor                    # Verificación de salud

Reinicio de configuración

# Reiniciar configuración de usuario
rm ~/.claude.json
rm -rf ~/.claude/

# Reiniciar configuración de proyecto
rm -rf .claude/
rm .mcp.json

Mensajes de error comunes

Implementación empresarial

Comparación de proveedores en la nube

Implementación de configuración administrada

Implemente políticas a nivel organizacional mediante managed-settings.json:

Ubicación: - macOS: /Library/Application Support/ClaudeCode/managed-settings.json - Linux: /etc/claude-code/managed-settings.json - Windows: C:\Program Files\ClaudeCode\managed-settings.json

Ejemplo de política:

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm run:*)",
      "Bash(git:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(curl:*)",
      "Read(.env*)",
      "WebFetch"
    ],
    "defaultMode": "default"
  },
  "model": "claude-sonnet-4-5-20250929",
  "disableBypassPermissionsMode": "disable"
}

Los usuarios no pueden anular la configuración administrada.

CLAUDE.md empresarial

Implemente contexto a nivel organizacional:

Ubicación: - macOS: /Library/Application Support/ClaudeCode/CLAUDE.md - Linux: /etc/claude-code/CLAUDE.md

Contenido:

# Company Standards

## Security Requirements
- Never commit secrets or credentials
- All external API calls require security review
- Use parameterized queries for all database access

## Code Standards
- Follow company style guide at @docs/STYLE.md
- All PRs require two approvals
- Test coverage minimum: 80%

## Approved Tools
- npm, yarn, pnpm for package management
- Jest for testing
- ESLint + Prettier for formatting

Estrategia de implementación gradual

1. Comience con la documentación: Defina correctamente el CLAUDE.md antes de implementar
2. Grupo piloto: Comience con 5-10 desarrolladores
3. Fase de preguntas y respuestas: Permita que los pilotos usen Claude para exploración de código
4. Desarrollo guiado: Avance hacia correcciones de errores menores
5. Implementación completa: Despliegue con configuración administrada
6. Monitoreo de costos: Haga seguimiento del uso por equipo

Auditoría y cumplimiento

• Las transcripciones de sesiones se almacenan localmente de forma predeterminada
• Utilice el registro del proveedor en la nube para auditorías empresariales
• Considere LiteLLM para un seguimiento detallado del uso
• La configuración administrada aplica políticas de cumplimiento

API de Analytics (Administrador)

Los planes Enterprise y Team tienen acceso a la API de Analytics de Claude Code para el seguimiento programático del uso.

Endpoint: GET /v1/organizations/usage_report/claude_code

Autenticación: Requiere una API key de administrador (sk-ant-admin...), aprovisionada en Console por los administradores de la organización.

Métricas disponibles:

Parámetros de solicitud: - starting_at - Fecha para agregación diaria (YYYY-MM-DD) - Devuelve datos a nivel de usuario para el día especificado

Ejemplo:

curl -X GET "https://api.anthropic.com/v1/organizations/usage_report/claude_code?starting_at=2026-01-25" \
  -H "x-api-key: sk-ant-admin-..." \
  -H "anthropic-version: 2023-06-01"

Limitaciones: - Solo agregados diarios (~1 hora de retraso para consistencia) - Para monitoreo en tiempo real, utilice la integración con OpenTelemetry - Solo rastrea el uso de API de primera parte (no Bedrock/Vertex)

Costo: Gratuito para organizaciones con acceso a la API de administrador.

Referencia de atajos de teclado

Controles generales

Atajos de teclado personalizables (v2.1.18+): Ejecute /keybindings para personalizar los atajos de teclado. Admite enlaces específicos por contexto, secuencias de acordes (combinaciones de múltiples teclas) y personalización completa. Los atajos se almacenan en ~/.claude/keybindings.json. Consulte la documentación de keybindings para la referencia completa de configuración.⁷⁷

Sugerencias de prompt (dic. 2025): Claude ahora sugiere prompts para acelerar su flujo de trabajo. Presione Tab para aceptar una sugerencia o Enter para enviar su propio prompt.¹³

Entrada multilínea

Prefijos rápidos

Rendimiento de referencias a archivos (ene. 2026): Las menciones con @ ahora son 3 veces más rápidas en repositorios git. Claude Code también respeta los archivos .ignore y .rgignore al sugerir completado de archivos, lo cual es útil para excluir artefactos de compilación o archivos generados de las sugerencias.³⁵

Modo Vim

Habilítelo con /vim:

Modo normal: - h/j/k/l - Navegación - w/e/b - Movimiento por palabras - 0/$ - Inicio/fin de línea - gg/G - Inicio/fin del búfer - dd - Eliminar línea - cc/C - Cambiar línea/hasta el final - dw/de/db - Variaciones de eliminación de palabra - x - Eliminar carácter - . - Repetir última edición

Modo inserción: - i/I - Insertar antes/al inicio de línea - a/A - Insertar después/al final de línea - o/O - Abrir línea abajo/arriba - Esc - Volver al modo normal

Mejores prácticas

Estrategia de sesiones

Use identificadores de sesión descriptivos:

claude --session-id "feature-$(git branch --show-current)-$(date +%s)"
claude --session-id "bug-JIRA-456"
claude --session-id "spike-new-architecture"

Reanude sesiones para trabajo en curso en lugar de volver a explicar el contexto.

Diseño de CLAUDE.md

Manténgalo fácil de escanear. Claude lee este archivo en cada sesión; el texto denso desperdicia contexto.

Enfóquese en lo no obvio. Documente patrones específicos del proyecto, convenciones inusuales y decisiones. Omita lo que Claude puede inferir del código.

Actualícelo continuamente. Agregue notas durante el desarrollo con #. Revise y consolide semanalmente.

Incluya una referencia de comandos. Los comandos que ejecuta constantemente deben estar documentados.

Comandos personalizados

Cree comandos para flujos de trabajo repetitivos:

---
description: Start new feature
allowed-tools: Bash(git:*), Read, Edit
---

1. Create branch: !`git checkout -b feature/$ARGUMENTS`
2. Pull latest main
3. Set up boilerplate
4. Begin implementation

Prompts efectivos

Sea específico:

# Good
"Add email validation to LoginForm in src/components/LoginForm.tsx"

# Too vague
"Improve the login"

Haga referencia a archivos directamente:

"Review @src/auth/middleware.ts for security issues"

Proporcione restricciones:

"Refactor using the same pattern as @src/repositories/UserRepository.ts"

Use subagents para exploración:

"Have an explore agent find all places where we handle errors"

Control de costos

• Use /cost regularmente
• Use Haiku para tareas simples y subagents
• Configure MAX_THINKING_TOKENS solo cuando sea necesario
• Use --max-turns para scripts automatizados
• Compacte proactivamente en sesiones largas

Seguridad

• Configure reglas de denegación en .claude/settings.json para archivos sensibles
• Use el modo sandbox para proyectos no confiables
• Nunca permita Bash(rm -rf:*) ni Bash(sudo:*)
• Use hooks para bloquear el acceso a secretos
• Implemente configuración administrada para entornos empresariales

Consejos y Técnicas de la Comunidad⁵⁶⁵⁸

La comunidad de Claude Code ha descubierto patrones poderosos que van más allá de la documentación oficial. Estos consejos provienen de usuarios avanzados, incluyendo a Boris Cherny (creador de Claude Code) y el repositorio de más de 40 consejos.

Use el Modo Plan Antes de Codificar

Si recuerda solo un consejo, que sea este. Cuanto más tiempo dedique a la planificación, más probable es que Claude tenga éxito. Presione Shift+Tab para cambiar al modo plan antes de comenzar la implementación.

Nuevo en enero de 2026: Cuando acepta un plan, Claude ahora ofrece limpiar automáticamente su contexto, dándole al plan una ventana de contexto limpia. Esto mejora significativamente la adherencia al plan—Claude se mantiene enfocado por más tiempo sin que el contexto anterior interfiera. Las opciones incluyen: “Sí, limpiar contexto y auto-aceptar ediciones” (Shift+Tab), “Sí, y aprobar ediciones manualmente”, o “Sí, auto-aceptar ediciones” (sin limpiar).

Limpie el Contexto Frecuentemente

Use /clear con frecuencia. Cada vez que comience algo nuevo, limpie el chat. No necesita que el historial anterior consuma tokens o active llamadas de compactación costosas. Simplemente límpielo y continúe.

Use Imágenes y Capturas de Pantalla

Claude sobresale con entrada visual. En macOS: Cmd+Ctrl+Shift+4 captura una captura de pantalla al portapapeles, luego Ctrl+V para pegar directamente en Claude Code. Use esto para compartir mockups de UI, mensajes de error o referencias de diseño.

Instale la GitHub App para Revisiones de PR

Ejecute /install-github-app y Claude revisará automáticamente sus PRs. Esto es particularmente valioso ya que el desarrollo asistido por IA aumenta el volumen de PRs—Claude frecuentemente detecta errores de lógica y problemas de seguridad que los revisores humanos pasan por alto.

Operación Autónoma Basada en Contenedores

Para operación completamente autónoma, ejecute Claude Code en un contenedor Docker con tmux como capa de control. Su Claude Code local controla la instancia en contenedor, que puede ejecutar tareas de larga duración o experimentales sin aprobación manual. Si algo sale mal, está aislado.

# Conceptual pattern (varies by setup)
# Local Claude Code → tmux → Container Claude Code
# Results pulled back when complete

Modo Docker Sandbox (Inicio Rápido): Claude Code soporta un sandbox Docker simplificado mediante el subcomando docker. Esto crea un entorno aislado para explorar bases de código no confiables o ejecutar prompts experimentales de forma segura.⁶³

# Run Claude Code in Docker sandbox
docker sandbox run claude

# Or with specific project
docker sandbox run claude /path/to/project

Use el modo sandbox cuando: - Explore bases de código desconocidas o no confiables - Pruebe prompts experimentales que podrían modificar archivos - Ejecute sesiones autónomas que desee completamente aisladas - Aprenda Claude Code sin riesgo para sus archivos reales

Gemini CLI como Alternativa

La herramienta WebFetch de Claude Code no puede acceder a ciertos sitios (como Reddit). Cree un skill que le indique a Claude usar Gemini CLI como alternativa—Gemini tiene acceso web y puede obtener contenido de sitios a los que Claude no puede acceder directamente.

Patrón Meta-Agent Factory

En lugar de crear agentes que realizan tareas, cree un agente que crea otros agentes. Esto no es recursión ingeniosa—es un multiplicador genuino de productividad para flujos de trabajo de automatización complejos.

Claude Squad: Gestor Multi-Agente

Claude Squad gestiona múltiples instancias de Claude Code en paralelo, cada una en su propia sesión tmux con worktrees aislados. Ejecute varios agentes simultáneamente en diferentes tareas, monitoree su progreso desde un único panel, y obtenga los resultados cuando terminen.⁶⁵

# Install
npm install -g @smtg-ai/claude-squad

# Start multiple agents
claude-squad start "Implement auth feature" --worktree auth-feature
claude-squad start "Write API tests" --worktree api-tests
claude-squad start "Update documentation" --worktree docs-update

# Monitor all agents
claude-squad status

Casos de uso: - Paralelizar funcionalidades independientes entre agentes - Ejecutar prompts exploratorios sin bloquear su sesión principal - Escalar codificación autónoma más allá de una única ventana de contexto

Estadísticas de Productividad de Usuarios Avanzados

Boris Cherny demostró el potencial de Claude Code: en 30 días, integró 259 PRs con 497 commits—40,000 líneas añadidas y 38,000 eliminadas. Esto muestra lo que es posible cuando Claude Code está completamente integrado en el flujo de trabajo de desarrollo.

Personas a Seguir

Manténgase actualizado con los desarrollos de Claude Code siguiendo estas cuentas:

Equipo de Anthropic (Fuentes Primarias)

Principales Creadores de Contenido

Recursos Clave

• GitHub Releases: anthropics/claude-code/releases - Observe solo los lanzamientos
• Discord: Canales de la comunidad de Anthropic
• Lista completa: Vea ~/.claude/docs/following-list.md para más de 20 cuentas curadas

Boris y el equipo de Anthropic comparten funcionalidades a medida que las lanzan—frecuentemente es la forma más rápida de conocer nuevas capacidades antes de que la documentación se actualice.

Anti-patrones Comunes

Aprender qué NO hacer frecuentemente proporciona más valor que las mejores prácticas. Estos patrones consistentemente causan problemas:

Anti-patrones de Costo

Anti-patrones de Contexto

Anti-patrones de Flujo de Trabajo

Anti-patrones de Configuración

Anti-patrones de Prompts

Recetas de Flujo de Trabajo

Patrones de principio a fin para escenarios comunes.

Receta 1: Iniciar un Nuevo Proyecto

# 1. Initialize
cd my-project
claude

# 2. Let Claude understand the codebase
> "Explore this codebase and summarize the architecture"

# 3. Set up project configuration
> /init

# 4. Create CLAUDE.md with learned patterns
> "Create CLAUDE.md documenting the patterns you observed"

# 5. Add team commands
> "Create a /test command that runs our test suite"
> "Create a /deploy command for staging deployment"

Receta 2: Flujo de Desarrollo Diario

# 1. Continue yesterday's session
claude -c

# 2. Quick context recap
> "What did we work on yesterday?"

# 3. Check current state
> /status

# 4. Work on feature (Sonnet handles most tasks)
> "Implement the user profile endpoint"

# 5. Proactive context management
> /compact  # Before context exceeds 50%

# 6. Check spending
> /cost

# 7. End session cleanly
> "Summarize what we accomplished today"

Receta 3: Refactorización Compleja

# 1. Use Opus for planning, Sonnet for execution
> /model opusplan

# 2. Plan the refactoring
> "Plan refactoring our authentication from sessions to JWT"

# 3. Review the plan
# (Claude presents approach, you approve or modify)

# 4. Execute with Sonnet
> "Execute the plan"

# 5. Verify nothing broke
> "Have an explore agent verify all auth-related tests pass"

# 6. Review the diff
> !git diff

Receta 4: Automatización de Revisión de PR

# In CI/CD (GitHub Actions, etc.)
claude -p "Review this PR for:" \
  --input-file pr_diff.txt \
  --output-format json \
  --permission-mode plan \
  --max-turns 5 << EOF
- Security vulnerabilities
- Performance issues
- Code style violations
- Missing test coverage
Provide findings in JSON format.
EOF

Receta 5: Depuración de Problemas en Producción

# 1. Configure Sentry MCP for error access
claude --add-mcp sentry

# 2. Get error context
> "Fetch the last 10 errors from Sentry for the auth service"

# 3. Deep dive with thinking
> Tab  # Enable extended thinking
> "Analyze these errors and identify the root cause"

# 4. Fix and verify
> "Implement a fix and add a regression test"
> !npm test

Guía de Migración

¿Viene de otras herramientas de programación con IA? Aquí le mostramos cómo se corresponden los conceptos.

Desde GitHub Copilot

Lo que gana: Capacidad verdaderamente agéntica—Claude Code lee su código base, ejecuta pruebas, crea PRs y delega a subagents. No son solo sugerencias.

Desde Cursor

Lo que gana: Integraciones MCP (bases de datos, GitHub, Sentry), delegación a subagents, hooks para automatización y flujo de trabajo nativo de terminal.

Desde ChatGPT / Claude Web

Lo que gana: Todo. Las interfaces web requieren flujos de trabajo de copiar y pegar; Claude Code opera directamente en su código base.

Cambios Clave de Mentalidad

1. Deje de copiar código. Claude Code escribe directamente en los archivos.
2. Deje de cambiar de contexto. MCP trae herramientas externas a la sesión.
3. Delegue agresivamente. Los subagents manejan la exploración sin inflar su contexto.
4. Automatice con hooks. El formateo, linting y registro ocurren automáticamente.
5. Piense en sesiones. Continúe el trabajo con -c, no con conversaciones nuevas.

Conclusiones Clave

Para desarrolladores: - Haiku cuesta 10-20x menos que Opus—úselo para subagents y tareas simples - Use /compact proactivamente durante sesiones largas para gestionar el contexto - Los IDs de sesión que codifican contexto (feature-${branch}-${timestamp}) ayudan a navegar de vuelta a trabajos anteriores - Prefije prompts comunes con # para añadirlos a la memoria persistente sin escribir más

Para equipos de DevOps y plataforma: - El modo headless (flag -p) habilita la integración CI/CD con salida JSON para análisis - Los hooks garantizan la ejecución independientemente del comportamiento del modelo—úselos para linting, formateo y verificaciones de seguridad - MCP extiende las capacidades a bases de datos, GitHub, Sentry y más de 300 integraciones - Las tareas en segundo plano (prefijo &) se ejecutan en Claude Code Remote para ejecución asíncrona

Para equipos de seguridad: - Las reglas de permisos se evalúan con primera-coincidencia-gana—estructure las listas de permitir/denegar cuidadosamente - El modo sandbox aísla el sistema de archivos y la red para códigos base no confiables - Los patrones de Bash solo coinciden con prefijos—Bash(curl:*) bloquea todo curl, no solo URLs específicas - Las configuraciones administradas de empresa no pueden ser anuladas por los usuarios

Para líderes de equipo: - Los skills se activan automáticamente según el contexto—integre experiencia de dominio sin invocación explícita - Los skills de proyecto se guardan en git—los compañeros de equipo obtienen experiencia estandarizada automáticamente - El seguimiento de costos vía /cost muestra el desglose de la sesión; presupueste 10k-300k TPM por usuario según el tamaño del equipo - Los comandos personalizados en .claude/commands/ crean flujos de trabajo reutilizables

Para arquitectos empresariales: - Las configuraciones administradas despliegan políticas a nivel organizacional vía /etc/claude-code/managed-settings.json - AWS Bedrock, Google Vertex AI y Microsoft Foundry se integran con la facturación de nube existente - El pensamiento extendido (Tab para alternar) mejora el razonamiento complejo a mayor costo - Comience un piloto con 5-10 desarrolladores antes del despliegue completo

Tarjeta de Referencia Rápida

Imprima esto. Péguelo en su monitor.

╔═══════════════════════════════════════════════════════════════╗
║                    CLAUDE CODE QUICK REFERENCE                 ║
╠═══════════════════════════════════════════════════════════════╣
║  MODELS                                                        ║
║    haiku     $1/$5/M     Exploration, simple tasks            ║
║    sonnet    $3/$15/M    Daily coding (default)               ║
║    opus      $5/$25/M    Architecture, hard problems          ║
║    sonnet[1m] $6/$22.50/M Large codebases (1M context)        ║
╠═══════════════════════════════════════════════════════════════╣
║  ESSENTIAL COMMANDS                                            ║
║    /compact        Reduce context (do at 50% capacity)        ║
║    /cost           Check session spending                     ║
║    /model opus     Switch to Opus                             ║
║    /status         Show current state                         ║
║    /init           Set up project config                      ║
║    /mcp            Configure integrations                     ║
╠═══════════════════════════════════════════════════════════════╣
║  KEYBOARD SHORTCUTS                                            ║
║    Tab             Toggle extended thinking                   ║
║    Shift+Tab       Cycle permission modes                     ║
║    Ctrl+C          Interrupt current operation                ║
║    Esc → Esc       Rewind last change                         ║
║    Ctrl+L          Clear screen                               ║
╠═══════════════════════════════════════════════════════════════╣
║  PREFIXES                                                      ║
║    #message        Add to persistent memory                   ║
║    @path/file      Reference file in prompt                   ║
║    !command        Execute bash directly                      ║
║    &task           Send to cloud (async)                      ║
╠═══════════════════════════════════════════════════════════════╣
║  CONFIG FILE HIERARCHY (first found wins)                      ║
║    .claude/settings.local.json    Personal (gitignored)       ║
║    .claude/settings.json          Project (shared)            ║
║    ~/.claude/settings.json        User global                 ║
║    /etc/.../managed-settings.json Enterprise (locked)         ║
║    CLAUDE.md                      Project context             ║
╠═══════════════════════════════════════════════════════════════╣
║  DAILY WORKFLOW                                                ║
║    1. claude -c              Continue session                 ║
║    2. Work on features       Use Sonnet                       ║
║    3. /compact               Before context bloats            ║
║    4. /cost                  Check spending                   ║
║    5. Summarize              Clean exit                       ║
╠═══════════════════════════════════════════════════════════════╣
║  DECISION RULES                                                ║
║    Simple task?        → Haiku                                ║
║    Hard reasoning?     → Opus                                 ║
║    Everything else?    → Sonnet                               ║
║    Must always run?    → Hook (not prompt)                    ║
║    Auto-apply wisdom?  → Skill (not command)                  ║
║    Needs isolation?    → Subagent                             ║
╚═══════════════════════════════════════════════════════════════╝

Registro de cambios

Esta referencia es un documento vivo. Las actualizaciones se aplican a medida que Claude Code evoluciona.

Ejecute /update-cc-guide para buscar y aplicar las últimas actualizaciones de Claude Code.

Referencias