Skills vs. agentes predeterminados: ¿realmente mejoran las skills a Claude Code y Cursor?

Resumen

Las skills son útiles, pero no son mágicas. La mejor evidencia pública indica que las skills específicas, cuidadosamente seleccionadas y activadas en el momento adecuado pueden mejorar el rendimiento de los agentes, mientras que las skills demasiado amplias o mal seleccionadas suelen comportarse como decoración costosa del prompt.

Para el trabajo de programación en Claude Code y Cursor, mi recomendación actual es:

• Usa contexto a nivel de repositorio (CLAUDE.md, AGENTS.md, .cursor/rules) para los datos que el agente siempre debe conocer: stack, arquitectura, comandos de prueba, restricciones y reglas de protección sobre lo que no debe hacer.
• Usa skills para flujos de trabajo repetibles con un punto de entrada claro: revisión de código, notas de lanzamiento, planificación de migraciones, scaffolding de APIs, ejecución de runbooks, uso del sistema de diseño y recetas para generar pruebas.
• Considera las conversaciones largas con agentes como una forma de descubrir flujos de trabajo. Si sigues explicando el mismo procedimiento, extráelo a una skill para que las tareas futuras no repitan el mismo ciclo de descubrimiento.
• No supongas que una skill ayuda solo porque parece organizada. Compárala en un benchmark con una línea base sin skill.
• Ten especial cuidado con las skills generadas automáticamente o provenientes de marketplaces. Varios estudios muestran que las skills irrelevantes, demasiado amplias o incompatibles con la versión pueden no aportar nada o incluso reducir el rendimiento.

El dilema es real, pero la respuesta no es «skills o no skills». La respuesta es contexto persistente para reglas estables, skills para procedimientos específicos de cada tarea y evals para obtener evidencia.

Qué aprenderás aquí

• Qué significan las «skills» en Claude Code y Cursor.
• Qué dicen los benchmarks reales sobre los agentes de programación que usan skills.
• Por qué AGENTS.md o CLAUDE.md a veces superan a las skills.
• En qué casos siguen teniendo sentido las skills.
• Cómo convertir conversaciones repetidas con agentes en skills procedimentales reutilizables.
• Un marco de decisión práctico para ingenieros y PMs.
• Un pequeño ejemplo de código para medir la mejora que aporta una skill en tu propio repositorio.

El problema

Los agentes de programación con IA están mejorando incluso cuando los ejecutas sin configuración personalizada. Claude Code y Cursor ya pueden inspeccionar archivos, ejecutar comandos, editar código, usar herramientas y razonar sobre un repositorio.

Así que surge una pregunta natural:

¿Deberíamos invertir en skills o los agentes predeterminados ya son suficientemente buenos?

Esta pregunta importa porque las skills no son gratis. Añaden mantenimiento, consumo adicional de tokens, incertidumbre sobre su activación, desactualización frente a las versiones y, a veces, riesgos de seguridad. Pero también pueden codificar conocimiento sobre flujos de trabajo que un modelo predeterminado no inferirá de manera confiable.

Este es un modelo mental útil:

                 stable and always relevant
                           |
                           v
    CLAUDE.md / AGENTS.md / .cursor/rules
      architecture, conventions, constraints
                           |
                           v
                 coding agent session
                           |
                           v
               task-specific skill loads
       review workflow, migration recipe, template,
       domain checklist, release process, test harness

Si la información debe orientar casi todas las tareas, probablemente pertenece al contexto del repositorio. Si debe activarse solo durante un flujo de trabajo específico, es candidata para una skill.

Qué son las skills en Claude Code y Cursor

En Claude Code, una skill es una carpeta que contiene un archivo SKILL.md. Claude usa la descripción de la skill para decidir cuándo cargarla, y el contenido completo de la skill entra en la conversación cuando se invoca. Claude Code también admite archivos de apoyo, como plantillas, ejemplos, documentos de referencia y scripts.

.claude/skills/code-review/
  SKILL.md
  checklist.md
  examples/
    good-review.md
  scripts/
    collect-diff.sh

Cursor añadió compatibilidad con Agent Skills en Cursor 2.4, lanzado el 22 de enero de 2026. Cursor describe las skills como archivos SKILL.md que pueden incluir comandos, scripts e instrucciones para especializar el comportamiento del agente. Cursor también cuenta con un sólido conjunto de opciones para el contexto del repositorio: .cursor/rules, reglas de usuario y AGENTS.md.

La distinción importante a nivel de producto:

Always-on context:
  Claude Code: CLAUDE.md
  Cursor: .cursor/rules, AGENTS.md, user rules

On-demand workflow context:
  Claude Code: .claude/skills/<name>/SKILL.md
  Cursor: Agent Skills / SKILL.md support in editor and CLI

Qué dicen los benchmarks

