Plugins vs Servidores MCP vs Skills

Preludio

Cuando empiezas a construir extensiones para Claude Code, la misma pregunta surge una y otra vez. ¿Debería construir un plugin, escribir un servidor MCP o simplemente crear un skill? La documentación explica cada uno individualmente, pero nada te dice cómo pensar en los tres juntos. Es fácil construir lo incorrecto antes de desarrollar un modelo mental claro.

La confusión es comprensible. Los tres mecanismos extienden lo que Claude Code puede hacer. Los tres se pueden compartir con un equipo. Los tres residen en archivos de configuración o directorios de proyecto. Desde fuera, parecen tres nombres para el mismo concepto.

No lo son. Cada uno resuelve un problema diferente en una capa diferente del sistema. Una vez que se entienden los límites, elegir entre ellos se vuelve obvio.

Esta guía es la comparación de extensiones de Claude Code que nos hubiera gustado tener hace doce meses. Recorreremos qué es cada mecanismo, cuándo recurrir a él y cómo combinar los tres para un flujo de trabajo de desarrollo que cubra todos los casos de uso que encontrarás.

El Problema

Claude Code de serie es potente. Lee archivos, escribe código, ejecuta comandos y razona sobre tu proyecto. Pero cada equipo tiene necesidades únicas. Puede que necesites que Claude consulte una base de datos privada, aplique una lista de verificación de despliegue o interactúe con una API interna de la que nadie fuera de tu organización ha oído hablar.

En el momento en que intentas extender Claude Code, te enfrentas a una decisión triple. El sistema de plugins ofrece un marketplace de herramientas preconstruidas. El Model Context Protocol te permite construir servidores de herramientas personalizadas en cualquier lenguaje. Y los skills te permiten definir slash commands que se expanden en prompts.

Elegir mal desperdicia tiempo. Una vez construimos un servidor MCP completo en Rust para proporcionar un conjunto de prompts de revisión de código, solo para darnos cuenta de que unos pocos archivos markdown en .claude/commands/ habrían logrado lo mismo en diez minutos. También pasamos semanas intentando estirar un skill para hacer algo que requería llamadas reales a APIs, cuando un servidor MCP era la respuesta correcta desde el principio.

El coste de elegir mal no es solo tiempo de desarrollo. Es carga de mantenimiento, confusión del equipo y capacidades desaprovechadas. Esta guía te dará un marco claro para que nunca construyas lo incorrecto.

El Camino

Qué Son los Plugins

Los plugins son extensiones empaquetadas distribuidas a través de marketplaces de plugins. Cuando instalas un plugin, obtienes un paquete que puede incluir herramientas, prompts, skills e incluso servidores MCP. Piensa en un plugin como un paquete completo, similar a una extensión de VS Code o un complemento de navegador.

Instalas plugins desde dentro de Claude Code usando el slash command /install y seleccionando de los plugins disponibles en el marketplace. También puedes explorar y gestionar plugins a través del comando /plugins dentro de una sesión de Claude Code.

Una vez instalado, las capacidades de un plugin están disponibles en cada sesión de Claude Code. Si el plugin proporciona una herramienta llamada query_database, Claude puede llamar a esa herramienta siempre que determine que es relevante para tu prompt. Si el plugin proporciona skills, esos skills aparecen como slash commands que puedes invocar.

Los plugins se pueden instalar globalmente (disponibles en todos los proyectos) o localmente (disponibles solo en un proyecto específico). Los administradores empresariales pueden usar configuraciones gestionadas para controlar qué plugins están permitidos en toda la organización.

La característica clave de los plugins es que alguien más los construyó. Tú los instalas, configuras y usas. Si necesitas algo que ofrece un marketplace, un plugin es el camino más rápido para conseguirlo. Si estás construyendo algo para que otros lo usen, publicar un plugin es cómo lo distribuyes.

Qué Son los Servidores MCP

El Model Context Protocol es un estándar abierto para conectar modelos de IA con datos y herramientas externas. Un servidor MCP es un programa que habla este protocolo y expone capacidades que Claude Code puede usar. A diferencia de los plugins, normalmente construyes los servidores MCP tú mismo para resolver problemas específicos de tu organización.

Los servidores MCP proporcionan tres tipos de capacidades. Las herramientas son funciones que Claude puede llamar, como consultar una base de datos o crear un ticket en Jira. Los recursos son datos que Claude puede leer, como archivos de documentación o valores de configuración. Los prompts son plantillas que guían el comportamiento de Claude para tareas específicas.

