¿Qué problemas resuelve?

• Horas haciendo boilerplate, tests rutinarios, migraciones
• Context-switching entre documentación, terminal, editor, navegador
• Deuda técnica que nunca tiene prioridad suficiente
• Onboarding lento en proyectos nuevos o legacy
• Pasamos de ser escritores de código a arquitectos

Claude Code no te reemplaza. Te amplifica.
Tú decides qué hacer. Él ejecuta.

No es un chatbot. Es un agente.

Refactoring

Desarrollo de nuevas features

Trabajar con código legacy

Code quality tools

¿Todos listos?

claude --version
						

Si alguien necesita instalarlo:

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

# Homebrew
brew install --cask claude-code
						

cd mi-proyecto
claude
						

Mi setup

Para que entendáis lo que veis en pantalla:

• Arch Linux
• Hyprland — tiling window manager
• Neovim como editor
• Tmux — multiplexor de terminal
• Terminal lover 🤘

Quién soy y por qué estoy aquí

La hora de Claude

Habla con tu código

No pegues código. Referencia archivos directamente.

Referencias precisas

• @archivo — fuzzy-find, adjuntar archivo completo
• @carpeta/ — adjuntar un directorio entero
• src/app.ts:42 — referencia a línea específica

Cómo introducir prompts

Tres trucos que marcan la diferencia en el día a día.

Abrir el prompt en tu editor

Ctrl+G abre tu editor por defecto (Neovim, VS Code...)

• Escribe prompts largos con comodidad
• Syntax highlighting, multilinea, copiar/pegar
• Al guardar y cerrar, se envía el prompt

También: Ctrl+X Ctrl+E (readline nativo)

Stashing del prompt

Estás escribiendo un prompt y necesitas hacer otra cosa antes:

• Ctrl+S o Ctrl+U — guarda y limpia la línea actual
• Ctrl+Y — la recupera cuando quieras

Como un stash de git, pero para tu prompt.

Pegar imágenes

Ctrl+V pega una imagen del portapapeles directamente.