1. SkillsBench: las skills ayudan, pero de manera desigual

SkillsBench es uno de los benchmarks públicos más claros sobre skills para agentes. Evaluó agentes que usan skills en muchas tareas y encontró que las skills cuidadosamente seleccionadas mejoraron la tasa promedio de éxito en 16.2 puntos porcentuales.

Ese resultado principal es alentador, pero los detalles importan:

• La ingeniería de software mejoró solo +4.5 puntos porcentuales en el desglose por área publicado.
• Algunas tareas empeoraron: 16 de 84 tareas mostraron variaciones negativas.
• Las skills generadas automáticamente no aportaron ningún beneficio en promedio.
• Las skills específicas con unos pocos módulos superaron a los paquetes de documentación gigantes y exhaustivos.

Mi interpretación: las skills son más eficaces cuando contienen conocimiento procedimental que el modelo aún no tiene y cuando la tarea realmente necesita ese procedimiento.

2. SWE-Skills-Bench: las mejoras en ingeniería de software suelen ser pequeñas

SWE-Skills-Bench es especialmente relevante porque evalúa tareas de ingeniería de software por separado. Los resultados invitan a la cautela:

• 39 de 49 skills no mejoraron la tasa de éxito.
• La mejora promedio fue de apenas +1.2%.
• Siete skills especializadas lograron mejoras significativas, de hasta +30%.
• Tres skills redujeron el rendimiento, hasta en -10%.
• El consumo adicional de tokens a veces aumentó considerablemente sin mejorar la tasa de éxito.

Esta es la advertencia más contundente contra la idea de que las skills mejoran universalmente la programación. En ingeniería de software, una skill debe encajar con precisión: el framework correcto, la versión correcta, la tarea correcta y el nivel de abstracción correcto.

3. La eval de Vercel: AGENTS.md superó a las skills para documentación de frameworks

Vercel comparó una skill de documentación de Next.js con un índice de documentación en AGENTS.md. El resultado fue sorprendente:

Esto no demuestra que las skills sean malas. Demuestra que invocar una skill requiere tomar una decisión, y los agentes pueden fallar al tomarla. Para la documentación de un framework que debe orientar cada paso relevante de programación, el contexto persistente del repositorio puede superar a la recuperación bajo demanda.

Este patrón es muy importante para quienes usan Claude Code y Cursor. Si el agente siempre debe saber «usamos Next.js 16, usa estas APIs y evita los patrones antiguos», una entrada compacta en AGENTS.md, CLAUDE.md o .cursor/rules puede superar a una skill que el agente podría olvidar cargar.

4. La recuperación de skills en condiciones realistas es frágil

Un estudio posterior sobre el uso de skills por agentes en condiciones realistas evaluó la recuperación desde un gran conjunto de skills reales. Encontró que las mejoras disminuyen cuando el agente tiene que buscar, seleccionar y adaptar las skills por sí solo.

El mismo artículo también mostró un camino a seguir: la recuperación combinada con un refinamiento específico para cada consulta mejoró el resultado de Claude Opus 4.6 en Terminal-Bench 2.0 de 57.7% a 65.5%.

Mi interpretación: las skills funcionan mejor cuando no se le entrega al agente simplemente una pila de archivos. Necesita una buena capa de recuperación, buenas descripciones y, a veces, un paso de refinamiento que adapte la skill a la tarea concreta.

5. Las reglas a nivel de repositorio tampoco son buenas automáticamente

La evidencia sobre los archivos a nivel de repositorio también es contradictoria. Un estudio sobre AGENTS.md encontró que los archivos de contexto tendían a reducir el éxito de las tareas y a aumentar el costo de inferencia. Otro estudio encontró que AGENTS.md redujo el tiempo mediano de ejecución y los tokens de salida, mientras mantenía un comportamiento comparable en las tareas.

También hay un hallazgo útil de la investigación sobre archivos de reglas: las restricciones negativas, como «no refactorices código que no esté relacionado», parecían más beneficiosas que las indicaciones positivas generales, como «sigue un buen estilo».

Así que el mensaje práctico no es «pon todo en AGENTS.md». Es este:

• Mantén compactos los archivos de contexto permanente.
• Prioriza las restricciones y la navegación sobre las explicaciones largas.
• No codifiques todos los flujos de trabajo de forma global.
• Traslada los procedimientos a skills solo cuando sean específicos y medibles.

Claude Code vs. Cursor: diferencias prácticas

Claude Code y Cursor ahora admiten la misma idea general: instrucciones reutilizables para el agente y skills específicas para cada tarea. La diferencia está en la experiencia de desarrollo.

Para los PMs, la distinción importante es esta: las skills no son solo «más contexto». Son activos de flujo de trabajo gestionados como producto. Una buena skill captura cómo quiere el equipo que se haga una tarea, no solo cómo es el código del proyecto.

