1) Objetivos y reglas del juego

Objetivos del curso

• Instalar Claude Code y arrancar sesiones de trabajo en un repo real.
• Dominar el “triángulo” de productividad: REPL (interactivo), print mode (scripting) y sesiones (continuar / resumir).
• Usar permisos y herramientas con criterio: velocidad sin perder control.
• Aplicar plantillas de prompts para tareas típicas (debug, refactor, pruebas, PR).

Reglas del juego (para que Claude realmente “rinda”)

1. Primero diagnóstico, luego cambios: pide plan y confirma supuestos antes de editar.
2. Cambios pequeños y verificables: “haz 1 cosa → corre tests → avanza”.
3. Siempre pide evidencia: “muéstrame el archivo/función y la razón”.
4. Automatiza sólo lo repetible: print mode + JSON para pipelines.

2) Instalación y login

Elige el método que mejor encaje con tu sistema. (Sección lista para copiar/pegar).

Instalación rápida (según plataforma)

macOS / Linux (Homebrew)

brew install --cask claude-code

macOS / Linux / WSL (script)

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

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

Con Node.js 18+ (NPM)

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

Primer login

claude
# Te pedirá autenticarte en el primer uso
/login
# Sigue el flujo de login

Consejo: dentro del REPL, usa ? para ver atajos disponibles en tu terminal.

3) Tu primera sesión (y tu primera victoria rápida)

Arranque recomendado

cd /ruta/a/tu/proyecto
claude

Secuencia “de oro” (explora → plan → cambia → valida)

1. Explora: “what does this project do?” / “where is the main entry point?”
2. Plan: “propón un plan en 3 pasos; no edites aún”.
3. Cambio: “aplica el paso 1 y muéstrame el diff”.
4. Valida: “corre tests / build; si falla, diagnostica y corrige”.

Git “conversacional” (ejemplos)

• “what files have I changed?”
• “show me the last 5 commits”
• “help me resolve merge conflicts”
• claude commit (si quieres que Claude te guíe a un commit bien descrito)

4) Comandos CLI (comando / descripción / usos)

Formato consistente: Comando → Qué hace → Cuándo usarlo.

claude

claude "explain this project"

claude -p "explain this function"

cat logs.txt | claude -p "explica el error y su causa probable"

claude -c

claude -r "abc123" "Finish this PR"

claude update

claude mcp

5) Flags clave (y cuándo usarlas)

Top flags para productividad

claude --model sonnet
claude --model opus

claude -p "resume este diff" --output-format json

claude -c
claude -r "abc123" "continúa con el paso 2"

claude --tools "Bash,Read,Edit"
claude --allowedTools "Bash(git log:*)" "Read"
claude --disallowedTools "Edit"

claude --permission-mode plan

claude --dangerously-skip-permissions

claude --agents '{
  "code-reviewer": {
    "description": "Revisa cambios y riesgos.",
    "prompt": "Eres un revisor senior. Prioriza seguridad y mantenibilidad.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  }
}'

6) Modo interactivo: atajos, modos y “quick commands”

Atajos que valen oro

• Ctrl + C: cancela generación/entrada
• Ctrl + D: salir
• Ctrl + O: alterna salida verbose
• Ctrl + R: búsqueda inversa en historial
• Esc + Esc: “rewind” (retroceder conversación/código)
• ?: muestra atajos disponibles en tu entorno

Quick commands (prefijos)

• / al inicio: ejecutar un slash command
• ! al inicio: ejecutar bash directamente y adjuntar salida al contexto
• @: autocompletar rutas de archivos
• #: atajo de “memoria” (gestión de CLAUDE.md)

Multilínea

Si vas a pegar bloques largos (logs, código), pega directo o usa el modo multilínea de tu terminal. Si tu entorno lo soporta, /terminal-setup suele ayudar a configurar entradas cómodas.

7) Slash commands imprescindibles

Úsalos para controlar la sesión sin salir del REPL.

