Mejores prácticas de Claude Code: De 'utilizable' a 'verdaderamente útil'

He estado usando Claude Code por más de medio año, y he metido la pata más veces de las que he escrito líneas de código.

Al principio, pensé que Claude Code era solo un "Copilot más avanzado": escribes en la terminal, genera código y listo. Después me di cuenta de que el techo de esta herramienta es mucho más alto de lo que imaginaba, pero solo si sabes cómo usarla.

Este artículo combina documentación oficial y experiencia práctica para organizar lo que considero los consejos de uso más importantes. Algunos los aprendí a la fuerza, otros son funciones ocultas que descubrí solo leyendo la documentación.

1. CLAUDE.MD: La función más infravalorada

Si solo recuerdas una cosa de este artículo, que sea esta: Escribe bien tu CLAUDE.md.

CLAUDE.md es el archivo de instrucciones que Claude Code lee automáticamente al inicio de cada conversación. Es como un manual de bienvenida que le escribes a un nuevo compañero de trabajo: todo lo que quieras que sepa, lo pones ahí.

Mucha gente no escribe un CLAUDE.md, o solo escribe un par de líneas. El resultado es tener que explicar la estructura del proyecto, los estándares de código y las decisiones tecnológicas desde cero en cada conversación. Es como presentarle la empresa a tu colega todas las mañanas.

Lo que debería incluir un buen CLAUDE.md:

1# Nombre del Proyecto
2
3## Comandos de compilación y pruebas
4- Instalar dependencias: npm install
5- Ejecutar pruebas: npm test
6- Prueba individual: npm test -- --grep "nombre de la prueba"
7- Formateo: npm run format
8
9## Estándares de código
10- Python: Usar ruff para formateo, ancho de línea 88
11- Pruebas: Usar pytest, un archivo de prueba por servicio
12- Rutas API: Usar nombres de archivo en plural: users.py, orders.py
13- Mensajes de commit: En inglés, formato: tipo(ámbito): descripción
14
15## Decisiones arquitectónicas
16- Elegir Tailwind en lugar de CSS Modules porque el equipo lo estandarizó
17- Las comprobaciones de permisos de usuario se hacen en middleware; no repetir en cada ruta
18- Prefijo de clave de caché Redis: app:v1:
19
20## Errores comunes
21- El límite del pool de conexiones a la BD es 20; no abrir nuevas conexiones en bucles
22- No simular (mock) la base de datos; la última vez que se hizo, las pruebas pasaron pero la migración en producción falló

Principios clave:

Primero, escribe cosas que Claude no pueda deducir del código. El "por qué" de un proyecto es más importante que el "qué". No hace falta explicarle cómo usar React, pero sí debes decirle "elegimos Tailwind porque el equipo lo estandarizó".

Segundo, que tenga menos de 200 líneas. La documentación oficial menciona explícitamente que si CLAUDE.md es demasiado largo, Claude podría ignorar las reglas. Usa encabezados y listas de Markdown para que sea fácil de escanear.

Tercero, no pongas contenido que cambie frecuentemente. Las documentaciones detalladas de APIs o las descripciones archivo por archivo no van en CLAUDE.md. Simplemente proporciona enlaces.

Los cuatro niveles de CLAUDE.md

Claude Code soporta cuatro niveles de CLAUDE.md, ordenados de mayor a menor prioridad:

En mi CLAUDE.md global, normalmente escribo:

1- Soy ingeniero full-stack; no hace falta explicar conceptos básicos en exceso
2- Mantén las respuestas concisas; omite las cortesías innecesarias
3- No resumas lo que hiciste después de cambios de código; yo revisaré el diff
4- Prioriza soluciones simples; evita la sobreingeniería

Estas cuatro líneas pueden ahorrarte cientos de correcciones repetitivas.

Avanzado: Organiza las reglas con .claude/rules/

A medida que un proyecto crece, un solo archivo CLAUDE.md no da abasto. La solución oficial es más elegante: Divide las reglas en el directorio .claude/rules/.

