Blog

Cómo usar Claude Code Skills para CI/CD

Ashley Innocent

Ashley Innocent

22 January 2026

Cómo usar Claude Code Skills para CI/CD

Si ha estado buscando una forma de inyectar inteligencia en su pipeline de CI/CD sin tener que lidiar con complejos scripts de automatización, las Habilidades de Código de Claude (Claude Code Skills) podrían ser exactamente lo que necesita. Estos flujos de trabajo personalizados, impulsados por IA, automatizan todo, desde las comprobaciones de seguridad previas a la confirmación hasta la validación de la implementación. Los define utilizando instrucciones en lenguaje natural en lugar de scripts de shell frágiles.

Lo que hace que las Habilidades de Código de Claude sean potentes para CI/CD:

💡
¿Construyendo pipelines centrados en API? Combine las Habilidades de Código de Claude con Apidog para una automatización de API de extremo a extremo. Apidog ofrece pruebas visuales de API, generación automática de pruebas a partir de especificaciones OpenAPI y herramientas CLI listas para CI/CD que se integran perfectamente con sus habilidades. Pruebe Apidog gratis para potenciar sus flujos de trabajo de API.
botón

En esta guía, exploraremos qué son las Habilidades de Código de Claude, cómo construir flujos de trabajo de CI/CD personalizados y ejemplos del mundo real que puede implementar hoy mismo.

Comprendiendo las Habilidades de Código de Claude

¿Qué Son las Habilidades?

Las Habilidades de Código de Claude son flujos de trabajo de IA personalizados y reutilizables que extienden las capacidades de Claude Code. Piénselos como scripts inteligentes que pueden:

Gráfico mostrando cómo Claude Code Skills se integran con herramientas de desarrollo como terminal, IDE, Git, API, archivos y la web, con un flujo de trabajo que incluye razonamiento, herramientas de ejecución, planificación de habilidades y memoria de conversación.

A diferencia de los scripts tradicionales que siguen una lógica rígida, las habilidades aprovechan las capacidades de razonamiento de Claude para manejar casos extremos, sugerir mejoras y adaptarse a condiciones cambiantes.

Cómo Funcionan las Habilidades

Las habilidades operan a través de varios mecanismos clave:

1. Comandos Invocables por el Usuario

# Run a skill with a slash command
/deploy-validation --env production
/security-review
/ci-pipeline-monitor --branch main

2. Herramientas Permitidas

Las habilidades especifican qué herramientas pueden usar:

3. Ganchos de Ciclo de Vida

Las habilidades pueden activar acciones en puntos específicos:

4. Archivos de Planificación

Las habilidades pueden mantener el estado utilizando archivos markdown para seguir el progreso, almacenar hallazgos y habilitar flujos de trabajo reanudables.

Por Qué las Habilidades Sobresalen en CI/CD

Los scripts tradicionales de CI/CD se rompen fácilmente cuando se enfrentan a condiciones inesperadas. Las habilidades aportan inteligencia a la automatización:

Anatomía de la Habilidad: Componentes y Estructura

Estructura de Directorios

Las habilidades residen en .claude/skills/ con esta disposición:

.claude/
├── skills/
│   ├── deploy-validation/
│   │   ├── SKILL.md              # Manifiesto e instrucciones de la habilidad
│   │   ├── planning.md           # Seguimiento de estado (opcional)
│   │   └── scripts/              # Scripts auxiliares (opcional)
│   ├── security-review/
│   │   └── SKILL.md
│   └── ci-monitor/
│       └── SKILL.md
└── skills.md                     # Índice de todas las habilidades

El Manifiesto SKILL.md

Cada habilidad comienza con un encabezado YAML seguido de instrucciones markdown:

---
name: deploy-validation
version: "1.0.0"
description: Validates deployment readiness with comprehensive checks
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Edit
  - Grep
  - Glob
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Deploy Validator] Starting pre-deployment checks...'"
  Stop:
    - matcher: command
      command: "echo '[Deploy Validator] Checks complete. Review output above.'"
