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

He estado usando Claude Code durante más de medio año, y he tropezado con más trampas de las que he escrito líneas de código.

Al principio, pensaba 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 son lecciones aprendidas a base de errores, mientras que otros son funciones ocultas que descubrí solo al leer 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 documento de bienvenida que le escribes a un nuevo colega: todo lo que quieras que sepa, lo escribes 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 codificación y las decisiones técnicas desde cero en cada conversación. Es como presentarle la empresa a tu colega cada mañana.

Lo que debe incluir un buen CLAUDE.md:

1# Nombre del Proyecto
2
3## Comandos de compilación y prueba
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 codificación
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: Inglés, formato: tipo(ámbito): descripción
14
15## Decisiones de arquitectura
16- Elegir Tailwind sobre 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 de la BD es 20; no abrir nuevas conexiones en bucles
22- No simular la base de datos; la última vez los mocks pasaron pero la migración en producción falló

Principios clave:

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

Segundo, mantenlo por debajo 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 incluyas contenido que cambie con frecuencia. Las API detalladas o las descripciones archivo por archivo no pertenecen a CLAUDE.md. Solo proporciona enlaces.

Los cuatro niveles de CLAUDE.md

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

En mi CLAUDE.md global, suelo escribir:

1- Soy ingeniero full-stack; no hace falta explicar conceptos básicos en exceso
2- Mantén las respuestas concisas; omite cortesías innecesarias
3- No resumas lo que hiciste después de los cambios de código; 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 es suficiente. 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 prueba
3├── api-style.md      # Estilo de escritura de API
4└── frontend.md       # Convenciones de frontend

Aún más potente, puedes usar frontmatter YAML para limitar las 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 nuevos endpoints requieren pruebas de integración en tests/api/.

De esta manera, la regla solo se carga cuando Claude accede a archivos coincidentes, ahorrando espacio de contexto.

2. La calidad del prompt determina la calidad del resultado

Esto suena a cliché, pero he visto a demasiadas personas 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: esto no es lo que quería.

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

Mala instrucción vs. Buena instrucción

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 oficiales para prompts

1. Usa @ para referenciar archivos específicos

Claude Code admite usar @rutaarchivo para incluir el contenido del archivo directamente en el 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 UI, una captura de pantalla 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 digas solo "ayúdame a arreglar este error", di:

"Arregla el problema por el que falla la reautenticación después de un tiempo de espera de inicio de sesión. Después del arreglo, al hacer clic en cualquier botón después de que el token expire, 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 del arreglo."

Dale a Claude un estándar de autoverificación—casos de prueba, capturas de pantalla, resultado esperado—para que pueda comprobar la calidad de su propio trabajo y reducir los intercambios.

4. Sé claro sobre lo que NO debe hacer

Claude Code a veces puede ser demasiado entusiasta: le pides que arregle un error y refactoriza el código circundante. Decir explícitamente "solo cambia esta función, no toques otro código" ahorra muchos problemas.

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 el código base, 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 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 lleva una frase; cambiar código ya escrito lleva diez veces más tiempo.

Flujo de trabajo recomendado para tareas complejas

El proceso estándar oficial tiene 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 según los requisitos

Cuándo no necesitas el Modo Plan

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

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

4. SUB-AGENTES: La capacidad 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 o busque muchos archivos, estas operaciones generan una salida masiva que llena tu ventana de contexto. Usa sub-agentes para estas tareas; la salida se queda en el contexto del sub-agente y solo se te devuelve un resumen.

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 API obsoletas"

Ejecución en segundo plano: Ctrl+B

Presiona Ctrl+B para poner un sub-agente en segundo plano. Puedes seguir charlando 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: revisor-codigo
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 llámalo en la conversación usando @"revisor-codigo (agent)".

5. Gestión del contexto: La clave más pasada por alto

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

¿Qué hay en el contexto?

• Tu historial de conversación
• Todo el contenido de archivos leídos por Claude
• Salida de ejecución de comandos
• Archivo CLAUDE.md (se carga cada vez)
• Archivo de memoria (primeras 200 líneas)
• Definiciones de Skill y herramientas MCP cargadas

Cinco estrategias prácticas

1. /clear: Limpia cuando termines una tarea

No arregles 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 mejor manera es añadir un enfoque a la compresión:

/compact centrado en cambios de API y resultados de pruebas

De esta forma, Claude prioriza mantener 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 ocupando un espacio enorme.

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 de compresión en CLAUDE.md

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