1.claude/rules/
2├── testing.md        # Estándares de pruebas
3├── api-style.md      # Estilo de escritura de APIs
4└── frontend.md       # Convenciones de frontend

Aún más potente, puedes usar frontmatter YAML para limitar reglas a archivos específicos:

1---
2paths: ["src/api/**/*.ts", "src/routes/**/*.ts"]
3---
4
5Las rutas API deben incluir validación de entrada y manejo de errores.
6Todos los endpoints nuevos requieren pruebas de integración en tests/api/.

De esta manera, la regla solo se carga cuando Claude accede a archivos que coinciden, ahorrando espacio en el contexto.

2. La calidad del prompt determina la calidad del resultado

Suena a cliché, pero he visto a demasiada gente usar Claude Code así:

"Ayúdame a escribir una función de inicio de sesión"

Y luego se preocupan por un enorme bloque de código generado que no es lo que querían.

Una buena instrucción debe contener tres elementos: Objetivo, Restricciones y Contexto.

Instrucción mala vs. Instrucción buena

Mala: "Añade una función de búsqueda a la lista de usuarios"

Buena: "Añade un cuadro de búsqueda encima de la tabla en @src/pages/UserList.tsx. La búsqueda debe usar la API del backend /api/users?search=xxx, sin filtrado en el frontend. Usa un debounce de 300 ms y mantén el estilo coherente con el componente Filter existente."

¿La diferencia? Las buenas instrucciones reducen la ambigüedad. Claude Code no tiene que adivinar si quieres búsqueda en frontend o backend, el tiempo de debounce o los estándares de estilo.

Consejos de prompting recomendados oficialmente

1. Usa @ para referenciar archivos específicos

Claude Code permite usar @rutaarchivo para incorporar el contenido del archivo directamente al contexto. En lugar de decir "ese código relacionado con la autenticación", escribir @src/auth/login.ts es mucho más preciso. Incluso puedes especificar rangos de líneas: @src/auth/login.ts#5-30.

2. Pega capturas de pantalla e imágenes

Usa Ctrl+V para pegar imágenes directamente. Al depurar problemas de interfaz, una captura de "cómo se ve ahora" vs "cómo quiero que se vea" es diez veces más efectiva que una descripción textual.

3. Proporciona criterios de validación

No te limites a decir "ayúdame a corregir este error", di:

"Corrige el problema por el cual la reautenticación falla después de un tiempo de sesión expirado. Después de la corrección, al hacer clic en cualquier botón tras la expiración del token, se debe redirigir automáticamente a la página de inicio de sesión. Los casos de prueba están en @tests/auth.test.ts; ejecútalos para confirmar que pasan después de la corrección."

Dale a Claude un estándar que pueda verificar por sí mismo: casos de prueba, capturas de pantalla, salida esperada—para que pueda comprobar la calidad de su propio trabajo y reducir el ir y venir.

4. Sé claro sobre lo que NO debe hacer

Claude Code a veces puede ser demasiado entusiasta: le pides que corrija un error y termina refactorizando el código circundante. Decir explícitamente "solo cambia esta función, no toques otro código" te ahorra muchos dolores de cabeza.

Cuándo son útiles las instrucciones vagas

No todas las situaciones requieren precisión. Las instrucciones vagas son mejores para tareas exploratorias:

• "¿Qué se puede mejorar en este archivo?"
• "Ayúdame a entender la arquitectura de este módulo"
• "¿Hay algún problema potencial con este código?"

Pero una vez que llegas a la etapa de implementación, vuelve al modo de precisión.

3. MODO PLAN: Piensa con claridad antes de actuar

Claude Code tiene un Modo Plan, que considero el flujo de trabajo más infravalorado.

Cómo entrar al Modo Plan

Tres formas:

1# Iniciar directamente en modo plan
2claude --permission-mode plan
3
4# Cambiar durante la conversación (presionar Shift+Tab dos veces)
5Shift+Tab Shift+Tab
6
7# Decir en el prompt
8"No cambies el código todavía, ayúdame a hacer un plan"