Un servidor MCP puede ejecutarse localmente sobre stdio (entrada/salida estándar) o remotamente sobre HTTP. El transporte stdio es más simple. Tu servidor MCP es un programa en tu máquina, y Claude Code lo lanza como un proceso hijo y se comunica a través de pipes. El transporte HTTP es más flexible. Tu servidor MCP se ejecuta en un host remoto, y Claude Code envía solicitudes por la red.

Configuras los servidores MCP en tu settings.json o en el archivo .mcp.json de tu proyecto.

{
  "mcpServers": {
    "my-database": {
      "command": "node",
      "args": ["./mcp-servers/database-server.js"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb"
      }
    }
  }
}

El poder de los servidores MCP es que se pueden escribir en cualquier lenguaje. Python, TypeScript, Rust, Go. Lo que mejor conozca tu equipo. Para un recorrido completo de cómo construir uno desde cero, nuestra guía para construir servidores MCP en Rust cubre el proceso completo. El protocolo maneja la capa de comunicación, así que tú te enfocas enteramente en la lógica de negocio.

Qué Son los Skills

Los skills son el más simple de los tres mecanismos. Un skill es un archivo markdown que define un slash command. El enfoque moderno es colocar los skills en el directorio .claude/skills/, donde cada skill obtiene su propio subdirectorio con un archivo SKILL.md. El directorio más antiguo .claude/commands/ también funciona, pero .claude/skills/ es la ruta recomendada para proyectos nuevos. Cuando escribes /nombre-del-skill en Claude Code, el contenido de ese archivo se expande en un prompt y se envía a Claude.

Aquí tienes un skill simple que genera una revisión de código.

Revisa el siguiente archivo buscando:
- Vulnerabilidades de seguridad
- Problemas de rendimiento
- Violaciones de estilo de código
- Manejo de errores faltante

Archivo a revisar: $ARGUMENTS

Proporciona sugerencias accionables con ejemplos de código.

Guarda eso como .claude/skills/review/SKILL.md, y puedes invocarlo con /review src/auth.rs. El marcador $ARGUMENTS se reemplaza con lo que escribas después del nombre del comando.

Los skills no requieren código. Ni compilación. Ni conocimiento del protocolo. Escribes un archivo markdown y se convierte en un comando. Esto hace que los skills sean el mecanismo de extensión más accesible. Cualquier miembro del equipo puede crearlos o modificarlos, independientemente de su capacidad de programación. Para equipos que incluyen no-desarrolladores, nuestra guía sobre skills para equipos no técnicos cubre cómo involucrar a todos.

Los skills se envían al repositorio de tu proyecto, haciéndolos disponibles para todos los que trabajan en el proyecto. Esto convierte las convenciones del equipo en comandos ejecutables. En lugar de documentar "así es como escribimos archivos de migración", creas un skill /migration que genera uno correctamente cada vez.

Para una visión más amplia de cómo los skills encajan en la colaboración del equipo, nuestra guía sobre skills y el marketplace cubre el panorama completo.

Comparación Rápida

Plugins en Detalle

El ecosistema de plugins es donde empiezas cuando tienes una necesidad común. Antes de construir nada, explora los plugins disponibles. Es muy probable que alguien ya haya resuelto tu problema.

Instalar un plugin sucede dentro de Claude Code. Usa el slash command /install para explorar e instalar desde los marketplaces disponibles. También puedes usar /plugins para gestionar tus plugins instalados, ver sus capacidades y configurarlos.

Una vez instalados, los plugins aparecen en tu configuración y sus herramientas quedan disponibles para Claude. Puedes revisar y gestionar los plugins instalados en cualquier momento a través del comando /plugins dentro de una sesión de Claude Code.

La configuración de plugins se maneja a través de la interfaz de configuración de Claude Code. Los equipos empresariales pueden usar configuraciones gestionadas para definir qué plugins están aprobados para la organización, enviar configuraciones por defecto y bloquear plugins no aprobados. Esto te da la extensibilidad de un marketplace sin el riesgo de seguridad de una instalación de herramientas sin control.

La limitación de los plugins es que resuelven problemas generales. Si necesitas una herramienta que consulte la API propietaria de tu empresa con tu esquema de autenticación específico y tu modelo de datos específico, no la encontrarás en el marketplace. Ahí es donde entran los servidores MCP.

Servidores MCP en Detalle

Los servidores MCP brillan cuando necesitas que Claude interactúe con algo específico de tu organización. Una base de datos privada. Una API REST interna. Un pipeline de despliegue personalizado. Un formato de datos propietario.

