Skills Personalizadas

Aprende a crear skills personalizadas para incorporar tu propio conocimiento especializado en ClaudeKit.

Requisito: Debes tener experiencia usando skills existentes antes de crear las tuyas.

¿Qué es una Skill Personalizada?

Una skill personalizada es un módulo de conocimiento especializado que puedes crear para:

• Incorporar best practices de tu organización
• Automatizar tareas repetitivas específicas
• Integrar herramientas y APIs propias
• Codificar conocimiento de dominio específico

📚 Conocimiento de Dominio

Incorpora documentación, guías, y estándares específicos de tu industria.

🔧 Automatización

Crea scripts que automatizan tareas repetitivas de tu workflow.

🔗 Integraciones

Conecta con APIs, databases, y herramientas específicas.

📋 Plantillas

Incluye templates de código, configuraciones, y estructuras.

Estructura de una Skill

.claude/skills/
└── my-custom-skill/
    ├── SKILL.md              # Metadatos y documentación
    ├── prompt.md             # System prompt (opcional)
    ├── scripts/              # Scripts ejecutables
    │   ├── analyze.py
    │   └── generate.sh
    ├── templates/            # Plantillas de código
    │   ├── component.tsx
    │   └── config.json
    └── assets/               # Recursos adicionales
        └── diagram.png

Archivos Obligatorios

SKILL.md - Metadatos de la skill:

# Mi Skill Personalizada

Descripción de qué hace esta skill y cuándo usarla.

## Cuándo Usar
- Situación 1
- Situación 2

## Comandos Disponibles
- `command1` - Descripción
- `command2` - Descripción

Archivos Opcionales

• prompt.md - System prompt personalizado
• scripts/ - Scripts de automatización
• templates/ - Plantillas de código
• assets/ - Imágenes, diagramas, etc.

Crear una Skill: Paso a Paso

Paso 1: Definir el Propósito

Antes de crear la skill, define claramente:

1. ¿Qué problema resuelve?
2. ¿Cuándo se debe usar?
3. ¿Qué valor aporta?

Ejemplo: React Component Generator

Propósito: Generar componentes React siguiendo estándares de mi equipo

Cuándo usar:

• Al crear nuevos componentes UI
• Para mantener consistencia en el código
• Para acelerar el desarrollo

Valor:

• Reduce tiempo de creación de componentes
• Mantiene estándares de código
• Incluye tests automáticamente

Ejemplo: API Schema Validator

Propósito: Validar schemas de APIs REST según estándares internos

Cuándo usar:

• Al diseñar nuevos endpoints
• Para revisar APIs existentes
• Para documentar contratos

Valor:

• Consistencia en diseño de APIs
• Documentación automática
• Detección temprana de errores

Paso 2: Crear la Estructura

# Crear directorio de la skill
mkdir -p .claude/skills/my-skill/{scripts,templates,assets}

# Crear archivo principal
touch .claude/skills/my-skill/SKILL.md

Paso 3: Escribir SKILL.md

# My Custom Skill

Skill personalizada para [propósito].

## Cuándo Usar

- [Situación 1]
- [Situación 2]
- [Situación 3]

## Comandos Disponibles

### `analyze`
Analiza [algo] y genera [resultado].

**Uso:**
```bash
claude ask "Analiza X usando my-skill"

generate

Genera [algo] basado en [entrada].

Uso:

claude cook "Genera Y usando my-skill"

Plantillas Incluidas

• template1.tsx - Descripción
• template2.json - Descripción

Scripts Disponibles

• scripts/analyze.py - Script de análisis
• scripts/generate.sh - Script de generación

Examples

Ejemplo 1: [Título]

claude cook "Crear componente Button usando my-skill"

Ejemplo 2: [Título]

claude ask "Validar schema API usando my-skill"

Referencias

• Documentación relacionada
• Best practices

### Paso 4: Crear Scripts (Opcional)

Los scripts permiten automatizar tareas:

**`scripts/analyze.py`**
```python
#!/usr/bin/env python3
"""
Script de análisis para my-skill.
"""

import sys
import json

def analyze(input_data):
    """Analiza los datos de entrada."""
    # Tu lógica aquí
    result = {
        "status": "success",
        "data": input_data
    }
    return result

if __name__ == "__main__":
    input_file = sys.argv[1]
    with open(input_file) as f:
        data = json.load(f)

    result = analyze(data)
    print(json.dumps(result, indent=2))

scripts/generate.sh

#!/bin/bash
# Script de generación para my-skill

TEMPLATE_DIR="$(dirname "$0")/../templates"
OUTPUT_FILE=${1:-"output.txt"}

# Copiar plantilla
cp "$TEMPLATE_DIR/template.txt" "$OUTPUT_FILE"

echo "Generated: $OUTPUT_FILE"

Paso 5: Crear Plantillas (Opcional)

templates/component.tsx

import React from 'react';

interface {{ComponentName}}Props {
  // Props aquí
}

export const {{ComponentName}}: React.FC<{{ComponentName}}Props> = ({
  // Destructuring
}) => {
  return (
    <div>
      {/* Component content */}
    </div>
  );
};

Paso 6: Probar la Skill