En el Modo Plan, Claude Code solo puede leer archivos y buscar código; no puede hacer ninguna modificación. Explora la base de código, analiza tus requisitos y proporciona un plan de implementación detallado.

Forma correcta de usar el Modo Plan

Operación clave: Presiona Ctrl+G para abrir y editar el plan en tu editor.

Esto significa que puedes:

1. Dejar que Claude genere un plan inicial
2. Ctrl+G para abrir el plan, eliminar las partes con las que no estés de acuerdo y añadir tus propias ideas
3. Volver al modo normal (Shift+Tab) y dejar que Claude ejecute según el plan modificado

Cambiar un plan te lleva una frase; cambiar código ya escrito te lleva diez veces más.

Flujo de trabajo recomendado para tareas complejas

El proceso estándar oficial consta de cuatro pasos: Explorar → Planificar → Implementar → Verificar.

11. Entrar en Modo Plan
22. Hacer que Claude lea el código relevante: "Lee el código en src/auth/ para entender la lógica de sesión"
33. Solicitar un plan: "Desarrolla un plan de migración a OAuth2"
44. Ctrl+G para revisar y editar el plan
55. Volver al modo normal
66. "Implementa según el plan, ejecuta las pruebas después de escribir"
77. Hacer que Claude se autoverifique con los requisitos

Cuándo no necesitas el Modo Plan

• Cambiar el nombre de una variable
• Corregir un error tipográfico evidente
• Añadir una sola línea de registro (log)

El criterio es simple: Si solo hay una forma de implementar la tarea, hazlo directamente. Si hay varias opciones, planifica primero.

4. SUB-AGENTES: El poder multitarea de Claude Code

Los sub-agentes son un mecanismo potente: Claude Code puede lanzar procesos de IA independientes para manejar tareas en paralelo. Cada sub-agente tiene su propia ventana de contexto y no saturará tu conversación principal.

Tipos de sub-agentes integrados

El mayor valor de los sub-agentes: Aislamiento de contexto

Cuando le pides a Claude que ejecute pruebas, analice registros (logs) o busque muchos archivos, estas operaciones generan una enorme cantidad de salida que llena tu ventana de contexto. Usa sub-agentes para estas tareas; la salida se queda en el contexto del sub-agente y solo un resumen vuelve a ti.

Por ejemplo:

"Usa un sub-agente para ejecutar todas las pruebas y listar los casos fallidos"

"Usa un sub-agente para buscar todos los archivos que usan APIs obsoletas"

Ejecución en segundo plano: Ctrl+B

Presiona Ctrl+B para poner un sub-agente en segundo plano. Puedes seguir conversando con Claude sobre otras cosas y recibirás una notificación cuando la tarea en segundo plano se complete.

Adecuado para:

• Ejecutar suites de pruebas (normalmente lleva minutos)
• Búsquedas de código a gran escala
• Revisiones de código no urgentes

Sub-agentes personalizados

Puedes crear agentes personalizados en el directorio .claude/agents/:

1---
2name: code-reviewer
3description: Experto en revisión de código. Se activa automáticamente después de cambios de código.
4tools: Read, Grep, Glob, Bash
5model: sonnet
6---
7
8Eres un revisor de código senior. Verifica las siguientes dimensiones:
9- Claridad y legibilidad del código
10- Integridad del manejo de errores
11- Exposición de información sensible
12- Validación de entrada
13- Problemas de rendimiento

Luego, invócalo en la conversación usando @"code-reviewer (agent)".

5. Gestión del contexto: Lo más ignorado y más importante

Si bien la ventana de contexto de Claude Code es grande (hasta 1 millón de tokens), no es infinita, y la gestión del contexto determina directamente la calidad del resultado.

¿Qué hay en el contexto?

• El historial de tu conversación
• Todo el contenido de los archivos que Claude ha leído
• La salida de la ejecución de comandos
• El archivo CLAUDE.md (se carga cada vez)
• El archivo de memoria (primeras 200 líneas)
• Las definiciones de Skills y herramientas MCP cargadas