El protocolo es simple. Tu servidor declara qué capacidades tiene (herramientas, recursos, prompts), y Claude Code las descubre al inicio. Cuando Claude decide usar una herramienta, envía una solicitud JSON a tu servidor, tu servidor la procesa y devuelve una respuesta JSON.

Aquí tienes un servidor MCP mínimo en TypeScript que proporciona una única herramienta.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new McpServer({ name: "ticket-server", version: "1.0.0" });

server.tool("create_ticket", {
  title: { type: "string" },
  priority: { type: "string", enum: ["low", "medium", "high"] }
}, async ({ title, priority }) => {
  const ticket = await createInternalTicket(title, priority);
  return { content: [{ type: "text", text: `Created ticket ${ticket.id}` }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);

La flexibilidad es enorme. Tu servidor MCP puede llamar a cualquier API, leer cualquier base de datos, ejecutar cualquier lógica. Se ejecuta como un proceso separado, así que puede mantener conexiones, almacenar datos en caché y gestionar estado independientemente de Claude Code.

Para el ecosistema de servidores MCP y extensiones, el estándar está evolucionando rápidamente. Los servidores MCP remotos sobre HTTP abren posibilidades como servidores compartidos de equipo, integraciones alojadas y gestión centralizada de herramientas.

La contrapartida es el esfuerzo de desarrollo. Necesitas escribir código, manejar errores, gestionar dependencias y mantener el servidor a lo largo del tiempo. Para flujos de trabajo simples basados en prompts, ese esfuerzo no está justificado. Pero para cualquier cosa que involucre datos externos o efectos secundarios, los servidores MCP son la elección correcta.

Skills en Detalle

Los skills ocupan un nicho único. No son herramientas en el sentido tradicional. No llaman a APIs ni devuelven datos. Son plantillas de prompts que codifican el conocimiento del equipo en comandos repetibles.

El directorio .claude/skills/ es tu biblioteca de skills. Cada subdirectorio contiene un archivo SKILL.md que se convierte en un slash command.

.claude/skills/
  review/SKILL.md       -> /review
  deploy/SKILL.md       -> /deploy
  migration/SKILL.md    -> /migration
  docs-api/SKILL.md     -> /docs-api
  docs-changelog/SKILL.md -> /docs-changelog

Los skills soportan la variable $ARGUMENTS para entrada del usuario. También soportan contenido multilínea, bloques de código y cualquier formato markdown. El contenido completo del archivo se inyecta en la conversación como un prompt.

Aquí tienes un skill más sofisticado para generar migraciones de base de datos.

Genera una migración de base de datos para el siguiente cambio: $ARGUMENTS

Sigue estas reglas:
1. Usa el framework de migraciones del proyecto (encontrado en db/migrations/)
2. Incluye migraciones tanto de ida como de vuelta
3. Usa castellano en los comentarios
4. Añade un índice para cualquier nueva columna de clave foránea
5. Prueba la migración contra el esquema en db/schema.sql

Nombra el archivo de migración con el formato: YYYYMMDD_HHMMSS_descripcion.sql

La belleza de los skills es que codifican el conocimiento institucional. Un nuevo miembro del equipo no necesita conocer tus convenciones de migración. Escribe /migration add user_preferences table with theme and language columns y obtiene una migración correctamente formateada cada vez.

Los skills se versionan con tu proyecto. Evolucionan con tu base de código. Cuando tus convenciones cambian, actualizas el archivo del skill. Cada miembro del equipo obtiene la actualización en su siguiente pull.

Cuándo Usar Plugins

Recurre a los plugins cuando el problema es común. Si necesitas integración con GitHub, consultas a bases de datos, gestión de Jira, notificaciones de Slack o cualquier otra capacidad conocida, consulta el marketplace primero.

Los plugins son la elección correcta cuando quieres una solución que alguien más mantiene. El autor del plugin se encarga de las actualizaciones, correcciones de errores y compatibilidad con nuevas versiones de Claude Code. Tú consumes la capacidad sin asumir la carga de mantenimiento.

Los plugins también son la elección correcta para entornos empresariales donde necesitas control sobre qué herramientas están disponibles. Las configuraciones gestionadas permiten a los administradores aprobar plugins específicos y enviar configuraciones. Esto es mucho más fácil de gobernar que una colección de servidores MCP personalizados dispersos en las máquinas individuales de los desarrolladores.

La decisión es simple. Si el marketplace tiene lo que necesitas y no requieres personalización más allá de la configuración, instala un plugin.

Cuándo Usar Servidores MCP

Recurre a los servidores MCP cuando necesitas acceso a datos personalizado o efectos secundarios personalizados. Cada vez que Claude necesite interactuar con algo único de tu organización, un servidor MCP es casi con certeza la respuesta.

Los casos de uso comunes de servidores MCP incluyen consultar bases de datos internas con tu esquema específico, llamar a APIs REST o GraphQL propietarias, integrarse con sistemas de despliegue internos, leer de almacenes de datos personalizados o formatos de archivo propietarios, y realizar operaciones que requieren autenticación con sistemas de identidad internos.

Los servidores MCP también son la elección correcta cuando necesitas control detallado sobre el comportamiento de las herramientas. Con un servidor MCP, controlas exactamente qué datos se devuelven, cómo se manejan los errores, qué logging ocurre y qué límites de tasa se aplican. Un plugin te da lo que el autor decidió. Un servidor MCP te da exactamente lo que construyes.

La contrapartida es clara. Los servidores MCP requieren esfuerzo de desarrollo y mantenimiento. Si puedes resolver el problema con un plugin o un skill, haz eso en su lugar. Pero cuando necesitas integración real con sistemas reales, los servidores MCP son indispensables.

Cuándo Usar Skills

Recurre a los skills cuando el problema es sobre flujo de trabajo, no sobre datos. Los skills codifican cómo trabaja tu equipo en comandos que cualquiera puede ejecutar.

Usa skills para listas de verificación de revisión de código, plantillas de descripción de PR, generación de documentación, scaffolding de migraciones, listas de verificación de preparación de despliegue, formato de mensajes de commit y cualquier otro flujo de trabajo repetible que se beneficie de un prompt consistente.

Los skills son la elección correcta cuando la salida es generada enteramente por Claude a partir de instrucciones, no de datos externos. Si Claude necesita consultar una API para cumplir la solicitud, eso es un problema de servidor MCP. Si Claude necesita una herramienta preconstruida para procesar datos, eso es un problema de plugin. Si Claude solo necesita seguir un patrón específico que tu equipo ha acordado, eso es un skill.

El coste es casi nulo. Crear un skill toma minutos. Modificarlo toma segundos. No hay compilación, no hay despliegue, no hay configuración más allá de colocar un archivo en un directorio.

Combinando los Tres

El verdadero poder viene de usar los tres juntos. En una configuración típica de proyecto, los plugins manejan las integraciones comunes, los servidores MCP cubren los sistemas propietarios y los skills codifican los flujos de trabajo del equipo.

Así es como se ve una configuración típica en la práctica.

Los plugins manejan las herramientas del ecosistema. El plugin de GitHub para gestión de PR, un plugin de testing para ejecutar y analizar suites de tests, y un plugin de documentación para generar documentación de API a partir del código. Estas son cosas que todo equipo de desarrollo necesita, y las versiones del marketplace están mejor mantenidas que cualquier cosa que la mayoría de los equipos construirían por su cuenta.

Los servidores MCP manejan los sistemas personalizados. Un servidor MCP que consulta la base de datos de analíticas con un esquema específico y lógica de negocio. Otro que se conecta con un pipeline de despliegue interno. Un tercero que proporciona herramientas para gestionar el sistema de gestión de contenidos. Estas son capacidades que ningún plugin del marketplace podría proporcionar porque son únicas para la arquitectura de cada organización.

Los skills manejan las convenciones. Un skill /deploy-checklist recorre los pasos de verificación previos al despliegue. Un skill /review aplica criterios específicos de revisión de código. Un skill /migration genera migraciones de base de datos siguiendo convenciones de nomenclatura y patrones. Un skill /sprint-summary compila actualizaciones de progreso en el formato que espera el director de proyecto.

Las tres capas no compiten. Se complementan. Los plugins te dan amplitud. Los servidores MCP te dan profundidad. Los skills te dan consistencia.

Capa 3: Skills (Convenciones del Equipo)
  /review, /deploy, /migration, /sprint-summary

Capa 2: Servidores MCP (Integraciones Personalizadas)
  analytics-db, deploy-pipeline, content-api

Capa 1: Plugins (Herramientas del Ecosistema)
  @anthropic/github, @testing/jest, @docs/openapi

Un Diagrama de Decisión

Cuando necesites extender Claude Code, recorre estas preguntas en orden.

¿Tiene el marketplace lo que necesitas? Si es que sí, instala el plugin. Has terminado. Este es el camino más rápido y la menor carga de mantenimiento.

¿Necesita Claude acceder a datos externos o realizar efectos secundarios? Si es que sí, construye un servidor MCP. Necesitas código real que haga llamadas reales a APIs. Ninguna cantidad de ingeniería de prompts en un archivo de skill le dará a Claude la capacidad de consultar tu base de datos.

¿La necesidad es sobre flujos de trabajo, plantillas o convenciones del equipo? Si es que sí, crea un skill. Coloca un archivo markdown en .claude/skills/ y codifica el conocimiento de tu equipo en un comando repetible.

¿La necesidad es lo suficientemente compleja como para justificar empaquetarla para distribución? Si es que sí, y ya has construido servidores MCP y skills que funcionan bien juntos, considera empaquetarlos como un plugin y publicarlos en el marketplace. Esto permite que otros equipos se beneficien de tu trabajo.

En forma de texto, el flujo se ve así.

¿Necesitas extender Claude Code?
  |
  +--> ¿Existe solución preconstruida? --> Instalar Plugin
  |
  +--> ¿Necesitas datos/APIs externos? --> Construir Servidor MCP
  |
  +--> ¿Necesitas flujo de trabajo/plantilla? --> Crear Skill
  |
  +--> ¿Necesitas distribuir? --> Empaquetar como Plugin

Evitando Errores Comunes

Los equipos cometen los mismos errores repetidamente. Aquí están los que debes vigilar.

Construir un servidor MCP para una plantilla de prompt. Si tu "herramienta" solo devuelve una cadena fija o una plantilla, debería ser un skill. Los servidores MCP son para datos dinámicos, no para prompts estáticos.

Usar un skill cuando necesitas datos. Si tu skill dice "busca el último estado del despliegue", Claude intentará ayudar pero no puede realmente consultar tu sistema de despliegue a través de un archivo markdown. Necesitas un servidor MCP para eso.

Reinventar un plugin. Antes de construir un servidor MCP personalizado para GitHub, Jira, Slack o cualquier otro servicio popular, consulta el marketplace. Es casi seguro que alguien ha construido un plugin que lo maneja, y su versión probablemente sea más completa que lo que construirías en una semana.

Ignorar la gobernanza empresarial. Si estás en un plan empresarial, usa configuraciones gestionadas para controlar plugins y servidores MCP. Dejar que los desarrolladores individuales instalen herramientas arbitrarias anula el propósito de tener controles de seguridad.

Hacer los skills demasiado complejos. Un skill debería ser un prompt claro y enfocado. Si tu archivo de skill tiene 500 líneas con lógica condicional incrustada en el markdown, has superado el mecanismo de skills. Considera dividirlo en múltiples skills o mover la lógica a un servidor MCP.

La Lección

Los tres mecanismos de extensión en Claude Code no son opciones intercambiables. Son capas en una arquitectura de extensión, cada una resolviendo una clase distinta de problema.

Los plugins son para consumo. Instalas lo que otros han construido, configurado a través de ajustes, gobernado por política empresarial.

Los servidores MCP son para integración. Construyes puentes entre Claude Code y tus sistemas únicos, escribiendo código real en cualquier lenguaje que convenga a tu equipo.

Los skills son para convención. Codificas el conocimiento del equipo en archivos markdown, creando flujos de trabajo repetibles que no requieren capacidad de programación para usar o modificar.

El marco de decisión es directo. Consulta el marketplace primero. Si necesitas datos externos, construye un servidor MCP. Si necesitas una plantilla de flujo de trabajo, crea un skill. Si necesitas distribuir, empaqueta como plugin.

Los equipos que adoptan las tres capas reportan el mismo resultado. Menos tiempo construyendo desde cero, menos confusión sobre qué herramienta usar y más consistencia en cómo el equipo interactúa con Claude Code.

Conclusión

Entender la distinción entre plugins, servidores MCP y skills no es un ejercicio académico. Es un marco práctico que te ahorra construir lo incorrecto. Pasamos semanas aprendiendo esto por las malas, construyendo servidores MCP cuando necesitábamos skills y estirando skills cuando necesitábamos servidores MCP.

La taxonomía es simple una vez que la ves. Plugins para herramientas preconstruidas del ecosistema. Servidores MCP para integraciones personalizadas con tus sistemas. Skills para flujos de trabajo del equipo codificados en markdown. Tres capas, tres propósitos, cero solapamiento.

Empieza auditando tu configuración actual de Claude Code. Si estás usando solo uno de estos mecanismos, casi con certeza te estás perdiendo capacidades que los otros dos proporcionarían. Instala algunos plugins del marketplace. Construye un servidor MCP para tu API interna más usada. Crea skills para los cinco flujos de trabajo que tu equipo repite con más frecuencia.

El objetivo no es usar los tres por completitud. El objetivo es usar el mecanismo adecuado para cada problema, de modo que cada extensión que construyas sea simple, mantenible y efectiva.