# Probar que la skill está disponible
claude ask "¿Qué skills están disponibles?"

# Usar la skill
claude cook "Crear X usando my-skill"

Ejemplo Completo: React Component Generator

Estructura

.claude/skills/react-component-generator/
├── SKILL.md
├── templates/
│   ├── functional-component.tsx
│   ├── hooks-component.tsx
│   └── test.spec.tsx
└── scripts/
    └── validate-component.sh

SKILL.md

# React Component Generator

Genera componentes React siguiendo los estándares del equipo.

## Cuándo Usar

- Crear nuevos componentes UI
- Mantener consistencia en el código
- Incluir tests automáticamente

## Comandos Disponibles

### `generate-component`
Genera un componente React con hooks y tests.

**Uso:**
```bash
claude cook "Crear componente Button usando react-component-generator"

validate-component

Valida que un componente cumpla los estándares.

Uso:

claude ask "Validar componente Button usando react-component-generator"

Plantillas

• functional-component.tsx - Componente funcional básico
• hooks-component.tsx - Componente con hooks personalizados
• test.spec.tsx - Template de test

Scripts

• validate-component.sh - Valida estructura del componente

Ejemplo

claude cook "Generar componente Button con variantes primary y secondary"

Resultado:

• Button.tsx - Componente con TypeScript
• Button.test.tsx - Tests con Vitest
• Button.stories.tsx - Stories de Storybook

## Best Practices

### 1. Naming Convention

Usa kebab-case para nombres de skills:

✅ my-custom-skill ✅ react-component-generator ✅ api-schema-validator

❌ MyCustomSkill ❌ react_component_generator ❌ apiSchemaValidator

### 2. Documentación Clara

Incluye en SKILL.md:
- ✅ Descripción clara del propósito
- ✅ Cuándo usar la skill
- ✅ Ejemplos de uso concretos
- ✅ Comandos disponibles con ejemplos
- ❌ Jerga o términos ambiguos

### 3. Scripts Robustos

```python
#!/usr/bin/env python3
"""
Script de análisis para my-skill.

Este script analiza archivos de entrada y genera reportes.
"""

import sys
import json
import logging
from pathlib import Path

# Configurar logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def validate_input(file_path):
    """Valida que el archivo de entrada exista."""
    path = Path(file_path)
    if not path.exists():
        logger.error(f"Archivo no encontrado: {file_path}")
        sys.exit(1)
    return path

def analyze(file_path):
    """Analiza el archivo y genera reporte."""
    try:
        with open(file_path) as f:
            data = json.load(f)

        # Tu lógica de análisis
        result = {
            "status": "success",
            "data": data
        }

        return result
    except Exception as e:
        logger.error(f"Error analizando archivo: {e}")
        return {"status": "error", "message": str(e)}

if __name__ == "__main__":
    if len(sys.argv) < 2:
        logger.error("Uso: python analyze.py <input_file>")
        sys.exit(1)

    input_file = validate_input(sys.argv[1])
    result = analyze(input_file)

    print(json.dumps(result, indent=2))

4. Plantillas Reutilizables

Usa placeholders para plantillas:

import React from 'react';

interface {{ComponentName}}Props {
  {{props}}
}

export const {{ComponentName}}: React.FC<{{ComponentName}}Props> = ({
  {{destructuredProps}}
}) => {
  return (
    <div>
      {{content}}
    </div>
  );
};

5. Testing de Skills

Crea tests para tus scripts:

tests/test_skill.py

import unittest
import json
from scripts.analyze import analyze

class TestMySkill(unittest.TestCase):
    def test_analyze_success(self):
        result = analyze({"test": "data"})
        self.assertEqual(result["status"], "success")

    def test_analyze_error(self):
        result = analyze(None)
        self.assertEqual(result["status"], "error")

if __name__ == "__main__":
    unittest.main()

Compartir tu Skill

Opción 1: Repositorio Interno

# Agregar a git
git add .claude/skills/my-skill/
git commit -m "Add my-skill"

# Push a repo interno
git push origin main

Opción 2: Publicar como Paquete

# Crear repo público
gh repo create my-claudekit-skill --public

# Documentar instalación
# En README.md:
# "Clona este repo en .claude/skills/my-skill/"

Opción 3: Contribuir a ClaudeKit

# Fork del repo
gh repo fork claudekit/aprende-claudekit

# Crear PR con tu skill
gh pr create --title "Add my-skill"

Troubleshooting

Skill no aparece

# Verificar estructura
ls -la .claude/skills/my-skill/SKILL.md

# Recargar ClaudeKit
claude reload

Scripts no ejecutan

# Dar permisos de ejecución
chmod +x .claude/skills/my-skill/scripts/*.sh

# Verificar shebang
head -n1 .claude/skills/my-skill/scripts/*.sh

Plantillas no se encuentran

# Verificar ruta
ls -la .claude/skills/my-skill/templates/

# Usar ruta absoluta en scripts
TEMPLATE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../templates" && pwd)"

Siguiente: Agentes Personalizados

Aprende a crear tus propios agentes especializados.

---

¿Preguntas? Usa claude ask "tu pregunta sobre skills" en cualquier momento.