Cinco estrategias prácticas

1. /clear: Limpia cuando termines una tarea

No corrijas errores, añadas funciones y refactorices todo en la misma conversación. /clear vacía el contexto pero mantiene CLAUDE.md, actuando como un reinicio gratuito.

2. /compact: Comprime el contexto manualmente

Cuando la conversación se alarga, usa /compact para que Claude resuma y comprima automáticamente el diálogo anterior. Una forma mejor es añadir un enfoque a la compresión:

/compact focus on API changes and test results

De esta manera, Claude prioriza conservar el contenido que te importa durante la compresión.

3. /context: Mira qué está consumiendo tu contexto

Escribe /context para ver el uso actual: qué archivos ocupan cuántos tokens y cuánto espacio ocupan las definiciones de herramientas MCP. A menudo encuentro servidores MCP inútiles que ocupan un montón de espacio.

4. Usa sub-agentes para aislar el ruido

Ejecutar pruebas y analizar registros produce mucha salida. Deja que los sub-agentes lo hagan para mantener limpio el contexto de la conversación principal.

5. Escribe instrucciones de retención en CLAUDE.md

Puedes decirle a Claude qué debe conservar durante la compresión:

1# Instrucciones de compresión
2Al comprimir el contexto, conserva siempre:
3- La lista completa de archivos modificados
4- Los comandos de prueba y sus resultados
5- Las decisiones arquitectónicas clave

Memoria vs CLAUDE.md

Para qué sirve la Memoria: Tus preferencias ("a esta persona le gustan las respuestas concisas"), las convenciones del proyecto ("el despliegue tiene un paso especial"), decisiones históricas ("la última vez elegimos la opción A por X").

Para qué NO sirve la Memoria: Detalles de código, historial de Git, estados temporales—estos se recuperan con más precisión del código y de Git.

Usa el comando /memory para ver y gestionar toda la Memoria cargada.

6. Gestión de permisos: Equilibrio entre seguridad y eficiencia

Claude Code proporciona cinco modos de permiso, que se ciclan con Shift+Tab en la conversación:

Configuración de reglas de permiso

En .claude/settings.json, puedes controlar finamente los permisos para cada herramienta:

1{
2  "permissions": {
3    "allow": [
4      "Bash(npm run *)",
5      "Bash(git commit *)",
6      "Edit(src/**/*.ts)",
7      "Read(*.md)"
8    ],
9    "deny": [
10      "Bash(rm -rf *)",
11      "Edit(.env)"
12    ]
13  }
14}

Prioridad de las reglas: deny → ask → allow (deny tiene la máxima prioridad).

Esto significa que puedes permitir audazmente comandos comunes mientras usas deny para proteger archivos sensibles. Por ejemplo, los archivos .env nunca deberían editarse.

Jerarquía de archivos de configuración

Al igual que CLAUDE.md, la configuración tiene múltiples niveles:

1Política de la organización (Máxima prioridad)
2  ↓
3Argumentos de CLI
4  ↓
5.claude/settings.local.json (Local, no se sube a Git)
6  ↓
7.claude/settings.json (Nivel de proyecto, compartido con el equipo)
8  ↓
9~/.claude/settings.json (Global, personal)
10  ↓
11Valores por defecto (Mínima prioridad)

Mi consejo: Pon las reglas compartidas del equipo en .claude/settings.json, las preferencias personales en ~/.claude/settings.json y las configuraciones sensibles en .claude/settings.local.json (recuerda añadirlo a .gitignore).

7. HOOKS: Convierte las reglas en leyes de hierro

Las instrucciones en CLAUDE.md son "sugerencias": Claude las sigue la mayoría del tiempo, pero de vez en cuando se le olvidan. Los hooks son "leyes de hierro": se ejecutan pase lo que pase.

Los hooks son comandos de shell que se activan automáticamente en eventos específicos del ciclo de vida, configurados en settings.json.

Tipos de eventos clave

Ejemplos prácticos

