Mientras el Mundo Discutía el Autocompletado, Claude Code ya Estaba Ejecutando Bash en tu Terminal
Mira tu IDE. ¿Qué hace el "autocompletado" de tu editor cuando le pides que añada paginación a un endpoint? Sugiere texto. Nada más.
Claude Code no sugiere. Ejecuta.
Lee tus ficheros, escribe en ellos, lanza comandos bash, corre los tests y corrige sus propios errores. Todo desde la terminal. Y en octubre de 2025 llegó Checkpoints — la primera máquina del tiempo fiable para agentes autónomos.
*El debate ya no es si la IA escribe código. Es si le vas a dejar ejecutarlo. *
Este es el tutorial de Claude Code 2026 que me habría ahorrado semanas de probar la herramienta como un chatbot caro.
La Creencia Errónea: Copilot Dentro de un Editor, con un Packaging Distinto
La narrativa dominante dice que "IA para programar" = sugerencias inline estilo Copilot dentro del IDE.
>> Eso describe mal a Claude Code por cuatro razones:
❌ No hay editor involucrado. Todo ocurre en la terminal. Es una CLI agéntica.
❌ No solo genera código. Lee archivos, los escribe, ejecuta bash y puede buscar en la web.
❌ No espera a que teclees. Planifica, ejecuta y te reporta. Si algo falla, intenta corregirlo.
❌ No es solo un producto de Anthropic. Puedes redirigir el endpoint a otros modelos. Es una runtime agéntica, no un editor.
El cuello de botella, por tanto, deja de ser "qué tecleo" y pasa a ser "cómo especifico intención y cómo vigilo la ejecución".
Esto cambia la habilidad que necesitas. No es teclear mejor. Es especificar sistemas completos y supervisar su despliegue — exactamente lo que hace un buen arquitecto frente a un buen mecanógrafo.
El Problema: un Agente que Ejecuta bash es un Riesgo, hasta que Tiene Freno
Aquí está el salto cualitativo que la mayoría no ve.
Un plugin de sugerencias nunca necesitó permisos porque nunca ejecuta nada. Solo te propone texto y tú decides.
Claude Code corre comandos de verdad. Y ahí es donde se separa el grano de la paja.
La arquitectura de confianza tiene tres capas:
1. Permisos. Sandbox que controla qué herramientas puede usar. Modos de permiso configurables y lista blanca de herramientas.
2. Checkpoints. Snapshot del estado del agente. Si rompe algo, vuelves a un punto anterior.
3. Hooks. Enlaces que se ejecutan antes o después de acciones concretas, para meter lógica tuya en el flujo.
Para el operador, esto significa que "dejar que la IA toque tu repo" deja de ser una apuesta y pasa a ser una configuración.
La objeción clásica es directa: "no confío en un agente que ejecuta bash en mi máquina". Respuesta: empieza con herramientas limitadas, ejecuta el modo de planificación primero, y sube permisos gradualmente. La seguridad está diseñada en capas, no pegada con cinta.
Evidencia: Esto Funciona, y Así se Ve
Vamos con lo práctico. Abre tu terminal e instala Claude Code. Luego, primera tarea agéntica real.
Ejemplo 1: Tarea one-shot, no un prompt
El error más común es usar Claude Code como un chat donde pides snippets. En su lugar, pide una tarea completa y observable:
```bash
claude "añade un endpoint /users con paginación por curso y tests"
```
Qué ocurre detrás:
1. Planifica. Lee la estructura del proyecto, los ficheros de ruta y los modelos existentes.
2. Ejecuta. Edita los archivos necesarios, crea los tests.
3. Verifica. Corre `npm test` u `opta por el gestor que uses`, ve los fallos, corrige.
4. Reporta. Te dice qué cambió, qué falta y qué no pudo verificar.
Ese ciclo planifica-edita-ejecuta-verifica es la diferencia real entre una herramienta de sugerencias y un agente.
Ejemplo 2: Memoria de proyecto con CLAUDE.md
El siguiente error más común: no darle memoria al agente.
Un fichero `CLAUDE.md` en la raíz del repo actúa como memoria persistente de proyecto. El agente lo relee en cada sesión para respetar tus convenciones.
```markdown
CLAUDE.md
Arquitectura
Monorepo con apps/web (Next.js) y apps/api (Fastify)
Capa de datos en packages/db con Drizzle
Convenciones
Componentes en inglés, comentarios en español
Tests con vitest junto al código (co-located)
Comandos
Build: `npm run build --workspace apps/web`
Test: `npm run test --workspace apps/api`
Lint: `npm run lint`
```
Resultado: el agente deja de adivinar. La calidad de sus respuestas sube porque opera con tu contexto, no con suposiciones.
Ejemplo 3: Subagentes para delegar
Con Claude Code 2.0 llegaron los subagentes: tareas que ejecutan en ventanas de contexto separadas. Esto sortea el techo de contexto del modelo principal.
Crea `.claude/agents/revisor.md`:
```yaml
---
name: revisor
description: Revisa pull requests, detecta bugs y sugiere mejores.
tools: Read, Grep, Bash
model: claude-sonnet-4
---
Revisa los cambios en el diff. Busca errores de seguridad,
duplicación y tests que no cubren el caso límite.
```
El agente principal delega la revisión de un PR a este subagente — con contexto fresco — mientras él sigue con otra tarea. Es contratar empleados con memoria independiente.
El efecto en tu forma de trabajar: las tareas grandes se descomponen para repartirse entre agentes, igual que un equipo reparte tickets.
Ejemplo 4: Conectar tu stack real con MCP
Claude Code es la implementación de referencia de MCP (Model Context Protocol) — el estándar abierto que está consolidándose como el USB-C de la IA.
Conecta una base de datos o un gestor de incidencias:
```bash
claude mcp add --transport stdio mi-bd -- npx mi-servidor-mcp
```
Ahora el agente consulta tu esquema real, lee tickets abiertos, ve el estado del CI. Trabaja con tu contexto, no con el que imagina.
Cada servidor MCP que publica la comunidad amplía lo que el agente puede hacer sin que Anthropic escriba una integración. Elegir herramientas que hablen MCP es inversión a futuro, no capricho.
Análisis: el Efecto Cultural que Nadie Menciona
Hay un efecto secundario del CLAUDE.md que es casi más valioso que la propia herramienta: la documentación vuelve a ser un activo que los equipos mantienen.
Durante una década, la comunicación de los equipos se movió al chat. La documentación murió. Con Claude Code, tu documentación es directamente proporcional a la calidad del agente.
Los equipos que mantienen un buen CLAUDE.md — arquitectura, decisiones, comandos — descubren que el agente comete menos errores y necesitan menos correcciones.
El agente no te ahorra documentar. Te obliga a documentar bien.
Y hay una segunda implicación, más profunda. La ventana de contexto del agente es tu nuevo lienzo. Cuando estructuras un sistema, ya no piensas en "qué archivos edito" sino en "qué información necesita el agente para tomar decisiones correctas". Es pensar en sistemas, no en ficheros.
El Marco del Operario Autónomo: 6 Pasos para Dominar Claude Code en 2026
Aquí está el método que uso con cada proyecto nuevo. Lo llamo El Marco del Operario Autónomo:
Paso 1: Primera tarea agéntica en terminal
No en el editor. Pide algo concreto y observable: "añade un endpoint con paginación y tests". Observa el ciclo completo planifica-edita-ejecuta-verifica. Ahí entiendes qué es realmente la herramienta.
Paso 2: Crea el CLAUDE.md desde el día uno
Arquitectura, convenciones, comandos de build y test. El agente lo relee en cada sesión. Es tu palanca de calidad más barata.
Paso 3: Define 2-3 subagentes para roles recurrentes
Un corrector de bugs, un revisor de PR, un refactorizador. En `.claude/agents/*.md` con frontmatter YAML. Delega en contextos separados y paralelos.
Paso 4: Guardarraíles desde el minuto cero
Configura los modos de permiso y la lista blanca de herramientas. Activa checkpoints antes de cualquier refactor de riesgo. Si el agente rompe algo, reviertes al snapshot.
```bash
Antes de un refactor arriesgado:
claude --permission-mode plan "analiza el refactor de auth y proponme el plan"
Al validar el plan, ejecuta con checkpoints activados:
claude "ejecuta el refactor de auth; si algo falla, revierte al checkpoint anterior"
```
(Verifica la sintaxis exacta de flags y comandos de checkpoints contra la documentación oficial actual — esto evoluciona rápido.)
Paso 5: Conecta tu stack vía MCP
Base de datos, gestor de incidencias, CI. Que el agente trabaje con datos reales, no con suposiciones. `claude mcp add` y listo.
Paso 6: Automatiza en CI
Ejecuta Claude Code en modo headless dentro del pipeline. Por ejemplo, revisión de pull requests con GitHub Actions. La agencia deja de ser una herramienta local y se convierte en parte del pipeline.
```yaml
GitHub Actions: revisión de PR con Claude Code
steps:
uses: actions/checkout@v4
run: claude --headless --allowedTools "Read,Grep" \
"Revisa este PR. Busca regresiones y bugs de seguridad."
```
Conclusiones: la Habilidad que de Verdad Cambia
Resumen de lo esencial:
✅ Claude Code no es un autocompletado. Es un agente que planifica, ejecuta bash y se corrige.
✅ El CLAUDE.md es tu palanca de calidad. Documentación bien mantenida = agente con menos errores.
✅ Los subagentes sortean el techo de contexto. Trabajo paralelo en ventanas separadas.
✅ Checkpoints resolvieron el freno de confianza. Ya puedes revertir el trabajo del agente.
✅ MCP es inversión a futuro. Cada servidor publicado amplía el agente sin trabajo extra.
✅ La seguridad es configuración, no apuesta. Permisos + checkpoints + hooks, en capas.
El cambio real que trae Claude Code no es técnico. Es una cuestión de confianza y de especificación.
La habilidad que necesitas ya no es escribir código perfecto a mano. Es especificar sistemas completos con claridad y supervisar su ejecución — el trabajo de un operario que sabe qué quiere, no de un mecanógrafo que teclea rápido.
Y la objeción de que "es solo un wrapper de la API, podría construirlo yo mismo" subestima lo brutal que es el resto: la seguridad en capas, la memoria persistente, la UX del bucle agente-usuario y el ecosistema MCP son el producto.
No el prompt.
El debate de 2026 no es si te vas a subir a los agentes. Es cómo de bien los vas a dirigir.
Lee el artículo completo en brianmenagomez.com
Más sobre mis servicios en brianmenagomez.com
Herramientas: Conversor IAE CNAE · Gestorias cerca de ti · Calculadora IRPF