Starter pack (los que más se usan)

/help
/clear
/exit

Operación y configuración

/config
/model
/permissions
/doctor
/mcp

• /doctor es el primer paso si algo “raro” pasa con la instalación.
• /permissions ajusta permisos sobre la marcha.
• /mcp administra conexiones MCP y autenticación.

Calidad de vida

/compact
/context
/export

• /compact: comprime conversación para enfocarte (ideal en sesiones largas).
• /context: visualiza consumo de contexto.
• /export: exporta la conversación (archivo o clipboard).

8) Workflows listos (plantillas para copiar/pegar)

Plantillas que fuerzan estructura: diagnóstico → plan → cambios → validación.

Debug de error (rápido y disciplinado)

Contexto: al ejecutar <comando> falla con este error:
<pega el error>

Tarea:
1) Identifica la causa raíz y el archivo/línea probable.
2) Propón 2 opciones de fix (mínima vs robusta) con pros/contras.
3) Implementa la opción mínima, muestra diff, y corre tests/build.
No edites hasta confirmar el plan.

Refactor con seguridad (sin romper contrato)

Quiero refactorizar <módulo> para:
- <objetivo>

Restricciones:
- Mantener API pública (firma/outputs).
- Añadir/actualizar tests donde falten.
- Cambios en pasos pequeños.

Proceso:
1) Describe el estado actual (archivos clave).
2) Propón plan en 3-5 commits lógicos.
3) Ejecuta el paso 1 y valida.

Tests: de “cero cobertura” a útil

Necesito tests para <componente>.
1) Enumera casos críticos y bordes.
2) Escribe tests unitarios primero (rápidos).
3) Si aplica, añade un test de integración mínimo.
4) Ejecuta el runner y corrige hasta verde.

Docs/README con foco (sin humo)

Actualiza README para que una persona nueva pueda:
- instalar
- ejecutar
- correr tests
- entender estructura del repo

Requisitos:
- comandos exactos
- variables de entorno
- troubleshooting común
- sección “Arquitectura en 90 segundos”

9) Automatización: print mode + JSON

Patrón base (CI-friendly)

# 1) Enviar diff a Claude y pedir un review estructurado en JSON
git diff | claude -p "haz code review; devuelve hallazgos en JSON con severidad y archivo" --output-format json

# 2) Analizar logs en un pipeline
cat logs.txt | claude -p "clasifica errores por causa raíz y sugiere fix" --output-format json

Consejo práctico

• Si lo vas a parsear, exige estructura: “devuélvelo como JSON con estas claves: …”.
• Para tareas largas, limita turnos con –max-turns.
• Para seguridad, restringe herramientas con –tools o listas allow/deny.

10) Cheatsheet + checklist de producción

Comandos “de bolsillo”

# REPL
claude
claude "explica este proyecto"

# Print mode (scripting)
claude -p "resume este archivo"
git diff | claude -p "haz code review" --output-format json

# Sesiones
claude -c
claude -r "abc123" "continúa"

# Operación
claude update
claude -v

Checklist antes de dejar que edite “en serio”

• ¿Le pediste plan primero (plan → cambios)?
• ¿Cambios pequeños, con diff visible y reversibles?
• ¿Tests/build corriendo después de cada paso?
• ¿Permisos y herramientas restringidas al mínimo necesario?
• ¿Sesión compactada si ya es muy larga (/compact)?

Cierre (tu “rutina” de alto rendimiento)

1. Entra con objetivo claro (1 frase).
2. Pide plan y supuestos.
3. Ejecuta en pasos; valida siempre.
4. Exporta conversación útil (/export) y documenta lo aprendido.

Notas WordPress/Divi (rápido)

• Si cargas guias.css como archivo, enlázalo en tu theme/child theme o con un plugin de “insert headers/footers”.
• Si prefieres rápido: pega el contenido del CSS en “Apariencia → Personalizar → CSS adicional” (pero tú dijiste que lo quieres aparte: perfecto).