---

# Habilidad de Validación de Implementación

Validación completa previa a la implementación para lanzamientos de producción.

## Uso

```bash
/deploy-validation --env production
/deploy-validation --env staging --dry-run
/deploy-validation --skip-tests  # Use cautiously
```

Qué Hace Esta Habilidad

Verificación del Entorno

Comprobaciones de Calidad de Código

Pruebas

Validación de Construcción

Escaneo de Seguridad

Comprobación de Documentación

Informe de Implementación

Instrucciones para Claude

Al ser invocada, siga este proceso:

  1. Analizar los argumentos de la línea de comandos para determinar el entorno y las opciones
  2. Comprobar la rama git actual y el SHA de la confirmación
  3. Ejecutar cada paso de validación en secuencia
  4. Por cada fallo, registrar el problema y continuar (recopilar todos los errores)
  5. Después de todas las comprobaciones, generar un informe de resumen
  6. Si alguna comprobación crítica falló, salir con código de error 1
  7. Si todas las comprobaciones pasaron, salir con código 0 y mostrar mensaje de éxito

---

## Casos de Uso de CI/CD para Habilidades

### 1. Validación Pre-Commit

**Habilidad: `/pre-commit-guard`**

Valida automáticamente los cambios antes de las confirmaciones:
- Linting y formato
- Escaneo de seguridad en busca de secretos
- Ejecución de pruebas unitarias
- Comprobación de tamaño de archivos
- Detección de cambios que rompen la compatibilidad

**Beneficio**: Detecta problemas antes de que entren en la base de código.

### 2. Análisis de Solicitudes de Extracción (Pull Request)

**Habilidad: `/pr-review`**

Revisión inteligente de PR que:
- Analiza los cambios de código en busca de problemas de calidad
- Comprueba vulnerabilidades de seguridad
- Verifica la cobertura de pruebas
- Sugiere mejoras
- Genera comentarios de revisión

**Beneficio**: Revisión de código consistente y exhaustiva sin cuellos de botella humanos.

### 3. Flujos de Trabajo de Pruebas Automatizadas

**Habilidad: `/test-runner`**

Ejecución inteligente de pruebas que:
- Detecta qué pruebas son relevantes para los cambios
- Ejecuta pruebas en orden óptimo
- Analiza fallos y sugiere soluciones
- Genera informes de cobertura
- Sigue las tendencias de rendimiento de las pruebas

**Beneficio**: Retroalimentación más rápida con selección inteligente de pruebas.

### 4. Validación de Implementación

**Habilidad: `/deploy-validator`**

Comprobaciones previas a la implementación, incluyendo:
- Validación de configuración del entorno
- Verificación de dependencias
- Comprobación de migraciones de bases de datos
- Pruebas de compatibilidad de API
- Detección de regresiones de rendimiento

**Beneficio**: Prevenir fallos de implementación antes de que ocurran.

### 5. Monitoreo de Pipeline de CI

**Habilidad: `/ci-monitor`**

Monitorea la salud del pipeline:
- Sigue las tasas de éxito de construcción
- Identifica pruebas inestables (flaky tests)
- Analiza tendencias de rendimiento
- Alerta sobre degradación
- Sugiere optimizaciones

**Beneficio**: Mantenimiento y optimización proactiva del pipeline.

### 6. Automatización de Lanzamientos

**Habilidad: `/release-manager`**

Orquesta el proceso de lanzamiento:
- Incremento de versión
- Generación de Changelog
- Creación de etiquetas
- Verificación de artefactos de construcción
- Redacción de notas de lanzamiento

**Beneficio**: Lanzamientos consistentes y sin errores.

### 7. Automatización de Pruebas de API

**Habilidad: `/api-test-runner`**

