Dominar Claude Code Parte 9: Secretos de usuario avanzado

Los trucos que separan a los usuarios casuales de los expertos en Claude Code. Algunos están documentados, otros se descubrieron mediante experimentación, y algunos surgieron de descompilar el bundle de Claude Code.

Pensamiento extendido: La historia completa

Presentamos el pensamiento extendido por primera vez en la Parte 2, pero aquí está la historia completa.

Probablemente has oído hablar de "ultrathink" y "think harder". Esto es lo que realmente funciona según la documentación oficial de Anthropic.

La jerarquía de palabras clave para pensar

Claude Code mapea frases específicas a presupuestos de pensamiento. Estas son las palabras clave oficialmente documentadas:

Think (~4.000 tokens) — think

Megathink (~10.000 tokens) — think hard, think deeply, think more, megathink

Ultrathink (~32.000 tokens) — think harder, think very hard, ultrathink

Ultrathink about how to architect this authentication system

Cuanto mayor sea el presupuesto, más "pista mental" tiene Claude para considerar múltiples enfoques, evaluar compromisos y detectar casos límite.

Actualizaciones de enero 2026

Algunas cosas cambiaron en Claude Code 2.1:

• Pensamiento habilitado por defecto para Opus 4.5 — No necesitas activarlo manualmente para tareas complejas
• Atajo cambiado de Tab a Alt+T — Evita activaciones accidentales
• Visualización del pensamiento en tiempo real — Pulsa Ctrl+O para ver el razonamiento de Claude mientras ocurre

Cuándo usar cada nivel

ultrathink (~32K tokens) — Decisiones de arquitectura, revisiones de seguridad, depuración compleja, cualquier cosa por la que programarías una reunión

think hard / megathink (~10K tokens) — Refactorización de múltiples archivos, diseño de APIs, depuración de problemas complicados

think (~4K tokens) — Análisis rápido, revisión de código, entender código desconocido

Sin palabra clave — Correcciones simples, erratas, tareas rutinarias donde el pensamiento extendido solo añade latencia

La regla: Ajusta el presupuesto de pensamiento a la complejidad del problema. No uses ultrathink para corregir una errata, no omitas el pensamiento para la arquitectura.

Mantente actualizado con información reciente

Los datos de entrenamiento de Claude tienen una fecha de corte. Para las últimas APIs de librerías, actualizaciones recientes de frameworks o mejores prácticas actuales:

Usa el servidor MCP Context7: Obtiene documentación en tiempo real y específica por versión. Consulta la Parte 7: Servidores MCP para la configuración.

"use context7 to look up the current API for React Query v5"

Pide a Claude que busque en línea: Claude puede hacer búsquedas web para información reciente.

"search online for the latest Supabase auth patterns in 2026"

Esto asegura que trabajes con APIs actuales, no con las obsoletas de los datos de entrenamiento de Claude.

Movimientos de poder con múltiples ventanas

No esperes a que termine una tarea. Ejecuta múltiples instancias de Claude Code simultáneamente—cada una en su propia terminal, cada una con contexto aislado.

Notificaciones sonoras: Sabe cuándo Claude ha terminado

Cuando malabareas con múltiples ventanas, necesitas saber cuándo Claude termina sin estar revisando constantemente. Habilita la campana de la terminal:

Claude config set --global preferredNotifChannel terminal_bell

Escucharás un pitido cuando Claude complete una tarea o necesite input. No más cambios de contexto para comprobar el progreso.

Para notificaciones más completas, usa un hook en ~/.claude/settings.json:

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "afplay /System/Library/Sounds/Ping.aiff"
          }
        ]
      }
    ]
  }
}

Esto reproduce un sonido en macOS cada vez que Claude necesita atención. En Linux, usa paplay o aplay en su lugar. En Windows puedes usar powershell.exe -c "[System.Media.SystemSounds]::Beep.Play()".

Trabajo entre repos: Referencia sin modificar

¿Trabajas en un frontend que llama a una API de backend? No ejecutes Claude en ambos repos simultáneamente. En su lugar, dale a Claude acceso de solo lectura al backend desde tu proyecto frontend.