• Screenshots de bugs, diseños, diagramas
• Claude los interpreta y trabaja con ellos
• Aparecen como [Image #N] en tu prompt

Tú decides cuánto control das

shift+tab cicla entre los 3 modos principales:

Modo adicional: claude --permission-mode auto

Requiere: plan Team/Enterprise/API • Sonnet 4.6 o Opus 4.6 • Anthropic API. No disponible en Pro/Max.

¿Cuándo uso cada uno?

• plan — "Quiero entender antes de tocar" (refactors, arquitectura)
• default — "Voy aprendiendo, quiero ver cada paso"
• accept edits — "Confío en las ediciones, pero los comandos los reviso"
• auto — "Tengo un spec claro y quiero irme a por café"

/permissions para pre-autorizar comandos específicos sin cambiar de modo

Elige el modelo adecuado

/model para cambiar en cualquier momento

Ajusta esfuerzo y velocidad

• /effort — high para bugs complicados, low para ediciones rápidas
• /fast — mismo modelo, output más rápido

Gestión de contexto

Cada sesión empieza con una ventana de contexto limpia.
Dos mecanismos llevan conocimiento entre sesiones:

• CLAUDE.md — instrucciones que tú escribes
• Auto memory — notas que Claude escribe solo

1M tokens: ¿cuánto es?

• 1 token ≈ 4 caracteres de código
• ~75,000 líneas de código caben en una sesión
• Un archivo típico (300 líneas) ≈ 1,000-2,000 tokens

Para hacerse una idea: 1M tokens ≈ 750,000 palabras

• 2 Quijotes completos (380K palabras cada uno)
• Guerra y Paz entero y sobra (580K)
• Casi toda la Biblia (775K)

CLAUDE.md: ejemplo

# Mi Proyecto

## Stack
- TypeScript, Node.js, PostgreSQL

## Convenciones
- Tests con vitest: npm test
- Estilo: prettier + eslint
- No tocar: migrations/, vendor/

## Reglas del equipo
- Siempre tests antes de commit
- Commits en español
						

Lo pones en la raíz del repo. Claude lo lee al inicio de cada sesión.

Cuatro niveles, de más amplio a más específico

Los más específicos tienen mayor precedencia. Se concatenan, no se sobreescriben.

Progressive disclosure: no todo se carga siempre

Claude Code carga el contexto por capas, solo cuando lo necesita:

• Siempre — CLAUDE.md en la raíz y directorios padre
• Al acceder a archivos — CLAUDE.md en subdirectorios + rules con paths:
• Bajo demanda — topic files de auto memory, skills invocados

.claude/rules/ — reglas modulares

.claude/
  CLAUDE.md
  rules/
    code-style.md     # siempre cargado
    testing.md        # siempre cargado
    api-design.md     # solo con archivos de src/api/
						

# .claude/rules/api-design.md
---
paths:
  - "src/api/**/*.ts"
---
# API Rules
- Todos los endpoints incluyen validación de input
- Usar el formato estándar de error
						

Sin paths: se carga siempre. Con paths: solo al trabajar con archivos que coinciden.

Imports: @path

CLAUDE.md puede importar otros archivos:

See @README for project overview.
See @package.json for npm commands.

# Additional Instructions
- git workflow @docs/git-instructions.md
						

• Rutas relativas o absolutas
• Los imports se expanden y cargan al inicio de la sesión
• Hasta 5 niveles de profundidad

Auto memory: Claude aprende solo

Claude guarda notas para sí mismo entre sesiones:

~/.claude/projects/<proyecto>/memory/
  MEMORY.md           # índice (200 líneas max en contexto)
  debugging.md        # notas sobre debugging
  api-conventions.md  # decisiones de API
						

• Se activa/desactiva con /memory
• Solo las primeras 200 líneas de MEMORY.md se cargan al inicio
• Los topic files se leen bajo demanda
• Son markdown plano: puedes editarlos o borrarlos

Comandos clave

/init       # genera CLAUDE.md desde tu codebase
/memory     # ver ficheros cargados, toggle auto memory
						

Conecta tus herramientas

Slack, bases de datos, navegador, Notion, calendario...
Claude accede a todo desde el terminal.

MCP: Model Context Protocol

Un protocolo abierto para conectar herramientas externas.

# Añadir un servidor en un comando
claude mcp add slack -- npx @anthropic/mcp-slack

# O explorar el marketplace
/mcp
						

Mi setup del día a día

• Chrome DevTools / Agent Browser — debugging visual, screenshots, navegar la app
• Context7 — documentación actualizada de cualquier librería
• Serena — buscar símbolos, referencias, navegar el código semánticamente
• GitNexus — knowledge graph del codebase: dependencias, call chains, breaking changes
• Sequential Thinking — razonamiento paso a paso para problemas complejos
• Grill me — desafía tus decisiones antes de implementar
• N8N — automatización: conecta Claude con cientos de servicios externos

Todo es reversible

Si algo va mal: Esc Esc

Tu red de seguridad

• Esc Esc → /rewind — vuelve a cualquier estado anterior (código y conversación)
• /clear — limpia la conversación, mantiene tus archivos
• El historial de git siempre queda limpio

No esperes. Sigue trabajando.

Builds, tests, tareas largas... todo en background.

Background tasks

• Pide "ejecuta esto en background" para que Claude lance tareas asíncronas
• Ctrl+B mientras se ejecuta un comando bash o agente → lo envía al fondo
• Claude monitoriza el output y reacciona a fallos automáticamente
• Sub-agents también corren como tareas en background

Multiplícate

Un Claude. Tres tareas. Al mismo tiempo.

Sub-agents

• Claude lanza copias de sí mismo en paralelo
• Cada una investiga una parte del codebase
• Los resultados se consolidan automáticamente
• Define agentes personalizados en .claude/agents/

Worktrees: ramas aisladas

claude --worktree
						

Retoma donde lo dejaste

Las sesiones de Claude Code se guardan. Puedes volver a ellas.

Continuar y retomar

# Continuar la última sesión de este directorio
claude -c

# Nombrar una sesión para encontrarla después
claude -n "auth-refactor"

# Retomar una sesión específica
claude -r "auth-refactor"
						

Dentro de una sesión: /resume para explorar y seleccionar sesiones anteriores

Contexto en sesiones largas

• /compact — comprime el contexto cuando se llena. CLAUDE.md se recarga fresco desde disco.
• /clear — limpia la conversación, mantiene archivos. La sesión anterior sigue disponible para retomar.

PRD vs TDD: dos documentos, dos preguntas

PRD — Product Requirements Document

Documento que define qué problema se va a resolver y por qué importa.

• Lo escribe (o lo guía) producto, no ingeniería
• Responde: ¿qué? ¿por qué? ¿para quién?
• No habla de cómo se implementa — eso vendrá en el TDD

"Requirements" = requisitos. No son tareas: son condiciones que debe cumplir el producto.

PRD — anatomía

NUNCA contiene: código, schemas de BBDD, decisiones de arquitectura.

PRD — por qué importa

• Alinea producto, diseño e ingeniería antes de escribir línea alguna
• Detecta scope creep temprano (--review lo automatiza)
• Open Questions: el agente no asume, pregunta — cada decisión sin resolver queda registrada

TDD — Technical Design Document

Documento que define qué hay que construir en términos técnicos a partir del PRD.

• Lo escribe (o lo guía) ingeniería
• Responde: ¿qué tablas? ¿qué endpoints? ¿qué autorización? ¿qué criterios de aceptación?
• No incluye implementación: signatures sí, function bodies no

Cuidado con el acrónimo: aquí TDD = Technical Design Document, no Test-Driven Development.

TDD — anatomía

NUNCA contiene: cuerpos de funciones, algoritmos detallados, tests escritos.

TDD — por qué importa

• Acceptance criteria = contrato verificable (lo que ac-checker validará)
• Forzamos signatures antes de cuerpos → APIs más limpias
• Cada criterio trazable a un requisito del PRD

Built-in slash commands

Hard-coded en la CLI. Gestionan sesión, contexto, modelo, permisos.

Pulsa / en cualquier sesión para verlos todos.

Custom slash commands

Los /algo que tú o tu equipo crean.

• Personales: ~/.claude/skills/<n>/SKILL.md
• De proyecto (vía git): .claude/skills/<n>/SKILL.md
• Soportan argumentos, frontmatter (disable-model-invocation, allowed-tools) y archivos auxiliares
• Caso típico: /commit-pr, /release-notes con el formato del equipo

Skills: bundled + custom

Prompts empaquetados que Claude invoca manual o automáticamente.

Auto-invocación: si el description del SKILL.md encaja con la petición, Claude lo activa solo. Comando: /skills (pulsa t para ordenar por tokens).

MCPs — Model Context Protocol

Servidores externos que dan a Claude acceso a tools, APIs, BBDD, recursos.

• Locales (en tu máquina) o remotos
• Cada MCP expone tools que Claude llama como cualquier otra
• Config: .claude/mcp.json (proyecto) o ~/.claude/mcp.json (usuario)
• Ejemplos: GitHub, Notion, Linear, tu propio backend

Comando útil: /mcp

Sub-agents

Asistentes especializados con contexto aislado.

• System prompt propio, tools restringidas, descripción para delegar
• Lo que el agente lee no contamina tu sesión principal
• Bundled: Explore, Plan, general-purpose, claude-code-guide...
• Custom: .claude/agents/<n>.md

Comando útil: /agents

Instalación de plugins

Dos vías complementarias para añadir capacidades a Claude Code.

Marketplace: instalar el plugin del curso

# 1. Añadir el marketplace
/plugin marketplace add AdrianRibao/Claude-Code-Vitamins

# 2. Instalar el plugin
/plugin install specs-plugin@claude-code-vitamins
						

Se instalan los comandos: /specs-plugin:prd, /specs-plugin:tdd, /specs-plugin:ac-checker

Auto-update deshabilitado por defecto en marketplaces de terceros — se activa desde /plugin → Marketplaces → Enable auto-update.

skills.sh: skills sueltos

# Instalar un skill desde GitHub
npx skills add vercel-labs/agent-browser

# Actualizar skills (manual, no automático)
npx skills update
						

• Instala solo los SKILL.md
• NO instala comandos, agents, hooks ni MCPs
• Útil para incorporar skills concretos sin meter un plugin entero

Cuando dudes: si el repo expone comandos, usa el marketplace. Si solo necesitas un skill concreto, npx skills add.

ac-checker: cerrar el loop

/specs-plugin:ac-checker \
  specs/tdds/incidents/01-incidents-backend.md \
  --coverage --update
						

• Verifica que cada criterio del TDD está implementado y testeado
• Coverage targets: ≥80% dominio · ≥90% reglas · ≥95% auth
• --update marca los checkboxes en el TDD
• Salida: reporte en specs/tdds/reports/

Lo veremos en acción durante la demo final.

/simplify [focus]

• Skill bundled. Revisa los archivos modificados recientemente
• Busca reuso, calidad y eficiencia — y aplica los fixes
• Lanza 3 agentes de review en paralelo y agrega hallazgos
• Focus opcional: /simplify focus on memory efficiency

Se ejecuta antes de abrir el PR para limpiar lo que acabas de escribir.

/review [PR]

• Revisa una pull request localmente en la sesión actual
• Detecta el PR de la rama actual con gh pr view, o pásale el número/URL
• Para revisión profunda multi-agent en la nube: /ultrareview

Hooks: scripts en eventos

Casos: enforce rules, logs, inyectar contexto, formatear al editar.

/hooks para configurar · /install-github-app para review automático de PRs

Trabaja desde donde quieras

claude remote-control
						

• Tu terminal, visible en el móvil y en claude.ai/code
• Envía prompts, aprueba acciones, monitoriza desde otro dispositivo

Más allá del código

Mención breve. Profundizamos en una sesión futura.

• Marketing: SEO, emails de lanzamiento, copy desde specs
• Ventas: análisis de competidores, propuestas técnicas
• Otros: documentación de usuario, scripts ad-hoc, automatizaciones

Setup proporcionado

• Directorio vacío, sólo con la información inicial proporcionada por Evenbytes
• Seguiremos el proceso paso a paso
• claude mcp add-json sequential-thinking '{"command":"npx","args":["-y","@modelcontextprotocol/server-sequential-thinking"]}'

Paso 2 — PRD writer

/specs-plugin:prd onboarding-app-mvp --type master
						

Open Questions: el plugin no inventa, pregunta

## Open Questions

| ID    | Question                              | Status         |
| ----- | ------------------------------------- | -------------- |
| OQ-01 | ¿Soportamos múltiples empleadores?    | Open           |
| OQ-02 | ¿Tamaño máximo de upload?             | Deferred to v2 |

### OQ-01: Multiple Employers
**Why it matters**: afecta data model, UI, reporting.
**Possible answers**:
- Single (más simple, v1)
- Multiple (mercado más amplio)
						

Análisis profundo con Sequential Thinking. --consolidate aplica las respuestas y limpia el documento.

PRD — flags clave

Paso 3 — TDD writer

/specs-plugin:tdd incidents --type backend \
  --prd @specs/prds/02-incident-management.md
						

El TDD se alimenta del PRD: cada criterio de aceptación es trazable a un requisito.

Splitting: cuándo dividir