Para equipos que construyen APIs, combine las Habilidades de Código de Claude con [Apidog](https://apidog.com) para una validación integral de API:

- **Generar casos de prueba**: Cree pruebas de API a partir de especificaciones OpenAPI/Swagger
- **Ejecutar pruebas automatizadas**: Ejecute colecciones de pruebas de Apidog en su pipeline
- **Validar respuestas**: Compruebe códigos de estado, esquemas y tiempos de respuesta
- **Simular dependencias**: Configure servidores de simulación para pruebas aisladas
- **Seguir cobertura**: Monitoree la cobertura de pruebas de los endpoints de API

**Ejemplo de integración de habilidad:**
```bash
/api-test-runner --collection ./tests/api-collection.json --env production

Beneficio: Detecte regresiones de API antes de la implementación con depuración visual e informes detallados. La integración de CI/CD de Apidog facilita la adición de pruebas de API a cualquier pipeline.

Interfaz de usuario de Apidog mostrando un conjunto de pruebas API con varios casos de prueba para diferentes operaciones como autenticación, recuperación de datos de usuario, actualización y eliminación, con detalles de solicitudes y respuestas.

Creando Su Primera Habilidad de CI/CD

Construyamos una habilidad práctica: una herramienta de revisión de seguridad que verifica el código antes de las confirmaciones.

Paso 1: Crear el Directorio de la Habilidad

mkdir -p .claude/skills/security-review

Paso 2: Escribir el Manifiesto de la Habilidad

Crear .claude/skills/security-review/SKILL.md:

---
name: security-review
version: "1.0.0"
description: Security scan for common vulnerabilities and secrets
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Grep
  - Glob
  - Write
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Security Review] Starting security scan...'"
  Stop:
    - matcher: command
      command: "echo '[Security Review] Scan complete'"
---

# Habilidad de Revisión de Seguridad

Escanea código en busca de problemas de seguridad antes de las confirmaciones.

## Uso

```bash
/security-review                    # Scan all changed files
/security-review --all              # Scan entire codebase
/security-review --file src/auth.js # Scan specific file
```

Patrones de Detección

Esta habilidad busca:

Secretos Hardcodeados

Vulnerabilidades Comunes

Configuraciones Inseguras

Problemas de Dependencias

Instrucciones

Al ser invocada:

Determinar el alcance del escaneo

Buscar secretos

Comprobar patrones de vulnerabilidad

Escanear dependencias

Generar informe

Estado de salida


### Paso 3: Registrar la Habilidad

Añadir a `.claude/skills.md`:

```markdown
# Habilidades Disponibles

## Seguridad y Calidad

### /security-review
Escaneo de seguridad en busca de vulnerabilidades y secretos.
- **Versión**: 1.0.0
- **Uso**: `/security-review [--all] [--file PATH]`
- **Cuándo usar**: Antes de las confirmaciones, durante la revisión de PR
```

Paso 4: Probar la Habilidad

# En Claude Code
/security-review

Claude ejecutará ahora el flujo de trabajo de revisión de seguridad, verificando su código en busca de problemas.

Patrones de Habilidad Avanzados

Patrón 1: Flujos de Trabajo con Estado y Archivos de Planificación

Para procesos de múltiples pasos, use archivos de planificación para seguir el progreso:

---
name: release-manager
version: "1.0.0"
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Write
  - Edit
---

# Gestor de Lanzamientos

Gestiona el proceso completo de lanzamiento.

## Gestión de Estado

Esta habilidad utiliza `planning.md` para seguir el progreso del lanzamiento:

```markdown
# Progreso del Lanzamiento v2.5.0

## Fase 1: Validación Pre-Lanzamiento [HECHO]
- [x] Ejecutar suite de pruebas completa
- [x] Comprobar cobertura de código > 80%
- [x] Escanear en busca de problemas de seguridad

## Fase 2: Incremento de Versión [EN PROGRESO]
- [x] Actualizar package.json
- [ ] Actualizar CHANGELOG.md
- [ ] Actualizar documentación

## Fase 3: Construcción y Etiquetado [PENDIENTE]
- [ ] Crear build de producción
- [ ] Ejecutar pruebas de humo
- [ ] Crear etiqueta git
- [ ] Subir a registro

## Fase 4: Post-Lanzamiento [PENDIENTE]
- [ ] Crear lanzamiento en GitHub
- [ ] Actualizar notas de lanzamiento
- [ ] Notificar al equipo
```

Instrucciones

Comprobar si existe planning.md

Ejecutar cada fase:

Para cada tarea:


### Patrón 2: Flujos de Trabajo Condicionales

Las habilidades pueden adaptarse según el tipo de proyecto:

```markdown
## Instrucciones

1. **Detectar tipo de proyecto**
   - Buscar `package.json` → Proyecto Node.js
   - Buscar `requirements.txt` → Proyecto Python
   - Buscar `Cargo.toml` → Proyecto Rust

2. **Ejecutar pruebas apropiadas**
   - Node.js: `npm test`
   - Python: `pytest`
   - Rust: `cargo test`

3. **Generar informes de cobertura**
   - Node.js: Usar Jest/Istanbul
   - Python: Usar pytest-cov
   - Rust: Usar tarpaulin
```

Patrón 3: Ejecución Paralela

Para tareas independientes, ejecutarlas concurrentemente:

## Instrucciones

1. **Comprobaciones paralelas** (ejecutar simultáneamente):
   - Linting (ESLint, Prettier)
   - Comprobación de tipos (TypeScript)
   - Escaneo de seguridad (npm audit)
   - Construcción de documentación

2. **Recopilar resultados**
   - Esperar a que todas las tareas se completen
   - Agregar hallazgos
   - Informar cualquier fallo

Patrón 4: Toma de Decisiones Interactiva

Las habilidades pueden solicitar la entrada del usuario:

## Instrucciones

1. **Analizar riesgos de implementación**
   - Comprobar cambios que rompen la compatibilidad
   - Revisar scripts de migración
   - Evaluar la complejidad de la reversión

2. **Si se detecta ALTO riesgo**
   - Presentar hallazgos al usuario
   - Preguntar: "¿Implementar de todos modos? (sí/no/cancelar)"
   - Si sí: proceder con la implementación
   - Si no: abortar y registrar decisión
   - Si cancelar: salir sin acción

3. **Si riesgo BAJO**
   - Aprobar automáticamente la implementación
   - Registrar decisión para auditoría

Integrando Habilidades con GitHub Actions

Método 1: Invocación Directa de Habilidad

Añadir Claude Code a su flujo de trabajo de GitHub Actions:

# .github/workflows/security-scan.yml
name: Security Scan

on:
  pull_request:
    branches: [main, develop]

jobs:
  security-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Install Claude Code
        run: |
          curl -fsSL https://install.claude.com | sh

      - name: Run Security Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude /security-review --all

      - name: Upload Report
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: security-report
          path: .claude/security-reports/

Método 2: Acción Personalizada de GitHub

Crear una acción reutilizable:

# .github/actions/claude-skill/action.yml
name: 'Run Claude Code Skill'
description: 'Execute a Claude Code skill in CI'
inputs:
  skill-name:
    description: 'Name of the skill to run'
    required: true
  skill-args:
    description: 'Arguments to pass to the skill'
    required: false
    default: ''
  api-key:
    description: 'Anthropic API key'
    required: true

runs:
  using: 'composite'
  steps:
    - name: Setup Claude
      shell: bash
      run: |
        curl -fsSL https://install.claude.com | sh

    - name: Run Skill
      shell: bash
      env:
        ANTHROPIC_API_KEY: ${{ inputs.api-key }}
      run: |
        claude /${{ inputs.skill-name }} ${{ inputs.skill-args }}

Uso en flujos de trabajo:

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  validate-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Pre-Deployment Validation
        uses: ./.github/actions/claude-skill
        with:
          skill-name: deploy-validation
          skill-args: '--env production'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}

      - name: Deploy
        if: success()
        run: ./deploy.sh production

      - name: Post-Deployment Check
        uses: ./.github/actions/claude-skill
        with:
          skill-name: health-check
          skill-args: '--url https://api.example.com'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}

Método 3: Pruebas de Matriz

Ejecutar habilidades en múltiples entornos:

# .github/workflows/test-matrix.yml
name: Test Matrix

on: [push, pull_request]

jobs:
  test:
    strategy:
      matrix:
        node-version: [16, 18, 20]
        os: [ubuntu-latest, macos-latest, windows-latest]

    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}

      - name: Run Test Skill
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude /test-runner --node-version ${{ matrix.node-version }}

Integración de Git Hooks

Configuración de Git Hooks

Los Git hooks permiten que las habilidades se ejecuten automáticamente en eventos de Git.

Hook Pre-Commit

Prevenir commits erróneos antes de que ocurran:

# .git/hooks/pre-commit
#!/bin/bash

echo "Running pre-commit security review..."

# Run Claude Code security review
claude /security-review

if [ $? -ne 0 ]; then
    echo "FAILED: Security issues detected. Commit blocked."
    echo "Fix the issues above or use 'git commit --no-verify' to bypass (not recommended)"
    exit 1
fi

echo "PASSED: Security check passed"
exit 0

Hacerlo ejecutable:

chmod +x .git/hooks/pre-commit

Hook Pre-Push

Validar antes de hacer push al remoto:

# .git/hooks/pre-push
#!/bin/bash

echo "Running pre-push validation..."

# Get the branch being pushed
BRANCH=$(git rev-parse --abbrev-ref HEAD)

# Run different checks based on branch
if [ "$BRANCH" = "main" ]; then
    echo "Pushing to main - running full validation..."
    claude /deploy-validation --env production
elif [ "$BRANCH" = "develop" ]; then
    echo "Pushing to develop - running staging validation..."
    claude /deploy-validation --env staging
else
    echo "Feature branch - running quick validation..."
    claude /quick-check
fi

if [ $? -ne 0 ]; then
    echo "FAILED: Validation failed. Push blocked."
    exit 1
fi

echo "PASSED: Validation passed"
exit 0

Hook Post-Merge

Ejecutar después de fusionar ramas:

# .git/hooks/post-merge
#!/bin/bash

echo "Post-merge checks..."

# Check if dependencies changed
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "package-lock.json"; then
    echo "Dependencies changed - running security audit..."
    claude /dependency-audit
fi

# Check if database migrations exist
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "migrations/"; then
    echo "Migrations detected - validating..."
    claude /migration-validator
fi

exit 0

Integración con Husky

Para equipos que usan Husky para gestionar los git hooks:

// package.json
{
  "husky": {
    "hooks": {
      "pre-commit": "claude /security-review && claude /lint-check",
      "pre-push": "claude /test-runner --quick",
      "post-merge": "claude /dependency-audit"
    }
  }
}

O con Husky v6+:

# .husky/pre-commit
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

claude /security-review
claude /lint-check

Conclusión

Las Habilidades de Código de Claude transforman el CI/CD de scripts frágiles en flujos de trabajo inteligentes y adaptativos. Al combinar el razonamiento de la IA con la automatización tradicional, las habilidades pueden:

Si su pipeline de CI/CD incluye endpoints de API, combinar las Habilidades de Código de Claude con Apidog le ofrece lo mejor de ambos mundos:

CaracterísticaBeneficio
Pruebas Visuales de APIConstruya casos de prueba sin escribir código
Importación OpenAPIGenere pruebas automáticamente a partir de sus especificaciones
Servidores MockPruebe integraciones antes de que los backends estén listos
CLI de CI/CDEjecute pruebas de Apidog en cualquier pipeline
Colaboración en EquipoComparta colecciones de pruebas con su equipo

¿Listo para optimizar su flujo de trabajo de API? Descargue Apidog gratis y cree su primera colección de pruebas de API en minutos.

botón

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar