Herramientas de código con IA agéntica

Los asistentes de programación con IA han evolucionado desde el simple autocompletado hasta agentes autónomos capaces de planificar, editar varios archivos, ejecutar pruebas y crear pull requests. Este tutorial aborda las tres herramientas principales: Claude Code, Cursor y GitHub Copilot.

1) ¿Qué hace que una herramienta sea «agéntica»?

El completado de código tradicional con IA sugiere las siguientes líneas. Las herramientas agénticas van más allá:

Capacidad	Autocompletado	Agéntica
Alcance	Línea/función actual	Base de código completa
Planificación	Ninguna	Razonamiento de varios pasos
Ejecución	Solo sugerencias	Puede editar archivos y ejecutar comandos
Contexto	Archivo actual	Comprensión de todo el repositorio
Flujo de trabajo	Reactivo	Finalización autónoma de tareas

Las herramientas agénticas pueden comprender toda la estructura de tu proyecto, planificar cambios en varios archivos, ejecutar esos cambios, realizar pruebas e iterar hasta completar la tarea.

2) Comparación rápida: Claude Code vs. Cursor vs. Copilot

Función	Claude Code	Cursor	GitHub Copilot
Interfaz	CLI, web, plugins para IDE	IDE completo (fork de VS Code)	Extensiones para IDE
Ventana de contexto	Grande (Opus de contexto largo)	Indexación de todo el repositorio	Más pequeña, en mejora
Edición de varios archivos	Potente	Excelente	En mejora
Modo de planificación	Sí	Sí	Sí (más reciente)
Precio	Planes Pro/Max	Créditos + suscripción	Suscripción
Ideal para	Arquitectura, grandes refactorizaciones	Desarrollo interactivo	Programación en línea

3) Fundamentos de Claude Code

Claude Code funciona con Opus 4.8 (su modelo predeterminado actual) y grandes ventanas de contexto. Instálalo y autentícate:

# Instalar Claude Code (instalador nativo, recomendado)
curl -fsSL https://claude.ai/install.sh | bash

# O mediante npm (requiere Node 18+)
npm install -g @anthropic-ai/claude-code

# Autenticarse: ejecuta claude y sigue las indicaciones del navegador
claude

# Iniciar en tu proyecto
cd your-project
claude

Comandos básicos

# Preguntar sobre tu base de código
claude "¿Cómo está implementada aquí la autenticación?"

# Generar código
claude "Añade un middleware de limitación de solicitudes"

# Refactorización de varios archivos
claude "Cambia el nombre de UserService a AuthService en toda la base de código"

# Crear un PR
claude "Crea un PR que añada validación de entradas a todos los endpoints de la API"

Configuración del proyecto

Incluye el contexto del proyecto en un archivo CLAUDE.md ubicado en la raíz del repositorio. Claude Code lo lee automáticamente al inicio de cada sesión:

# Notas del proyecto

- Lenguaje: TypeScript, formateado con Prettier
- Pruebas: Vitest, en tests/
- No modificar node_modules/ ni dist/

La configuración legible por máquinas (permisos de herramientas, variables de entorno y hooks) se guarda en .claude/settings.json. Por ejemplo, para exigir aprobación antes de ejecutar herramientas destructivas, configura allí los permisos.

Memoria y contexto

El contexto persistente del proyecto se guarda en archivos CLAUDE.md, que Claude Code carga al inicio de cada sesión, además de un almacén de memoria automática que Claude actualiza por sí mismo según tus correcciones y preferencias. Para proporcionarle contexto permanente, edita CLAUDE.md en lugar de enviar una instrucción puntual del tipo «Recuerda:»:

# CLAUDE.md
Este es un monorepositorio. El código compartido se encuentra en packages/.

Usa el comando /clear dentro de una sesión para restablecer el contexto de trabajo.

4) Funciones agénticas del IDE Cursor

Cursor está diseñado en torno a flujos de trabajo agénticos. Sus funciones principales son:

Modo Agent

Pulsa Cmd+Shift+I (Mac) o Ctrl+Shift+I (Windows/Linux) para abrir Composer en modo Agent:

Flujo de trabajo del modo Agent:
1. Describe tu tarea
2. El agente crea un plan
3. Lo apruebas o modificas
4. El agente ejecuta los cambios
5. Revisas e iteras

Modo Plan

Para tareas complejas, usa explícitamente el modo Plan:

@plan Añade autenticación de usuarios con:
- Tokens JWT
- Rotación de tokens de actualización
- Hashing de contraseñas con bcrypt
- Limitación de intentos de inicio de sesión

El agente:

1. Investigará tu código existente
2. Creará un plan de implementación detallado
3. Esperará tu aprobación
4. Lo ejecutará paso a paso

Inyección de contexto

Usa @ para añadir contexto específico:

@file src/api/auth.ts
@folder src/middleware
@docs https://jwt.io/introduction

Implementa un middleware de verificación de JWT siguiendo estos patrones

Agentes en paralelo

Ejecuta varios agentes simultáneamente en ramas diferentes:

# En Cursor:
1. Abre la paleta de comandos
2. "Cursor: New Agent in Worktree"
3. Cada agente trabaja de forma aislada
4. Compara los resultados en paralelo