En el .claude/settings.json de tu frontend:

{
  "permissions": {
    "additionalDirectories": ["../backend-repo/"],
    "allow": [
      "Read(../backend-repo/**)",
      "Grep(../backend-repo/**)"
    ],
    "deny": [
      "Edit(../backend-repo/**)",
      "Write(../backend-repo/**)"
    ]
  }
}

Ahora Claude puede leer los controladores y modelos del backend para entender la API, pero no puede modificarlos accidentalmente. Puedes preguntar cosas como:

"Check ../backend-repo/src/controllers/ for the user endpoints and wire up the frontend to match"

Claude lee el backend, entiende la forma de la API y escribe solo en tu frontend.

Mismo proyecto, diferentes ramas: Git Worktrees

Cuando necesitas trabajar en múltiples funcionalidades en el mismo repo, los git worktrees te permiten hacer checkout de diferentes ramas en directorios separados:

# Create worktrees for parallel features
Git worktree add ../myproject-dashboard feature/user-dashboard
Git worktree add ../myproject-notifications feature/email-notifications

Ahora tienes:

Myproject/                    # main branch
Myproject-dashboard/          # feature/user-dashboard branch
Myproject-notifications/      # feature/email-notifs branch

Ejecuta Claude en cada directorio—sesiones completamente aisladas, sin conflictos de cambio de rama.

Por qué funciona

• Cada sesión de Claude tiene contexto aislado
• El acceso de solo lectura previene cambios accidentales entre repos
• Puedes referenciar código externo sin arriesgar modificaciones
• El contexto de una tarea no contamina otra

Limpieza de worktrees

Cuando terminas con una funcionalidad:

Cd myproject
Git merge feature/dashboard
Git worktree remove ../myproject-dashboard

Entrada de capturas de pantalla e imágenes

Claude Code puede ver imágenes. Arrastra y suelta capturas de pantalla directamente en tu terminal.

Cómo funciona

1. Toma una captura de pantalla (Cmd+Shift+4 en Mac)
2. Arrastra el archivo de imagen a tu terminal de Claude Code
3. Pregunta sobre ella

Casos de uso

Depuración de UI:

[drag screenshot of broken layout]
What's wrong with this layout? The button should be aligned right.

Implementación de diseños:

[drag mockup image]
Implement this design using Tailwind CSS

Capturas de errores:

[drag screenshot of error dialog]
What does this error mean and how do I fix it?

Generación de diagramas Mermaid

Haz que Claude cree diagramas visuales que puedes renderizar en cualquier lugar.

Diagramas de arquitectura

Generate a mermaid diagram showing the authentication flow in this app

Resultado:

Dónde renderizar

• mermaid.live — Editor online con vista previa en vivo
• GitHub — Renderiza mermaid en archivos markdown y comentarios
• VS Code — Con extensión de vista previa de mermaid
• Notion — Soporta bloques de código mermaid

Tipos de diagramas

Create a mermaid flowchart showing the order processing states

Generate a mermaid class diagram for the data models

Make a mermaid ER diagram of the database schema

Patrón de banco de memoria

Persiste contexto entre sesiones sin inflar CLAUDE.md. Esto complementa bien la Estrategia de documentar + /clear de la Parte 2.

Configuración

Crea un directorio de memoria:

Mkdir -p .claude/memory

Archivo de memoria de sesión

# .claude/memory/current-session.md

## Active Focus
Implementing user dashboard feature

## Decisions Made
- Using React Query for data fetching (decided 2024-01-15)
- Chart library: Recharts (lighter than D3 for our needs)
- State: Zustand (team already familiar)

## Blocked On
- Waiting for design review on mobile layout
- Need API endpoint for activity feed

## Recent Changes
- Added DashboardLayout component
- Created useUserStats hook
- Set up Recharts for usage graphs

## Next Steps
1. Implement activity feed once API ready
2. Add export functionality
3. Mobile responsive tweaks

Uso de los archivos de memoria

Inicia las sesiones con:

Read .claude/memory/current-session.md and continue where we left off