De una conversación con un agente a una skill reutilizable

Una de las formas más prácticas de encontrar buenas skills no es imaginar una biblioteca gigante de skills desde el principio. Es observar lo que sucede en sesiones reales con agentes.

Si un equipo tiene que explicarle repetidamente los mismos pasos a un agente, o si una conversación larga de depuración, revisión, migración o lanzamiento produce un procedimiento confiable, esa conversación es una señal. Lo útil es extraer el procedimiento estable y convertirlo en una skill pequeña.

El ciclo de vida se ve así:

agent chat
  -> repeated explanation or correction
  -> stable procedure emerges
  -> convert procedure into SKILL.md
  -> test on future similar tasks
  -> keep, trim, or remove based on results

Esto puede reducir el consumo futuro de tokens, pero solo en el sentido específico de que puede reducir la repetición de prompts, la exploración y las correcciones. La propia skill sigue consumiendo tokens cuando se carga. Así que el objetivo no es «agregar una skill para ahorrar tokens». El objetivo es «evitar redescubrir el mismo flujo de trabajo cuando basta con un procedimiento compacto que se active en el momento adecuado».

Los buenos candidatos suenan así:

• «Cada vez que pedimos un lanzamiento, explicamos los mismos pasos de rama, changelog, tag y verificación».
• «Cada revisión de migración de API termina en la misma lista de verificación de compatibilidad».
• «Cada tarea del sistema de diseño necesita la misma búsqueda de componentes y las mismas reglas de tokens».
• «Cada informe de incidente necesita el mismo formato de cronología, impacto en clientes, causa raíz y seguimiento».

Los malos candidatos suenan así:

• «Haz que el agente programe mejor».
• «Recuerda toda nuestra documentación».
• «Usa este enorme archivo de ejemplos siempre que pueda ser útil».

Marco de decisión

Usa esta regla sencilla:

Does the agent need this on almost every task?
  yes -> put it in CLAUDE.md / AGENTS.md / .cursor/rules
  no  -> continue

Is it a repeatable workflow with a clear trigger?
  yes -> make a skill
  no  -> use a one-off prompt or normal docs

Did the workflow emerge from repeated agent chats?
  yes -> extract the stable steps, not the whole transcript
  no  -> continue

Can you verify improvement with a small eval?
  yes -> keep and iterate
  no  -> treat it as experimental

Una versión más concreta:

Una pequeña eval de la mejora aportada por una skill

No necesitas un benchmark gigante para empezar. Crea entre cinco y diez tareas que tu equipo realmente les pida a los agentes y luego ejecuta cada tarea dos veces:

1. Agente predeterminado con el contexto normal del repositorio.
2. El mismo agente con la skill disponible o invocada explícitamente.

Registra si la tarea pasa o falla, los tokens, el tiempo transcurrido y los comentarios de revisión.

Para las skills derivadas de conversaciones, incluye al menos una tarea en la que el agente predeterminado normalmente pierda tiempo redescubriendo el procedimiento. Solo vale la pena conservar la skill si reduce la necesidad de repetir explicaciones, corregir o revisar lo suficiente como para justificar los tokens que añade al cargarla.

type EvalResult = {
  taskId: string;
  mode: "default-agent" | "with-skill";
  passed: boolean;
  elapsedMs: number;
  inputTokens: number;
  outputTokens: number;
  reviewerNotes: string;
};

function summarizeSkillLift(results: EvalResult[]) {
  const byMode = new Map<string, EvalResult[]>();

  for (const result of results) {
    byMode.set(result.mode, [...(byMode.get(result.mode) ?? []), result]);
  }

  for (const [mode, rows] of byMode) {
    const passRate = rows.filter((row) => row.passed).length / rows.length;
    const avgTokens =
      rows.reduce((sum, row) => sum + row.inputTokens + row.outputTokens, 0) /
      rows.length;

    console.log(`${mode}: ${(passRate * 100).toFixed(1)}% pass, ${avgTokens.toFixed(0)} avg tokens`);
  }
}

Lo que buscas no es «se usó la skill». Buscas evidencia de que la skill mejoró los resultados lo suficiente como para justificar su mantenimiento.

La estructura de una buena skill

Una buena skill de programación es específica, fácil de navegar y comprobable.

---
name: api-migration-review
description: Use when reviewing an API migration PR that changes routes, schemas, auth, or backward compatibility.
---

## Goal

Review an API migration for compatibility, safety, and rollout risk.

## Checklist

1. Identify changed routes and request/response schemas.
2. Check whether existing clients can still call the old contract.
3. Verify auth and permission changes.
4. Look for database migration coupling.
5. Confirm tests cover old and new behavior.

## Output

Return:
- blocking issues
- non-blocking concerns
- missing tests
- rollout risk: low, medium, or high