1# Instrucciones de compresión
2Al comprimir el contexto, mantener siempre:
3- Lista completa de archivos modificados
4- Comandos de prueba y resultados
5- Decisiones clave de arquitectura

Memoria vs CLAUDE.md

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

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

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

6. Gestión de permisos: Equilibrando 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 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 deben editarse.

Jerarquía de archivos de configuración

Similar a 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 predeterminados (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: Convirtiendo reglas en leyes de hierro

Las instrucciones en CLAUDE.md son "sugerencias"—Claude las sigue la mayoría de las veces, pero ocasionalmente las olvida. Los Hooks son "leyes de hierro"—se ejecutan pase lo que pase.

Los Hooks son comandos de shell que se activan automáticamente mediante 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 modificar 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 resuelve un problema común: cuando una conversación larga se comprime, las instrucciones importantes mencionadas anteriormente pueden perderse. Los Hooks pueden reinyectarlas automáticamente después de cada compresión.

Cuatro tipos de Hooks

8. FLUJO DE TRABAJO CON GIT: Aprovechando WORKTREE

Claude Code puede ejecutar comandos 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 independiente de la rama de Git en .claude/worktrees/. Todo lo que Claude haga dentro no afectará a tu rama principal. Al salir:

• Si no hay cambios → Limpieza automática
• Si hay cambios → Te pregunta si 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, deséchalo sin riesgo.

Algunas leyes de hierro de 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 enviado al remoto, el coste de revertir aumenta significativamente.

2. Haz commit con frecuencia

Haz commit después de terminar una pequeña función. 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 contexto desde un PR

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

1claude --from-pr 123

9. Atajos y referencia de comandos

Uso estos atajos a diario; recomiendo encarecidamente memorizarlos:

Atajos más comunes

Comandos de barra más comunes

1/compact [enfoque]     # Comprimir contexto, se puede especificar enfoque
2/clear              # Limpiar conversación, empezar de nuevo
3/context            # Ver uso del contexto
4/memory             # Ver y gestionar Memoria
5/rewind             # Retroceder a un punto de control
6/resume [nombre]     # Reanudar una conversación anterior
7/model              # Cambiar modelos
8/effort [nivel]      # Establecer profundidad de razonamiento: low/medium/high/max
9/init               # Generar automáticamente CLAUDE.md
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 código base y ayuda a generar un borrador de CLAUDE.md. Aunque normalmente necesita ajustes manuales, es mucho más rápido que empezar desde 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# Atajo de teclado
2Option+T (Mac) / Alt+T (Windows/Linux)
3
4# O mediante comando
5/effort high    # Razonamiento más profundo
6/effort max     # Profundidad máxima de razonamiento
7/effort low     # Tareas simples, ahorra tokens

Cuándo usarlo

• Decisiones complejas de arquitectura
• 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 de código simples
• Formateo, renombrado
• Correcciones de errores ya claras

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: Conectando 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/midb

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 herramientas. Usa el comando /mcp para comprobar la sobrecarga de cada servidor y desactivar los que no uses.

Mi experiencia: No seas codicioso. 2-3 servidores MCP de uso común son suficientes. Instalar demasiados consume espacio de 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 solo 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 diferencias, claras de un vistazo
• Option+K / Alt+K: Insertar rápidamente @referencias al archivo actual
• Conversaciones en múltiples pestañas: Abrir varias conversaciones independientes en diferentes pestañas
• Cmd+Shift+Esc: Abrir rápidamente una nueva pestaña de conversación

JetBrains

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

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

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

Problemas comunes

1. Sobreingeniería

Pides una función de utilidad simple y te da una capa de abstracción completa 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. API alucinadas

A veces usa API inexistentes o sintaxis obsoleta, especialmente para versiones nuevas de bibliotecas especializadas.

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

3. Expansión del alcance

Le pides que cambie una función y refactoriza 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 para desempeñar 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 velocidad de API"
2Sesión B (Revisor): "Revisa la implementación de limitación de velocidad en @src/middleware/rateLimiter.ts, 
3                     centrándote en casos extremos, 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

Habiendo dicho 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 a Claude Code rienda suelta, 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 en el 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 un piloto automático. El volante siempre está en tus manos.

Ordenado por importancia, mi consejo es:

1. Escribe bien el 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 — Primero planifica, luego actúa para tareas complejas
4. Gestiona el contexto — /clear, /compact, Sub-agentes
5. Controla los permisos — Deniega operaciones peligrosas, permite comandos comunes
6. Haz commits con frecuencia — Conserva la capacidad de revertir cambios

Haz esto, y Claude Code puede multiplicar tu eficiencia varias veces. Si no lo 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.