Autoformateo: Ejecutar Prettier después de cada edición:

1{
2  "hooks": {
3    "PostToolUse": [{
4      "matcher": "Edit|Write",
5      "hooks": [{
6        "type": "command",
7        "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
8      }]
9    }]
10  }
11}

Proteger archivos críticos: Evitar la modificación de configuraciones de producción:

1{
2  "hooks": {
3    "PreToolUse": [{
4      "matcher": "Edit|Write",
5      "hooks": [{
6        "type": "command",
7        "command": ".claude/hooks/protect-files.sh"
8      }]
9    }]
10  }
11}

Un comando hook que devuelve código de salida 0 significa permitido; código de salida 2 significa bloqueado. Esto significa que puedes escribir cualquier lógica compleja.

Reinyectar información clave después de la compresión del contexto:

1{
2  "hooks": {
3    "SessionStart": [{
4      "matcher": "compact",
5      "hooks": [{
6        "type": "command",
7        "command": "echo 'Usa Bun, no npm. Ejecuta bun test antes de hacer commit.'"
8      }]
9    }]
10  }
11}

Esto soluciona un problema común: cuando una conversación larga se comprime, las instrucciones importantes mencionadas antes podrían perderse. Los hooks pueden reinyectarlas automáticamente después de cada compresión.

Cuatro tipos de hooks

8. FLUJO DE TRABAJO CON GIT: Aprovecha WORKTREE

Claude Code puede ejecutar comandos de Git, lo cual es un arma de doble filo. Pero la herramienta oficial proporciona una gran red de seguridad: Worktree.

Git Worktree: Espacios de trabajo aislados

1# Iniciar Claude en un worktree aislado
2claude --worktree feature-auth
3claude --worktree bugfix-123
4
5# Generar un nombre automáticamente
6claude --worktree

Worktree crea una copia de una rama independiente de Git en .claude/worktrees/. Todo lo que Claude haga dentro no afectará a tu rama principal. Al salir:

• Si no hay cambios → Se limpia automáticamente
• Si hay cambios → Te pregunta si quieres conservarlos o eliminarlos

Esto es especialmente útil para tareas exploratorias. ¿No estás seguro de si un plan de refactorización funcionará? Pruébalo en un worktree; si falla, lo tiras sin riesgo.

Algunas leyes de hierro con Git

1. Nunca dejes que Claude Code haga push automático

Puede hacer commit, pero la acción de push debe ser confirmada por ti. Una vez subido al remoto, el costo de revertir aumenta significativamente.

2. Haz commit con frecuencia

Haz commit después de completar una pequeña funcionalidad. Usa /rewind para volver a cualquier punto de control, siempre que tengas registros de commit.

3. Cuidado con las operaciones destructivas

Si Claude Code quiere ejecutar git reset --hard, git push --force o rm -rf, piensa en las consecuencias antes de aprobar. Estas operaciones no tienen deshacer. También puedes denegar estos comandos en las reglas de permiso.

4. Restaurar el contexto desde un PR

Esto carga automáticamente los cambios y discusiones del PR como contexto, perfecto para revisiones de código o para continuar el trabajo de otra persona.

1claude --from-pr 123

9. Atajos y referencia de comandos

Uso estos atajos todos los días; recomiendo encarecidamente memorizarlos:

Atajos más comunes

Comandos de barra más comunes

1/compact [focus]     # Comprimir contexto, se puede especificar un enfoque
2/clear              # Limpiar conversación, empezar de nuevo
3/context            # Ver el uso del contexto
4/memory             # Ver y gestionar la Memoria
5/rewind             # Retroceder a un punto de control
6/resume [name]       # Reanudar una conversación anterior
7/model              # Cambiar de modelo
8/effort [level]       # Establecer profundidad de razonamiento: low/medium/high/max
9/init               # Generar CLAUDE.md automáticamente
10/mcp                # Gestionar servidores MCP
11/permissions        # Ver reglas de permiso
12/cost               # Ver consumo de tokens