Cursor 3 añadió una ventana de agentes (ábrela con Cmd+Shift+P y después «Agents Window») que ejecuta varios agentes en paralelo en checkouts locales, worktrees de git y entornos en la nube. El comando /worktree crea para cada agente su propio worktree aislado de git, mientras que /best-of-n ejecuta la misma tarea con varios modelos para que puedas comparar los resultados en paralelo.

Reglas para mantener la coherencia

Crea .cursor/rules/project.mdc:

# Reglas del proyecto

## Estilo del código
- Usar el modo estricto de TypeScript
- Preferir componentes funcionales
- Usar exportaciones con nombre, no predeterminadas

## Pruebas
- Cada funcionalidad necesita pruebas
- Usar bloques describe/it
- Simular servicios externos

## Seguridad
- Nunca guardar secretos en commits
- Validar todas las entradas del usuario
- Usar consultas parametrizadas

5) Funciones agénticas de GitHub Copilot

Copilot ha evolucionado más allá del autocompletado:

Copilot Chat

Abre el panel de chat y usa comandos con barra:

/explain - Explica el código seleccionado
/fix - Corrige los problemas de la selección
/tests - Genera pruebas
/doc - Añade documentación

Agente de programación (de issue a pull request)

# En GitHub:
1. Abre un issue de GitHub
2. Asígnalo a "Copilot"
3. El agente de programación trabaja en segundo plano:
   analiza el issue, edita archivos y ejecuta pruebas
4. Abre un pull request para que lo revises

Esto es distinto del modo Agent de Copilot dentro del IDE, que trabaja de forma sincrónica contigo en VS Code o JetBrains.

Copilot ahora divide su trabajo autónomo en dos: el modo Agent se ejecuta de forma sincrónica dentro de tu IDE (VS Code y JetBrains), decide qué archivos editar, ejecuta comandos de terminal e itera sobre los errores; el agente de programación se ejecuta de forma asíncrona en la nube, recibe un issue asignado y entrega un pull request mientras tú trabajas en otra cosa.

Sugerencias en línea con contexto

Copilot lee tu base de código. Ayúdalo con comentarios:

// Middleware de autenticación que:
// - Extrae el JWT de la cabecera Authorization
// - Valida la firma del token
// - Adjunta el usuario a la solicitud
// - Devuelve 401 si no es válido
export function authMiddleware(req, res, next) {
  // Copilot genera la implementación
}

6) Mejores prácticas para todas las herramientas

Escribe instrucciones claras

❌ Mal: "Corrige el error"

✅ Bien: "Corrige la excepción de puntero nulo en UserService.getById 
cuando el usuario no exista. Devuelve null en lugar de lanzar una excepción."

❌ Mal: "Añade pruebas"

✅ Bien: "Añade pruebas unitarias para CartService que cubran:
- Añadir artículos a un carrito vacío
- Eliminar artículos
- Calcular totales con descuentos
- Caso límite: cantidades negativas"

Usa el modo de planificación para tareas complejas

Para cualquier tarea que afecte a 3 archivos o más:

1. Pide siempre primero un plan
2. Revisa el plan
3. Apruébalo o modifícalo
4. Deja que el agente lo ejecute
5. Revisa los cambios antes de crear el commit

Proporciona contexto arquitectónico

Antes de un trabajo importante, explica el contexto al agente:

"Esta es una arquitectura de microservicios:
- api-gateway: Enruta las solicitudes
- auth-service: JWT, sesiones
- user-service: CRUD de usuarios
- notification-service: Correo electrónico, notificaciones push

Los servicios se comunican mediante pub/sub de Redis.
La base de datos es PostgreSQL con el ORM Prisma."

Desarrollo guiado por pruebas con agentes

1. Escribe primero una prueba que falle:
   "Escribe una prueba de registro de usuarios que compruebe la validación del correo electrónico"

2. Deja que el agente vea la prueba fallida:
   "Implementa el registro para que esta prueba pase"

3. Itera hasta que todas pasen:
   "Corrige las pruebas que todavía fallan"

7) Consideraciones de seguridad

Las herramientas agénticas tienen un poder real. Establece límites:

Controles de aprobación

// .claude/config.json
{
  "safety": {
    "requireApproval": [
      "rm",
      "git push",
      "npm publish",
      "database migrations",
      "env file changes"
    ]
  }
}

Aislamiento

# Ejecutar agentes en entornos aislados
docker run -v $(pwd):/workspace -it claude-sandbox

# O usar worktrees de git para aislarlos
git worktree add ../feature-branch feature-branch

Archivos confidenciales

# .cursorignore / .claudeignore
.env
.env.*
secrets/
credentials/
*.pem
*.key

Revisa todos los cambios

# Antes de aceptar los cambios del agente:
git diff --stat
git diff

# Usar staging interactivo
git add -p

# Nunca hacer una fusión automática sin revisión

8) Patrones de flujo de trabajo que funcionan

Patrón 1: Explorar, planificar, ejecutar

Sesión 1: "¿Cómo funciona el sistema de pagos?"
          → El agente explora, tú aprendes