Actualiza al final de las sesiones:

Update .claude/memory/current-session.md with our progress today

Trucos de optimización de tokens

Ahorra dinero y mejora la calidad de las respuestas.

Prefiere /clear sobre /compact

Actualización enero 2026: /compact ahora es instantáneo (v2.0.64+) y el auto-compact se activa al 75% de capacidad. También prueba /context para verificar el uso de servidores MCP antes de compactar.

Como cubrimos en la Parte 2, /compact es tentador pero arriesgado. El resumen es opaco—no sabes qué se preserva o se pierde.

La mayor parte del tiempo, /clear es mejor:

• Empiezas algo nuevo
• Menos de la mitad de tu contexto es relevante
• Puedes restablecer fácilmente lo que importa

Si debes usar /compact, guíalo:

/compact Focus on preserving the authentication flow and database schema decisions

Referencia, no pegues

Mal (desperdicia tokens):

Here's the code:
[pastes 500 lines]

Fix the bug in this

Bien (eficiente):

Fix the bug in src/auth/login.ts around line 45

Claude leerá el archivo por sí mismo, cargando solo lo que necesita.

Consejo pro: Copiar ruta en VS Code. Haz clic derecho en cualquier archivo → Copy Relative Path (o Cmd+Shift+Alt+C). Pega la ruta exacta en lugar de escribirla. Sin erratas, sin ambigüedad—especialmente útil para archivos muy anidados o cuando múltiples archivos tienen nombres similares. Combínalo con números de línea para precisión quirúrgica: src/auth/login.ts:45-60

El patrón de documentar y limpiar

Actualización enero 2026: Ahora está integrado en el Modo Plan. Cuando aceptas un plan, Claude limpia automáticamente el contexto y carga el plan de nuevo. Puedes desactivarlo si prefieres mantener el contexto.

Para trabajo complejo de múltiples sesiones, usa documentación explícita:

"Save our progress and remaining TODOs to docs/feature-plan.md"
/clear
"Read docs/feature-plan.md and continue where we left off"

Tú controlas exactamente qué persiste. Sin adivinar qué conservó el resumidor.

Estrategias de cambio de modelo

Diferentes modelos para diferentes tareas.

Cuándo usar cada modelo

Opus ($$$) — Arquitectura compleja, revisiones de seguridad, problemas novedosos que necesitan máximo poder de razonamiento.

Sonnet ($$) — Programación general y tareas del día a día. Es el modelo por defecto y maneja bien la mayoría del trabajo.

Haiku ($) — Preguntas rápidas, tareas simples, operaciones de alto volumen donde la velocidad importa más que la profundidad.

Uso estratégico de modelos

Comienza funcionalidades complejas con opus:

/model opus
Plan the architecture for user permissions system

Cambia a sonnet para la implementación:

/model sonnet
Implement the permission checking middleware we discussed

Usa haiku para verificaciones rápidas:

/model haiku
Does this regex pattern look correct? /^[\w-]+@[\w-]+\.[\w-]+$/

Automatización en modo headless

Programa Claude Code para CI/CD y automatización usando la bandera -p (print).

Uso básico

Claude -p "analyze this PR for security issues"

La bandera -p ejecuta Claude de forma no interactiva y termina cuando se completa. Perfecto para scripts y pipelines.

Formatos de salida

Controla cómo se devuelven las respuestas:

# Plain text (default)
Claude -p "summarize this project"

# JSON with metadata
Claude -p "list all TODO comments" --output-format json

# Stream JSON for real-time processing
Claude -p "analyze this code" --output-format stream-json

Aprobación automática de herramientas

Pre-aprueba herramientas para evitar prompts de permisos en CI:

# Allow specific tools
Claude -p "run tests and fix failures" \
  --allowedTools "Bash,Read,Edit"

# Restrict to specific commands
Claude -p "create a commit" \
  --allowedTools "Bash(git diff:*),Bash(git log:*),Bash(git commit:*)"

Ejemplos de pipeline

# Automated PR review
Git diff HEAD~1 | claude -p "summarize these changes"

