# Claude Skills: cómo instalarlas, usarlas y crear tu primera skill

> Aprende a instalar y usar skills en Claude Code, crear un archivo SKILL.md y probarlo con un ejemplo de documentación técnica para tu proyecto.

Canonical: https://www.gilbertsahumada.com/blog/como-utilizar-claude-skills-para/
Last updated: 2026-10-22

IA · AI Agents · Skills

![Ilustración de la guía para instalar, usar y crear skills en Claude](https://www.gilbertsahumada.com/images/blog/como-utilizar-claude-skills-para/cover.png)

He combinado en este artículo todo lo que he aprendido sobre Claude Skills mientras construyo mis proyectos, principalmente [micompa.cl](https://micompa.cl/) y [@movehat](https://x.com/@movehat).

Si ya programas y repites instrucciones para documentar código, revisar cambios o preparar un README, puedes convertir ese proceso en una skill. Aquí veremos cómo instalar una, invocarla y crear un archivo `SKILL.md` para documentar un archivo de tu proyecto.

La parte práctica se centra en **Claude Code**. Después revisaremos cómo definir las instrucciones, probar el resultado y corregir los casos en que la skill no hace lo que esperabas. Una skill ayuda a repetir un proceso; no garantiza que el código o la documentación sean correctos sin revisión.

## Por dónde empezar

* [Crear y probar una skill mínima](https://www.gilbertsahumada.com/blog/como-utilizar-claude-skills-para/#tu-primera-skill-en-claude-code).
* [Instalar una skill existente](https://www.gilbertsahumada.com/blog/como-utilizar-claude-skills-para/#parte-1-instala-tu-primera-skill-en-5-minutos).
* [Entender cómo se invoca](https://www.gilbertsahumada.com/blog/como-utilizar-claude-skills-para/#c%C3%B3mo-utilizar-una-skill).
* [Desarrollar el ejemplo completo de documentación](https://www.gilbertsahumada.com/blog/como-utilizar-claude-skills-para/#escribe-el-archivo-skillmd).
* [Resolver problemas de carga o activación](https://www.gilbertsahumada.com/blog/como-utilizar-claude-skills-para/#si-la-skill-no-aparece-o-no-se-activa).

## Tu primera skill en Claude Code

Necesitas Claude Code instalado y un proyecto con un archivo de código que puedas revisar. Para empezar, crea la carpeta `.claude/skills/document-file/` dentro del proyecto y añade un archivo llamado `SKILL.md` con este contenido:

```markdown
---
name: document-file
description: Explain a source file and suggest technical documentation. Use when asked to document a file, explain its functions, or prepare a README for that file.
---

# Document a source file

1. Ask which file to document if no path was provided.
2. Read the file before describing its behavior.
3. Explain its purpose, exported functions, inputs, outputs, and errors.
4. Include one usage example supported by the code.
5. Mark anything that cannot be determined from the file as uncertain.
6. Return Markdown documentation for review. Do not modify files.
```

En Claude Code, escribe `/document-file` seguido de la ruta de un archivo real de tu proyecto. Por ejemplo, `/document-file src/user.service.ts` si ese archivo existe; si no, usa otro que conozcas.

Revisa que la documentación describa funciones que realmente existen, que el ejemplo tenga sentido y que no invente comportamientos. Este primer ejemplo solo propone documentación: no modifica archivos. Más abajo ampliaremos las instrucciones y los criterios para evaluar el resultado.

La [documentación oficial de skills en Claude Code](https://code.claude.com/docs/en/skills) explica las ubicaciones, la invocación y las opciones disponibles. Para instalar una skill de terceros, revisa primero su `SKILL.md` y los scripts que incluya; no ejecutes código que no entiendas ni le entregues secretos para probarla.

## <strong>Qué son realmente los Claude Skills, o Skills simplemente</strong>

Y por qué la mayoría los está utilizando mal.

Un Skill es un archivo markdown con instrucciones que vive en tu máquina y/o proyecto, y le dice a Claude exactamente cómo realizar una tarea específica. Siempre y cuando lo necesite, sin que tengas que repetirlo una y otra vez.

Cualquiera lee esto y dice: “ah, entonces es como un prompt guardado”.

No.

Un prompt guardado es un punto inicial para una conversación.

Un Skill es un empleado entrenado para ejecutar tareas específicas.

Un prompt guardado dice: “así se empieza”.

Un Skill dice: “así se hace exactamente este trabajo de principio a fin, así se ve un buen resultado, así se ve uno malo, esto debes hacer cuando algo salga mal, estas son las herramientas que necesitas y este es el formato en que tienes que entregar los resultados”.

La diferencia en la calidad del output es enorme. Esto pasa por la naturaleza de los LLMs, algo que explico en el primer video de [mi mini curso de LLM fundamentals en YouTube](https://www.youtube.com/playlist?list=PL2uIxLJ7G8e3gEb7RScczaEDqs7-CoAdn). Si estudias a alto nivel cómo se entrena y fine-tunea un modelo, se aplican principios parecidos: el contexto, los ejemplos, el formato esperado y las instrucciones importan muchísimo.

Cuando le das a Claude un prompt único, obtienes calidad de prompt único. A veces excelente, a veces mediocre. Diferente cada vez, porque cada vez escribes las cosas ligeramente distintas, omites detalles o Claude interpreta algo de otra manera.

Cuando activas un Skill bien construido, la tarea ya tiene un proceso definido: qué revisar, en qué orden hacerlo, qué criterios seguir y cómo entregar el resultado.

No elimina toda la variación, porque seguimos trabajando con LLMs, pero reduce muchísimo la improvisación <del>alucinación</del>.

Esa es la diferencia entre tener un practicante al que le explicas todo cada vez, y tener un profesional entrenado en lo que hace.

## <strong>Por qué las Skills son una de las funciones más subutilizadas de la IA ahora mismo</strong>

Hay cada vez más Skills hechas por la comunidad. Anthropic ha publicado Skills oficiales para PDFs, documentos, presentaciones y hojas de cálculo. Yo publiqué una para crear diagramas con estilo Excalidraw. Hay otras para Word, diseño, desarrollo, análisis, documentación, UI, datos, lo que se te ocurra.

Y la mayoría de las personas ni siquiera ha instalado una. Ni siquiera <strong>UNA</strong>.

La razón es simple: nadie ha explicado bien cómo usarlas.

La mayoría de las guías te muestra cómo instalar un Skill y eso es todo. Eso es como mostrarle a alguien cómo comprar una cocina, pero nunca enseñarle cómo cocinar.

Este artículo cubre todo el ciclo de vida: cómo encontrar los Skills correctos, cómo instalarlos, cómo construir Skills personalizadas desde cero, cómo probarlas y refinarlas, cómo desplegarlas en flujos reales de trabajo y cómo construir una biblioteca completa de Skills que automatice parte importante de tu operación.

## <strong>Parte 1: Instala tu primera Skill en 5 minutos</strong>

¿Dónde viven estas Skills?

Las Skills son simplemente carpetas en tu computador. Dentro de cada carpeta debe haber un archivo llamado <strong>SKILL.md</strong>.

Ese archivo contiene las instrucciones que le dicen a Claude cómo hacer la chamba.

Para Claude Code, viven en el directorio de tu proyecto en:

<strong>.claude/skills/</strong>

Y globalmente están en:

<strong>\~/.claude/skills/</strong>

Claude.ai y Cowork también tienen skills, pero sus opciones de carga y sincronización pueden diferir. Para seguir este ejemplo, usa la carpeta de Claude Code del proyecto; no necesitas configurar otra aplicación.

No hay una instalación compleja, ni dependencias raras ni archivos de configuración. En su forma más simple, son archivos markdown dentro de una carpeta.

## <strong>Qué hacer en la Fase 1</strong>

Anda a [skillsmp.com](https://skillsmp.com/), [skills.sh](https://skills.sh/), [agentskills.io](https://agentskills.io/) o [github.com/anthropics/skills](https://github.com/anthropics/skills) y encuentra alguna Skill que pueda ser relevante para tu trabajo.

En el mismo repositorio normalmente vienen las instrucciones de instalación. O simplemente copia y pega la URL del Skill y pídele a Claude que lo instale.

Por ejemplo:

<em>Instala esta Skill en mi proyecto y déjala disponible en .claude/skills/</em>

Felicidades, has instalado tu primera Skill.

Pero ahora viene la pregunta importante.

¿Cómo cresta la utilizo?

## <strong>Cómo utilizar una Skill</strong>

Primero veamos la estructura básica de una Skill. Estas deben tener un nombre y una descripción. Aquí tenemos un ejemplo de una Skill de shadcn.

```
---
name: shadcn
description: Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI. Provides project context, component docs, and usage examples. Applies when working with shadcn/ui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for "shadcn init", "create an app with --preset", or "switch to --preset".
---
```

Tenemos tres maneras de “invocar una Skill”, de manera directa o indirecta.

La primera es indirecta. Dado un prompt, Claude lo matchea con la descripción de la Skill e infiere que debe utilizarla.

Por ejemplo:

<em>Agrega un botón usando shadcn/ui y deja el componente listo para producción.</em>

La segunda es más explícita. Puedes escribirle en el prompt el nombre exacto de la Skill, o algo muy cercano al nombre y la descripción.

Por ejemplo:

<em>Usa la Skill de shadcn para agregar este componente.</em>

La tercera es usando slash command.

Por ejemplo:

<em>/shadcn</em>

<strong>Slash seguido del nombre de tu Skill.</strong>

Esta parte es importante porque la descripción no es decoración. La descripción es lo que Claude usa para decidir si debe activar la Skill o no. Si tu descripción es vaga, la Skill se va a activar mal. Si tu descripción es clara, la Skill se vuelve mucho más confiable.

## Si la skill no aparece o no se activa

* **No aparece al escribir `/`:** comprueba que guardaste el archivo como `.claude/skills/document-file/SKILL.md` y que Claude Code está abierto en ese proyecto. El nombre del archivo debe ser `SKILL.md`, no `skill.md` ni `SKILL.md.txt`.
* **El archivo no se interpreta bien:** revisa que el frontmatter YAML tenga los delimitadores `---`, un `name` válido y una `description` que explique la tarea. Usa el ejemplo mínimo para aislar el problema.
* **No se activa con una petición normal:** invócala explícitamente con `/document-file`. Si así funciona, revisa que la descripción incluya el tipo de petición que estás haciendo.
* **Se activa para otras tareas:** acota la descripción y añade casos en los que no debería utilizarse. Prueba tanto una petición que deba activarla como otra que no.
* **Se activa, pero inventa documentación:** compara la respuesta con el archivo original, registra el error y ajusta las instrucciones. Activarse no equivale a producir un resultado correcto.

## <strong>Parte 2: Creando tu primera Skill desde cero</strong>

Antes de crearla, debemos responder estas cuatro preguntas.

## <strong>1. ¿Qué debería permitirle hacer esta habilidad a Claude? ¿Qué hace?</strong>

Debes ser lo más específico posible.

No escribas:

Ayudar con creación de documentación.

Eso es demasiado genérico.

Escribe algo como:

> <em>Crear documentación técnica estructurada en Markdown para proyectos de software.\
> \
> Cada carpeta dentro del proyecto representa un módulo de documentación. Cada archivo dentro de esa carpeta contiene funciones, clases o lógica relacionada con ese módulo.\
> \
> La Skill debe analizar cada archivo, identificar sus funciones relevantes y documentarlas siguiendo una estructura definida.\
> \
> Si una función no contiene documentación comentada, la Skill debe generar una documentación sugerida, infiriendo su propósito desde el nombre de la función, sus parámetros, sus tipos, su retorno y su lógica interna.\
> \
> Si algo no puede inferirse con certeza desde el código, debe indicarlo explícitamente y no inventarlo.</em>

Eso ya es otra cosa.

Ahí no estás diciendo “ayúdame a documentar”. Estás definiendo el trabajo, el contexto, los límites y el criterio.

## <strong>2. ¿Cuándo debería activarse o gatillarse esta Skill?</strong>

Aquí tienes que pensar qué escribirías tú realmente para gatillar la ejecución de esta Skill.

Por ejemplo:

> <em>Documéntame este archivo.\
> Actualiza la documentación de este módulo.\
> Genérame la documentación del proyecto.\
> Crea un README técnico para esta carpeta.\
> Documenta todas las funciones de este archivo.\
> Agrega comentarios JSDoc a las funciones sin documentación.\
> Revisa si este módulo está bien documentado.</em>

Estas frases deberían aparecer, o estar muy reflejadas, en la descripción del Skill.

Recuerda lo que vimos más arriba: Claude primero ve el nombre y la descripción. Si la descripción no explica bien cuándo se debe activar, no puedes esperar que Claude adivine perfecto.

## <strong>3. ¿Cuál es el formato de salida esperado?</strong>

Esto tiene que ser lo más claro y menos abstracto posible.

No basta con decirle:

Documenta bien este código.

Eso no significa nada.

Tienes que mostrarle cómo se ve un buen resultado.

Un ejemplo real vale más que cincuenta líneas de instrucciones vagas, especialmente en Skills más deterministas, como documentación, análisis, reportes, resúmenes estructurados o generación de archivos.

Para el caso de una Skill de documentación técnica, el output esperado podría ser algo así:

```
# Nombre del módulo

Breve descripción del propósito del módulo, inferida a partir del nombre de la carpeta, los archivos que contiene y la lógica general del código.

## Archivos incluidos

Lista de archivos encontrados dentro del módulo, con una descripción breve de la responsabilidad de cada archivo.

Ejemplo:

1. `user.service.ts`: contiene la lógica de negocio relacionada con usuarios.
2. `user.controller.ts`: expone endpoints HTTP para gestionar usuarios.
3. `user.repository.ts`: maneja el acceso a datos del módulo de usuarios.

---

## Archivo: `nombre-del-archivo.ts`

Descripción general del archivo y de su rol dentro del módulo.

### Función: `nombreDeLaFuncion`

Descripción clara de lo que hace la función.

#### Propósito

Explicar en uno o dos párrafos para qué existe esta función y qué problema resuelve dentro del módulo.

#### Parámetros

Documentar cada parámetro en formato tabla:

| Parámetro | Tipo | Requerido | Descripción |
|---|---|---|---|
| `userId` | `string` | Sí | Identificador único del usuario. |
| `options` | `CreateOptions` | No | Configuración adicional para ejecutar la operación. |

Si el tipo no está explícito, inferirlo desde el uso interno de la función, pero indicar que fue inferido.

#### Retorno

Explicar qué devuelve la función.

| Tipo de retorno | Descripción |
|---|---|
| `Promise<User>` | Retorna el usuario creado o actualizado. |

Si la función no retorna nada explícitamente, indicar:

> Esta función no retorna un valor explícito.

#### Flujo interno

Describir paso a paso la lógica principal de la función.

Ejemplo:

1. Valida los parámetros recibidos.
2. Consulta la información necesaria desde la base de datos.
3. Aplica las reglas de negocio correspondientes.
4. Retorna el resultado procesado.

#### Errores o casos especiales

Documentar errores, validaciones, condiciones especiales o comportamientos importantes.

Ejemplo:

1. Lanza un error si el usuario no existe.
2. Ignora registros duplicados.
3. Retorna `null` si no encuentra resultados.
4. Usa valores por defecto cuando ciertos parámetros no son enviados.

#### Ejemplo de uso

Cuando sea posible, incluir un ejemplo breve de uso.

ts
const user = await createUser({
  email: "user@example.com",
  name: "Gilberts"
});
Comentario sugerido para el código
Si la función no tiene documentación comentada, generar un bloque de comentario listo para pegar sobre la función.
/**
 * Crea un nuevo usuario en el sistema.
 *
 * Valida los datos de entrada, verifica si el usuario ya existe
 * y persiste la información en la base de datos.
 *
 * @param input - Datos necesarios para crear el usuario.
 * @returns El usuario creado.
 */
```

Y además puedes agregar reglas de calidad del output:

```
## Reglas de calidad del output

1. No inventar comportamiento que no pueda inferirse desde el código.
2. Si algo no puede inferirse con seguridad, indicarlo explícitamente con: `No se puede inferir con certeza desde el código`.
3. Mantener la documentación técnica, clara y útil para otros desarrolladores.
4. Usar Markdown válido.
5. Usar nombres reales de carpetas, archivos, clases, funciones, parámetros y tipos.
6. No omitir funciones públicas.
7. No omitir funciones privadas si contienen lógica relevante.
8. No documentar imports, constantes triviales o boilerplate salvo que afecten la lógica del módulo.
9. Priorizar claridad sobre extensión.
10. Evitar frases genéricas como “esta función maneja la lógica”.
11. Cada función debe explicar qué hace, qué recibe, qué devuelve y qué efectos secundarios tiene.
```

Este es el tipo de ejemplo que hace que una Skill mejore muchísimo. Le estás diciendo a Claude exactamente cómo se ve un output correcto.

> <em>Nota Importante: no tiene que ser así de extenso la primera vez y tampoco recomiendo hacerlo en español, esto es solo para fines educativos, más abajo de explica el proceso de refinamiento y mejora, no se espera tener un skill así de extenso a la primera.</em>

## <strong>4. ¿Deberíamos configurar casos de prueba para verificar que la Skill funcione?</strong>

Sí.

Una Skill no debería tratarse como un prompt bonito que escribiste una vez y quedó listo para siempre.

Debería tratarse más parecido a una pieza de software o a un workflow que puedes probar, evaluar y mejorar.

No necesitas empezar con algo complejo. Pero al menos deberías pensar:

¿Con qué input debería funcionar bien?

¿Con qué input podría fallar?

¿Qué resultado consideraría aceptable?

¿Qué resultado consideraría incorrecto?

¿Qué errores quiero evitar?

En el caso de la Skill de documentación, por ejemplo, podríamos probar:

* <strong>Caso simple: </strong>Documentar un archivo con funciones bien nombradas, parámetros tipados y retornos claros.

* <strong>Caso incompleto: </strong>Documentar un archivo donde algunas funciones no tienen tipos explícitos o no retornan nada.

* <strong>Caso grande: </strong>Documentar una carpeta completa con services, controllers, repositories, helpers y funciones privadas.

* <strong>Caso de activación incorrecta: </strong>Pedirle que escriba un post de LinkedIn sobre el proyecto y verificar que NO use la Skill de documentación técnica.

Esto te obliga a pensar el Skill como algo que tiene comportamiento esperado, no solo como una instrucción larga.

## <strong>Escribe el archivo SKILL.md</strong>

El archivo <strong>SKILL.md </strong>tiene dos secciones principales.

La primera es el YAML frontmatter al inicio, entre guiones, como el ejemplo que mostré para shadcn más arriba.

Ahí ponemos el nombre en kebab-case y la descripción. Esa descripción debería ser precisa, concisa y descriptiva. Idealmente debe listar las frases gatillo que mencionamos antes y también aclarar cuándo NO debe activarse.

Por ejemplo:

```
---
name: project-documentation
description: Create structured technical documentation in Markdown for software projects. Use this skill when the user asks to document a file, module, folder, function, class, service, controller, repository, SDK, CLI command, or full project. Trigger for requests like "document this file", "generate docs for this module", "create a README", "add JSDoc comments", "document all functions", or "update the technical documentation". Do not use this skill for marketing copy, blog posts, user-facing tutorials, or non-technical summaries.
---
```

La segunda parte son las instrucciones debajo del frontmatter.

Aquí va el paso a paso de manera secuencial y clara. No escribas inspiración. Escribe el proceso de trabajo.

Piensa en cómo resolverías tú la tarea y conviértelo en instrucciones. No necesitas escribir cada pensamiento interno, sino los pasos observables: qué revisar, qué decidir, qué evitar y cómo entregar el resultado.

Por ejemplo:

```
# Project Documentation Skill

## Goal

Create clear, structured, developer-friendly documentation for software projects using Markdown.

## Workflow

1. Inspect the project structure.
2. Identify folders that represent modules.
3. Identify relevant files inside each module.
4. For each file, identify exported functions, public functions, classes, methods and relevant private functions.
5. For each function, infer its purpose from name, parameters, types, return value and internal logic.
6. Document each function using the required output format.
7. Generate suggested comments for undocumented functions.
8. Mark uncertain behavior explicitly.
9. Produce final Markdown ready to paste into a README or docs file.

## Rules

1. Do not invent behavior that cannot be inferred from the code.
2. Use real names of folders, files, functions, parameters and types.
3. Do not omit public functions.
4. Include private functions only when they contain relevant business logic.
5. Ignore trivial imports, constants and boilerplate unless they affect behavior.
6. Prioritize clarity over length.
7. Avoid generic phrases like "handles logic" or "processes data".
8. Always explain what the function receives, what it returns and what side effects it has.
```

Incluye ejemplos de input y output.

Incluye edge cases si necesitas y cómo deberíamos manejarlos.

Utiliza diagramas ASCII si te ayudan, como diagramas de flujo, jerarquías o incluso secuencias. Aunque para secuencias muchas veces prefiero dejarlo en pasos claros.

Ten en cuenta lo siguiente:

* Metadata, aproximadamente 100 tokens: el nombre y la descripción son cargados al iniciar el Skill.

* Instrucciones, menos de 5000 tokens recomendados: el cuerpo completo del SKILL.md es cargado cuando el Skill es activado.

* Resources, cuando se necesitan: puedes adjuntar referencias a archivos como scripts/, references/ o assets/, que son cargados solo cuando son requeridos.

## <strong>Qué hacer en la Fase 2</strong>

Escoge alguna tarea que hagas de manera repetitiva y responde las cuatro preguntas.

* Escribe el YAML frontmatter con descripciones explícitas de activación.

* Escribe las instrucciones como un flujo paso a paso con ejemplos concretos.

* Guarda el archivo SKILL.md en el directorio correcto de Skills.

* Ejecuta la Skill en una tarea real y guarda el output para revisarlo.

## <strong>Qué hacer en la Fase 3</strong>

Aquí hacemos lo que más nos gusta: el método científico de ensayo y error.

Ejecutamos, evaluamos y refinamos.

En otra publicación podemos crear Skills que se mejoren a sí mismas, o Skills que generen otras Skills, porque eso también se pone interesante. Pero por ahora mantengámoslo simple.

A la hora de testear nuestro Skill, es muy similar a cuando testeamos código.

## <strong>1. Happy Path o Golden Path</strong>

Este es el caso en que nada se rompe.

Prueba un input normal y directo que represente el 80% de tus casos de uso.

<strong>Por ejemplo:</strong>

<em>Documenta este archivo user.service.ts</em>

Aquí esperas que la Skill haga lo obvio: identificar funciones, documentar parámetros, retornos, flujo interno, errores y generar comentarios sugeridos si faltan.

## <strong>2. Caso límite o Edge Case</strong>

Prueba inputs raros, incompletos o ambiguos que pongan a prueba los límites de la Skill.

<strong>Por ejemplo:</strong>

<em>Documenta este módulo, pero algunas funciones no tienen tipos explícitos y otras no retornan nada.</em>

Aquí quieres ver si la Skill sabe manejar incertidumbre. No quieres que invente comportamiento. Quieres que diga claramente cuando algo no se puede inferir desde el código.

## <strong>3. Stress Testing</strong>

Esta es la versión más grande y desordenada de la tarea.

<strong>Por ejemplo:</strong>

<em>Documenta toda esta carpeta con controllers, services, repositories, DTOs, helpers y funciones privadas.</em>

Esto debería mostrarte si tu Skill escala o si solo funciona con inputs simples.

También puedes hacer pruebas de activación. Por ejemplo, si tu Skill es de documentación técnica, debería activarse con:

* <em>Documéntame este archivo.</em>

* <em>Actualiza la documentación de este módulo.</em>

* <em>Genera un README técnico para esta carpeta.</em>

Pero no debería activarse con:

* <em>Escribe un post para LinkedIn sobre este proyecto.</em>

* <em>Crea un pitch para inversionistas.</em>

* <em>Haz una landing page para este producto.</em>

Si tu Skill se activa cuando no corresponde, <strong>la descripción probablemente es demasiado amplia</strong>.

Si no se activa cuando debería, la descripción probablemente <strong>no incluye suficientes frases gatillo</strong> o <strong>no explica bien el caso de uso</strong>.

Si tu Skill pasa estos escenarios con un output que estarías cómodo mostrando a un cliente, está lista para producción.

Si falla en algún escenario, esa falla te dice exactamente qué instrucción debes agregar.

## <strong>El ciclo de mejora</strong>

Lo que no se mide no se puede mejorar.

Y aunque estas mediciones muchas veces no son cuantitativas, sí tenemos una idea clara de qué funciona y qué no a medida que usamos la Skill.

Así que repite el proceso.

* Cada vez que la utilices y no produzca el resultado esperado, refínala.

* Si omitió funciones privadas relevantes, agrega una regla.

* Si inventó comportamiento, agrega una regla.

* Si el formato salió inconsistente, agrega un ejemplo mejor.

* Si se activó cuando no debía, ajusta la descripción.

* Si no se activó cuando debía, agrega mejores frases gatillo.

Con el tiempo, irá produciendo mejores resultados.

Si la tarea se complejiza demasiado y estamos sobre las líneas o tokens recomendados, ahí puedes separar lógica en scripts/, documentación larga en references/, o templates en assets/.

Eso lo podemos ver en otro post, o puedes probarlo por ti mismo.

## <strong>Qué hacer en la Fase 4</strong>

Una Skill es una herramienta.

Diez Skills bien diseñadas empiezan a parecer una pequeña fuerza laboral.

La idea no es crear una Skill aislada y olvidarte. La idea es empezar a mirar tus tareas repetitivas y preguntarte cuáles podrían convertirse en workflows reutilizables.

Por ejemplo, puedes crear Skills para:

* Documentación técnica.

* Code review.

* Creación de contenido.

* Investigación.

* Preparación de reuniones.

* Redacción de emails.

* Generación de reportes.

* Análisis competitivo.

* Creación de diagramas.

* Testing de features.

* Escritura de PRDs.

* Revisión de arquitectura.

* Refactor de código.

* Preparación de demos.

* Publicación de contenido.

El patrón es siempre el mismo.

* Identifica una tarea repetitiva.

* Define cómo debería ejecutarse.

* Define cuándo debería activarse.

* Define el output esperado.

* Prueba con casos reales.

* Refina.

* Repite.

Con una Skill automatizas una tarea.

Con una biblioteca de Skills empiezas a convertir tu forma de trabajar en infraestructura.

Y aquí es donde se pone interesante, porque ya no estás solo usando Claude para responder cosas. Estás empezando a construir una capa de procesos sobre Claude.

Una especie de sistema operativo personal para trabajar con agentes.

## <strong>Qué haría yo para construir una biblioteca de Skills</strong>

Partiría simple.

No intentaría crear veinte Skills desde el día uno.

Primero listaría las tareas que repito todas las semanas.

<strong>Por ejemplo:</strong>

* ¿Qué cosas me pide mi trabajo o proyecto una y otra vez?

* ¿Qué tareas siempre explico igual?

* ¿Qué outputs siempre quiero con el mismo formato?

* ¿Qué cosas me da lata volver a corregir cada vez?

* ¿Qué workflows ya tengo claros en mi cabeza, pero todavía no están escritos?

De esa lista, escogería una sola tarea.

<em>La más repetida.</em>

<em>La más clara.</em>

<em>La que tenga un output fácil de evaluar.</em>

Y construiría mi primer Skill para eso.

Luego usaría esa Skill durante una semana real de trabajo. No en ejemplos inventados. En trabajo real.

Cada vez que falle, actualizo el SKILL.md.

Después de una semana, probablemente ya tienes una Skill mucho mejor que la versión inicial.

Después de un mes, puede ser parte de tu flujo normal.

Y después de varios meses, puedes tener una biblioteca de Skills que capture parte importante de tu forma de trabajar.

## <strong>Para finalizar</strong>

La definición de Skill directamente desde la documentación es:

> <em>Agent Skills are a lightweight, open format for extending AI agent capabilities with specialized knowledge and workflows.</em>

Me gusta esa definición porque es precisa.

Pero si tuviera que explicarlo en simple, diría esto:

> <em>Un Skill es una forma de empaquetar un workflow para que un agente lo pueda ejecutar de manera consistente.</em>

* No es un prompt guardado.

* No es solo contexto.

* No es solo documentación.

* Es un proceso reutilizable.

La mayoría va a seguir escribiendo los mismos prompts todos los días:

* “Documenta esto”.

* “Revisa este código”.

* “Crea un README”.

* “Hazme un resumen”.

* “Escribe este post”.

Y cada vez van a obtener resultados distintos.

Los que entiendan Skills van a hacer algo distinto: convertir tareas repetitivas en workflows reutilizables.

Para mí, esa es la forma correcta de ver Claude Skills.

Pequeños procesos empaquetados que viven en tu proyecto, entienden tu estándar y ejecutan tareas específicas cada vez que los necesitas.

Y cuando juntas suficientes, tu forma de trabajar cambia del cielo a la tierra.

Nos vemos :)

## Seguir aprendiendo

Puedes continuar con [Los únicos 3 Skills que necesitas](https://www.gilbertsahumada.com/blog/los-unicos-3-skills-que-necesitas/) y ver cómo estas instrucciones encajan en la memoria de un equipo en [Qué es un Company Brain y cómo puedes construirlo](https://www.gilbertsahumada.com/blog/que-es-un-company-brain-y-como-puedes/).

Si quieres profundizar en cómo usar IA en tu trabajo como desarrollador y construir aplicaciones con ella, en la [academia](https://academia.gilbertsahumada.com/) puedes consultar la formación en español que estoy preparando.

[Publicado originalmente en](https://gilbertsahumada.substack.com/p/como-utilizar-claude-skills-para)

## Related

* [La IA no está subsidiada…](https://www.gilbertsahumada.com/blog/la-ia-no-esta-subsidiada/)
* [¿De verdad me gustaba programar?](https://www.gilbertsahumada.com/blog/la-ia-el-codigo-y-quienes-somos-ahora/)