/init es particularmente útil para proyectos nuevos: analiza automáticamente tu base de código y ayuda a generar un borrador de CLAUDE.md. Aunque normalmente necesita ajustes manuales, es mucho más rápido que empezar de cero.

10. PENSAMIENTO EXTENDIDO: Deja que Claude piense más profundamente

Para problemas complejos, puedes activar el modo de Pensamiento Extendido, permitiendo que Claude dedique más tiempo a razonar antes de responder.

Cómo usarlo

1# Alternar con atajo
2Option+T (Mac) / Alt+T (Windows/Linux)
3
4# O mediante comando
5/effort high    # Razonamiento más profundo
6/effort max     # Máxima profundidad de razonamiento
7/effort low     # Tareas simples, ahorra tokens

Cuándo usarlo

• Decisiones arquitectónicas complejas
• Depuración complicada (múltiples causas posibles que eliminar)
• Diseño de refactorización de varios pasos
• Sopesar pros y contras de múltiples soluciones

Cuándo no lo necesitas

• Cambios simples de código
• Formateo, renombrado
• Corrección de errores ya evidentes

Consejo profesional: Escribir "ultrathink" en el prompt puede forzar la máxima profundidad de razonamiento sin necesidad de ajustar manualmente la configuración de esfuerzo.

11. SERVIDOR MCP: Conecta Claude con el mundo exterior

MCP (Model Context Protocol) permite que Claude Code se comunique con herramientas externas: GitHub, bases de datos, Slack, Notion, etc.

Añadido rápido

1claude mcp add github -- npx @anthropic-ai/mcp-server-github
2claude mcp add postgres -- npx @anthropic-ai/mcp-server-postgres postgresql://localhost:5432/mydb

Archivo de configuración

MCP se configura en .mcp.json:

1{
2  "mcpServers": {
3    "github": {
4      "type": "stdio",
5      "command": "npx",
6      "args": ["@modelcontextprotocol/server-github"],
7      "env": {
8        "GITHUB_TOKEN": "$GITHUB_TOKEN"
9      }
10    }
11  }
12}

Ten en cuenta la sobrecarga del contexto

Cada servidor MCP consume entre 100 y 500+ tokens adicionales para las definiciones de las herramientas. Usa el comando /mcp para verificar la sobrecarga de cada servidor y desactiva los que no uses.

Mi experiencia: No seas ambicioso. 2 o 3 servidores MCP de uso común son suficientes. Instalar demasiados consume espacio del contexto con definiciones de herramientas, lo que puede degradar la calidad del análisis de código.

12. Integración con IDE: Más que una terminal

VS Code

Después de instalar la extensión Claude Code, puedes usar Claude directamente en VS Code sin cambiar a la terminal.

Funciones útiles:

• Vista de diferencias lado a lado: Los cambios de Claude se muestran como diffs, claros de un vistazo
• Option+K / Alt+K: Inserta rápidamente @referencias al archivo actual
• Conversaciones en múltiples pestañas: Abre varias conversaciones independientes en diferentes pestañas
• Cmd+Shift+Esc: Abre rápidamente una nueva pestaña de conversación

JetBrains

IntelliJ, PyCharm, WebStorm y otros IDEs de JetBrains también tienen un plugin de Claude Code. Solo busca "Claude Code" en el marketplace de Plugins para instalarlo.

13. Revisar el código: Confía, pero verifica

La calidad del código de Claude Code es generalmente buena, pero no debes confiar ciegamente.

Problemas comunes

1. Sobreingeniería

Le pides una función utilitaria simple y te da toda una capa de abstracción con genéricos, interfaces y patrones de fábrica. Usar un martillo pilón para cascar una nuez.

Solución: Escribe "prioriza soluciones simples" en CLAUDE.md, o di explícitamente "no se necesita abstracción" en la instrucción.

2. APIs alucinadas

A veces usa APIs que no existen o sintaxis obsoleta, especialmente con versiones nuevas de librerías poco conocidas.

Solución: Ejecuta pruebas. Por eso las instrucciones deberían incluir estándares de validación.