# Pre-commit hook
Claude -p "check staged files for secrets" || exit 1

# Security scan with JSON output
Claude -p "security review of this codebase" \
  --output-format json \
  --allowedTools "Read,Grep" | jq -r '.result'

Continuación de sesión

Continúa conversaciones de forma programática:

# Get session ID from first call
Session_id=$(claude -p "start review" --output-format json | jq -r '.session_id')

# Continue that session
Claude -p "now check for performance issues" --resume "$session_id"

Atajos de teclado

Domina estos para navegar Claude Code más rápido.

Atajos esenciales

Escape — Interrumpe a Claude a mitad de respuesta. Útil cuando ves que va en la dirección equivocada.

Escape, Escape (doble toque) — Abre el historial de comandos. Desplázate por prompts anteriores y vuelve a ejecutarlos.

Ctrl+C — Cancela la operación actual por completo.

Ctrl+L — Limpia la pantalla de la terminal (no el contexto, solo el desorden visual).

Flecha arriba — Navega por tus prompts recientes.

En la extensión de VS Code

La extensión de Claude Code para VS Code trae las mismas capacidades a tu editor. No es un producto separado—es Claude Code ejecutándose nativamente en VS Code, compartiendo la misma configuración, comandos y servidores MCP.

Cmd+L — Abre el panel de Claude. Aquí es donde pasarás la mayor parte del tiempo—una interfaz de chat persistente que entiende tu workspace.

Cmd+Shift+L — Envía código seleccionado a Claude. Selecciona código, pulsa el atajo y Claude ve exactamente lo que estás mirando.

Cmd+I — Modo de edición inline. Claude edita código in situ con vista de diff—acepta o rechaza cambios sin salir de tu archivo.

Cmd+Shift+P → "Claude" — Accede a todos los comandos de Claude desde la paleta de comandos.

La extensión comparte tu configuración .claude/, así que los comandos personalizados, servidores MCP e instrucciones de CLAUDE.md funcionan de forma idéntica. La ventaja principal sobre Claude Code en terminal: diffs visuales, sugerencias inline e integración más estrecha con el editor.

Entrada por voz: Habla con Claude

Cuando estoy solo en la habitación, a menudo cambio a voz. Es más rápido que escribir para explicar problemas complejos, y a veces hablar sobre un problema ayuda a clarificar tu pensamiento antes incluso de que Claude responda.

En Mac, la configuración es simple: Ajustes del Sistema → Teclado → Dictado → Activar. Luego usa el atajo de dictado (doble toque en Fn por defecto) en cualquier lugar—incluyendo el panel de Claude.

La voz funciona especialmente bien para:

• Explicar bugs que llevas mirando horas
• Describir cambios de UI mientras miras un mockup
• Preguntas rápidas cuando tus manos están en el trackpad
• Hablar en voz alta sobre problemas como técnica de rubber-ducking

La combinación de entrada por voz con la comprensión de Claude hace que las conversaciones sobre código sean sorprendentemente naturales.

Trucos ocultos de productividad

El patrón "como si"

Implement this as if you were a senior engineer at Stripe

Review this code as if it's going to production tomorrow

Establece expectativas de calidad sin requisitos explícitos.

El patrón de restricción

Implement this in under 50 lines

Solve this without adding new dependencies

Las restricciones a menudo llevan a mejores soluciones.

El patrón de explicar primero

Before implementing, explain your approach in 2-3 sentences

Obliga a Claude a pensar antes de actuar. Detecta malos enfoques a tiempo.

El prompt de rubber duck

I'm stuck on [problem]. Ask me questions to help me figure it out.

Claude como compañero de depuración, no solo generador de código.

Qué viene después

Has aprendido los secretos de usuario avanzado—ultrathink para razonamiento profundo, worktrees para desarrollo en paralelo, modo headless para automatización y los patrones de productividad que marcan la diferencia.

En la Parte 10: Vibe Coding, cerraremos con la filosofía de trabajar con IA—cuándo dejar que Claude conduzca, cuándo tomar el volante y cómo desarrollar tu propia intuición para el desarrollo asistido por IA.