Observa lo que esta skill no hace. No enseña toda la arquitectura del backend. No incluye todas las directrices de API que la empresa haya escrito. Le da al agente un procedimiento repetible para una tarea de revisión específica.

Análisis de la investigación de este artículo

Esta es la síntesis honesta:

• Evidencia a favor de las skills: SkillsBench muestra una mejora promedio significativa con skills cuidadosamente seleccionadas, y la recuperación en condiciones realistas combinada con refinamiento puede mejorar el rendimiento en Terminal-Bench.
• Evidencia contra el uso ingenuo de skills: SWE-Skills-Bench muestra pequeñas mejoras promedio en ingeniería de software, muchas skills sin mejoras y algunas perjudiciales.
• Evidencia a favor del contexto permanente: la eval de Next.js de Vercel mostró que un índice compacto de documentación en AGENTS.md superó a la recuperación basada en skills.
• Evidencia contra el exceso de contexto permanente: los estudios sobre AGENTS.md discrepan; algunos muestran una reducción en el éxito de las tareas o un aumento del costo.
• Evidencia a favor de las evals locales: las propias actualizaciones de skill-creator de Anthropic hacen énfasis en pruebas, benchmarks, comparación A/B, uso de tokens y comprobaciones de regresión.

El patrón es lo suficientemente consistente como para actuar:

Default agent
  good for: general coding, exploration, one-off changes

Repo context
  good for: stable constraints, architecture, commands, version facts

Skills
  good for: narrow procedures, repeated workflows, tool-backed actions

Evals
  good for: deciding whether any of the above actually helped

Vacíos actuales

Encontré algunos vacíos que vale la pena señalar:

• Los benchmarks públicos y controlados que comparan específicamente Cursor con skills frente a Cursor sin skills siguen siendo limitados. Cursor ha realizado un trabajo sólido de evaluación de agentes mediante CursorBench, pero esa investigación trata sobre la calidad de los modelos y agentes, no específicamente sobre la mejora aportada por las skills.
• Muchos benchmarks públicos de skills evalúan condiciones cuidadosamente preparadas. Los equipos reales necesitan pruebas con condiciones desordenadas: documentación desactualizada, reglas duplicadas, malas descripciones de skills, desajustes de versión y varias skills que compiten por la misma tarea.
• Necesitamos más métricas útiles para PMs: no solo la tasa de éxito, sino también el tiempo de revisión ahorrado, la tasa de defectos, la cantidad de retrabajo y la frecuencia con la que el agente hace mejores preguntas.
• La seguridad de las skills merece más atención. Una skill puede incluir scripts e instrucciones operativas, por lo que debe revisarse como si fuera código.

Recomendación final

Para los equipos que usan Claude Code y Cursor, empezaría con este modelo de trabajo:

1. Primero escribe un archivo compacto de contexto del repositorio.
2. Observa sesiones reales con agentes para detectar ciclos repetidos de explicación.
3. Añade skills solo para flujos de trabajo repetidos que el equipo pueda identificar.
4. Mantén cada skill lo suficientemente pequeña para que el agente realmente pueda seguirla.
5. Prefiere skills con scripts, ejemplos o listas de verificación en lugar de consejos vagos.
6. Ejecuta una pequeña eval A/B antes de estandarizar una skill para todo el equipo.

Los mejores equipos no preguntarán «¿deberíamos usar skills?». Preguntarán:

¿Qué parte de nuestro flujo de trabajo con agentes necesita contexto persistente, qué parte necesita un procedimiento reutilizable y qué parte necesita una comprobación ejecutable?

Ahí es donde las skills se vuelven útiles: no como decoración, sino como infraestructura de flujos de trabajo con resultados medibles.

Lista de fuentes

• Documentación de Claude Code: amplía Claude con skills
• Changelog de Cursor 2.4: subagentes, skills y generación de imágenes
• Documentación de Cursor: reglas y AGENTS.md
• Investigación de Cursor: cómo comparamos la calidad de los modelos en Cursor
• Vercel: AGENTS.md supera a las skills en nuestras evals de agentes
• SkillsBench: evaluación de la eficacia de las skills de agentes en tareas diversas
• SWE-Skills-Bench: ¿realmente ayudan las skills de agentes en la ingeniería de software del mundo real?
• ¿Qué tan bien funcionan las skills de agentes en condiciones reales?
• Evaluación de AGENTS.md: ¿son útiles los archivos de contexto a nivel de repositorio para los agentes de programación?
• Sobre el impacto de los archivos AGENTS.md en la eficiencia de los agentes de programación con IA
• Las restricciones superan a las indicaciones: un estudio a gran escala de reglas, skills y configuración persistente para agentes de programación
• Anthropic: mejoras a skill-creator para probar, medir y refinar Agent Skills