Sesión 2: "¿Qué haría falta para añadir Stripe?"
          → El agente crea un plan

Sesión 3: "Implementa la integración con Stripe"
          → El agente ejecuta el plan

Patrón 2: Exploración en paralelo

# En Cursor con agentes en paralelo:

Agente 1: "Implementa almacenamiento en caché con Redis"
Agente 2: "Implementa almacenamiento en caché con Memcached"
Agente 3: "Implementa almacenamiento en caché con una LRU en memoria"

→ Compara las implementaciones y elige el mejor enfoque

Patrón 3: Migración incremental

Paso 1: "Identifica todos los usos de la API obsoleta"
Paso 2: "Crea un adaptador para la nueva API"
Paso 3: "Migra el módulo A para que use el adaptador"
Paso 4: "Migra el módulo B..."
...
Paso N: "Elimina el adaptador y usa directamente la nueva API"

Patrón 4: Desarrollo de funcionalidades comenzando por las pruebas

1. "Escribe pruebas de aceptación para la edición del perfil de usuario"
2. "Escribe pruebas unitarias para la validación del perfil"
3. "Implementa lo necesario para que las pruebas pasen"
4. "Añade pruebas de integración"
5. "Refactoriza para mejorar la claridad"

9) Cuándo usar cada herramienta

Situación	Herramienta recomendada
Programación en tiempo real, ayuda en línea	GitHub Copilot
Grandes refactorizaciones, arquitectura	Claude Code
Sesión de desarrollo completa	Cursor
Preguntas rápidas sobre código	Cualquier interfaz de chat
Crear PR a partir de issues	Copilot Workspace
Cambios complejos en varios archivos	Cursor Agent
Diseño de API, documentación	Claude Code
Aprender una nueva base de código	Cursor o Claude Code

10) Medición de la eficacia

Haz seguimiento de estas métricas para evaluar las herramientas agénticas:

const metrics = {
  // Productividad
  suggestionsAccepted: 'porcentaje de sugerencias que conservaste',
  timeToFeature: 'horas desde el inicio hasta la fusión del PR',
  linesPerHour: 'velocidad de código (usar con cautela)',
  
  // Calidad
  bugsIntroduced: 'defectos atribuidos al código generado por IA',
  testCoverage: 'cobertura del código generado por IA',
  reviewChanges: 'cuánto modificas las sugerencias de la IA',
  
  // Coste
  apiCosts: 'gasto mensual en herramientas de IA',
  creditsUsed: 'créditos de Cursor consumidos',
  
  // Aprendizaje
  newPatternsLearned: 'técnicas que aprendiste de la IA',
  codebaseUnderstanding: 'cuánto te ayudó la IA a aprender',
}

11) Errores comunes

Confiar demasiado en el agente

❌ Aceptar grandes cambios sin revisarlos
❌ Permitir que los agentes ejecuten comandos destructivos
❌ No comprender el código antes de publicarlo

✅ Revisar cada cambio
✅ Comprender lo que publicas
✅ Usar los agentes como colaboradores, no como sustitutos

Contaminación del contexto

❌ Instrucciones enormes con contexto irrelevante
❌ No borrar el contexto entre tareas sin relación
❌ Incluir archivos generados en el contexto

✅ Mantener las instrucciones centradas
✅ Usar referencias específicas de @file
✅ Excluir los artefactos de compilación

Ambigüedad en las instrucciones

❌ "Mejóralo"
❌ "Corrige los problemas"
❌ "Añade algunas pruebas"

✅ "Reduce la complejidad temporal de O(n²) a O(n log n)"
✅ "Gestiona el caso null en la línea 45 devolviendo el resultado antes"
✅ "Añade pruebas para los casos límite: entrada vacía, longitud máxima, Unicode"

12) Lista de comprobación para empezar

## Lista de comprobación de la configuración

### Claude Code
- [ ] Instalar la CLI: `npm install -g @anthropic/claude-code`
- [ ] Autenticarse: `claude login`
- [ ] Crear `.claude/config.json`
- [ ] Añadir `.claudeignore` para los archivos confidenciales

### Cursor
- [ ] Descargarlo desde cursor.com
- [ ] Importar la configuración de VS Code
- [ ] Configurar `.cursor/rules/`
- [ ] Aprender a usar `Cmd+Shift+I` para el modo Agent

### GitHub Copilot
- [ ] Instalar la extensión en tu IDE
- [ ] Activar Copilot Chat
- [ ] Probar Copilot Workspace con issues
- [ ] Configurar `.github/copilot-instructions.md`

### Todas las herramientas
- [ ] Configurar controles de aprobación para las operaciones destructivas
- [ ] Crear archivos de exclusión para los secretos
- [ ] Establecer un flujo de trabajo de revisión
- [ ] Registrar métricas desde el primer día

Contenido relacionado

• Publica un juego web que cargue rápido
• Web Workers para la lógica del juego
• Game jams y hackatones — las herramientas de código con IA están cambiando lo que se puede lograr en una game jam de 48 horas
• Comparación de motores de juegos web — cómo elegir un motor que encaje bien con los flujos de trabajo asistidos por IA