3. Ampliación del alcance

Le pides que cambie una función y termina refactorizando todo el archivo.

Solución: Di explícitamente "solo cambia X, no toques otro código". O usa el comando /freeze para limitar el ámbito de edición a directorios específicos.

Modo Escritor/Revisor

Un modo avanzado recomendado oficialmente: Usa dos sesiones independientes que desempeñen los roles de "Escritor" y "Revisor".

Dos sesiones tienen contextos independientes; el Revisor no está influenciado por la lógica del Escritor y puede encontrar puntos ciegos.

1Sesión A (Escritor): "Implementa middleware de limitación de tasa para la API"
2Sesión B (Revisor): "Revisa la implementación de limitación de tasa en @src/middleware/rateLimiter.ts, 
3                     céntrate en casos límite, condiciones de carrera y consistencia"
4Sesión A: "Corrige los comentarios de la revisión: [Pega la salida de B]"

14. Lo que NO debes hacer con Claude Code

Después de hablar tanto sobre "qué hacer", hablemos de "qué no hacer".

1. No dejes que haga cosas que no entiendes en absoluto

Si no sabes nada de Kubernetes, no dejes que Claude Code escriba configuraciones de despliegue para que las uses directamente. No puedes revisar lo que no entiendes.

2. No lo uses en entornos sin control de versiones

Sin Git no hay capacidad de revertir. Los cambios de Claude Code podrían sobrescribir tus archivos; usarlo sin control de versiones es como caminar por la cuerda floja sin red.

3. No le lances una tarea masiva de una sola vez

"Migra todo el proyecto de JavaScript a TypeScript"

Esta instrucción le da rienda suelta a Claude Code, haciendo que el resultado sea incontrolable. Divídelo en pequeños pasos y confirma cada paso antes de pasar al siguiente.

4. No esperes perfección al primer intento

La iteración es normal. Usa /rewind para retroceder y usa comentarios precisos para describir "qué está mal".

Resumen

La filosofía central de usar Claude Code es simple:

Es un colaborador extremadamente capaz, pero no es un piloto automático. El volante siempre está en tus manos.

Ordenados por importancia, mis consejos son:

1. Escribe un buen CLAUDE.md – Es la base de todo; invierte tiempo en ello.
2. Usa el Modo Plan para tareas complejas – Primero piensa, luego actúa. Cambiar un plan es mucho más barato que cambiar código.
3. Gestiona el contexto de forma activa – /clear, /compact, /context; no dejes que la ventana de contexto se llene de basura.
4. Separa tareas ruidosas con sub-agentes – Pruebas, análisis de logs, búsquedas a gran escala: todo en sub-agentes.
5. Escribe instrucciones precisas – Objetivo + Restricciones + Contexto + Criterios de validación. Sin ambigüedad.
6. Usa hooks para reglas obligatorias – Las instrucciones en CLAUDE.md son sugerencias; los hooks son leyes.
7. Aísla los riesgos con Git Worktree – Operaciones experimentales en worktrees; el fracaso no tiene costo.
8. Habilita el Pensamiento Extendido para problemas complejos – Cuanto más profundo el razonamiento, mejor la solución.

1. Escribe bien CLAUDE.md — Invierte una vez, benefíciate en cada conversación
2. Da instrucciones precisas — Objetivo + Restricciones + Estándares de validación
3. Usa el modo Plan — Planifica primero, actúa después para tareas complejas
4. Gestiona el contexto — /clear, /compact, Sub-agentes
5. Controla los permisos — Rechaza operaciones peligrosas, permite comandos comunes
6. Haz commits con frecuencia — Conserva la capacidad de revertir

Haz estas cosas, y Claude Code puede multiplicar tu eficiencia varias veces. Si no las haces, solo te ayudará a crear caos más rápido.

El valor de una herramienta siempre depende de la persona que la usa.

Lo anterior es una combinación de la documentación oficial de Claude Code y la experiencia práctica. Si tienes mejores prácticas, no dudes en compartirlas.