Blog

Cara Menggunakan Claude Code Skills untuk CI/CD (Continuous Integration/Continuous Delivery)

Ashley Innocent

Ashley Innocent

22 January 2026

Cara Menggunakan Claude Code Skills untuk CI/CD (Continuous Integration/Continuous Delivery)

Jika Anda mencari cara untuk menyuntikkan kecerdasan ke dalam pipeline CI/CD Anda tanpa bersusah payah dengan skrip otomatisasi yang kompleks, Claude Code Skills mungkin adalah yang Anda butuhkan. Alur kerja kustom bertenaga AI ini mengotomatiskan segalanya mulai dari pemeriksaan keamanan pra-komit hingga validasi deployment. Anda menentukannya menggunakan instruksi bahasa alami alih-alih skrip shell yang rapuh.

Yang membuat Claude Code Skills kuat untuk CI/CD:

💡
Membangun pipeline berbasis API? Gabungkan Claude Code Skills dengan Apidog untuk otomatisasi API end-to-end. Apidog menyediakan pengujian API visual, pembuatan tes otomatis dari spesifikasi OpenAPI, dan alat CLI siap CI/CD yang terintegrasi dengan mulus dengan skill Anda. Coba Apidog gratis untuk meningkatkan alur kerja API Anda.
button

Dalam panduan ini, kita akan menjelajahi apa itu Claude Code Skills, cara membangun alur kerja CI/CD kustom, dan contoh dunia nyata yang dapat Anda terapkan hari ini.

Memahami Claude Code Skills

Apa Itu Skills?

Claude Code Skills adalah alur kerja AI kustom yang dapat digunakan kembali yang memperluas kemampuan Claude Code. Anggaplah mereka sebagai skrip cerdas yang dapat:

Berbeda dengan skrip tradisional yang mengikuti logika kaku, skills memanfaatkan kemampuan penalaran Claude untuk menangani kasus-kasus khusus, menyarankan perbaikan, dan beradaptasi dengan kondisi yang berubah.

Bagaimana Skills Bekerja

Skills beroperasi melalui beberapa mekanisme kunci:

1. Perintah yang Dapat Dipanggil Pengguna

# Jalankan skill dengan perintah slash
/deploy-validation --env production
/security-review
/ci-pipeline-monitor --branch main

2. Alat yang Diizinkan

Skills menentukan alat mana yang dapat mereka gunakan:

3. Lifecycle Hooks

Skills dapat memicu tindakan pada titik-titik tertentu:

4. Planning Files

Skills dapat mempertahankan status menggunakan file markdown untuk melacak kemajuan, menyimpan temuan, dan memungkinkan alur kerja yang dapat dilanjutkan.

Mengapa Skills Unggul dalam CI/CD

Skrip CI/CD tradisional mudah rusak saat menghadapi kondisi yang tidak terduga. Skills membawa kecerdasan ke otomatisasi:

Anatomi Skill: Komponen dan Struktur

Struktur Direktori

Skills berada di .claude/skills/ dengan tata letak ini:

.claude/
├── skills/
│   ├── deploy-validation/
│   │   ├── SKILL.md              # Manifes skill dan instruksi
│   │   ├── planning.md           # Pelacakan status (opsional)
│   │   └── scripts/              # Skrip pembantu (opsional)
│   ├── security-review/
│   │   └── SKILL.md
│   └── ci-monitor/
│       └── SKILL.md
└── skills.md                     # Indeks semua skill

Manifes SKILL.md

Setiap skill dimulai dengan frontmatter YAML diikuti oleh instruksi markdown:

---
name: deploy-validation
version: "1.0.0"
description: Memvalidasi kesiapan deployment dengan pemeriksaan komprehensif
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Edit
  - Grep
  - Glob
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Deploy Validator] Memulai pemeriksaan pra-deployment...'"
  Stop:
    - matcher: command
      command: "echo '[Deploy Validator] Pemeriksaan selesai. Tinjau output di atas.'"
---

# Skill Validasi Deployment

Validasi pra-deployment komprehensif untuk rilis produksi.

## Penggunaan

```bash
/deploy-validation --env production
/deploy-validation --env staging --dry-run
/deploy-validation --skip-tests  # Gunakan dengan hati-hati

Apa yang Dilakukan Skill Ini

Verifikasi Lingkungan

Pemeriksaan Kualitas Kode

Pengujian

Validasi Build

Pemindaian Keamanan

Pemeriksaan Dokumentasi

Laporan Deployment

Instruksi untuk Claude

Saat dipanggil, ikuti proses ini:

  1. Uraikan argumen baris perintah untuk menentukan lingkungan dan opsi
  2. Periksa branch git saat ini dan SHA commit
  3. Jalankan setiap langkah validasi secara berurutan
  4. Untuk setiap kegagalan, catat masalahnya dan lanjutkan (kumpulkan semua kesalahan)
  5. Setelah semua pemeriksaan, buat laporan ringkasan
  6. Jika ada pemeriksaan kritis yang gagal, keluar dengan kode kesalahan 1
  7. Jika semua pemeriksaan lulus, keluar dengan kode 0 dan tampilkan pesan sukses

---

## Kasus Penggunaan CI/CD untuk Skills

### 1. Validasi Pra-Komit

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

Secara otomatis memvalidasi perubahan sebelum komit:
- Linting dan pemformatan
- Pemindaian keamanan untuk rahasia
- Eksekusi pengujian unit
- Pemeriksaan ukuran file
- Deteksi perubahan yang merusak

**Manfaat**: Tangkap masalah sebelum masuk ke basis kode.

### 2. Analisis Permintaan Tarik (Pull Request)

**Skill: `/pr-review`**

Peninjauan PR cerdas yang:
- Menganalisis perubahan kode untuk masalah kualitas
- Memeriksa kerentanan keamanan
- Memverifikasi cakupan pengujian
- Menyarankan perbaikan
- Menghasilkan komentar peninjauan

**Manfaat**: Peninjauan kode yang konsisten dan menyeluruh tanpa hambatan manusia.

### 3. Alur Kerja Pengujian Otomatis

**Skill: `/test-runner`**

Eksekusi pengujian cerdas yang:
- Mendeteksi pengujian mana yang relevan dengan perubahan
- Menjalankan pengujian dalam urutan optimal
- Menganalisis kegagalan dan menyarankan perbaikan
- Menghasilkan laporan cakupan
- Melacak tren kinerja pengujian

**Manfaat**: Umpan balik yang lebih cepat dengan pemilihan pengujian yang cerdas.

### 4. Validasi Deployment

**Skill: `/deploy-validator`**

Pemeriksaan pra-deployment meliputi:
- Validasi konfigurasi lingkungan
- Verifikasi dependensi
- Pemeriksaan migrasi database
- Pengujian kompatibilitas API
- Deteksi regresi kinerja

**Manfaat**: Mencegah kegagalan deployment sebelum terjadi.

### 5. Pemantauan Pipeline CI

**Skill: `/ci-monitor`**

Memantau kesehatan pipeline:
- Melacak tingkat keberhasilan build
- Mengidentifikasi pengujian yang tidak stabil
- Menganalisis tren kinerja
- Memberikan peringatan saat terjadi degradasi
- Menyarankan optimasi

**Manfaat**: Pemeliharaan dan optimasi pipeline yang proaktif.

### 6. Otomatisasi Rilis

**Skill: `/release-manager`**

Mengorkestrasi proses rilis:
- Peningkatan versi
- Pembuatan Changelog
- Pembuatan tag
- Verifikasi artefak build
- Penyusunan catatan rilis

**Manfaat**: Rilis yang konsisten dan bebas kesalahan.

### 7. Otomatisasi Pengujian API

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

Untuk tim yang membangun API, gabungkan Claude Code Skills dengan [Apidog](https://apidog.com) untuk validasi API yang komprehensif:

- **Hasilkan kasus uji**: Buat pengujian API dari spesifikasi OpenAPI/Swagger
- **Jalankan pengujian otomatis**: Eksekusi koleksi pengujian Apidog dalam pipeline Anda
- **Validasi respons**: Periksa kode status, skema, dan waktu respons
- **Mock dependensi**: Siapkan server mock untuk pengujian terisolasi
- **Lacak cakupan**: Pantau cakupan pengujian endpoint API

**Contoh integrasi skill:**
```bash
/api-test-runner --collection ./tests/api-collection.json --env production

Manfaat: Tangkap regresi API sebelum deployment dengan debugging visual dan laporan terperinci. Integrasi CI/CD Apidog memudahkan penambahan pengujian API ke pipeline apa pun.

Membuat Skill CI/CD Pertama Anda

Mari kita bangun skill praktis: alat tinjauan keamanan yang memeriksa kode sebelum komit.

Langkah 1: Buat Direktori Skill

mkdir -p .claude/skills/security-review

Langkah 2: Tulis Manifes Skill

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

---
name: security-review
version: "1.0.0"
description: Pemindaian keamanan untuk kerentanan umum dan rahasia
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Grep
  - Glob
  - Write
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Tinjauan Keamanan] Memulai pemindaian keamanan...'"
  Stop:
    - matcher: command
      command: "echo '[Tinjauan Keamanan] Pemindaian selesai'"
---

# Skill Tinjauan Keamanan

Memindai kode untuk masalah keamanan sebelum komit.

## Penggunaan

```bash
/security-review                    # Pindai semua file yang diubah
/security-review --all              # Pindai seluruh basis kode
/security-review --file src/auth.js # Pindai file tertentu

Pola Deteksi

Skill ini memeriksa:

Rahasia yang di-hardcode

Kerentanan Umum

Konfigurasi Tidak Aman

Masalah Dependensi

Instruksi

Saat dipanggil:

Tentukan cakupan pemindaian

Cari rahasia

Periksa pola kerentanan

Pindai dependensi

Hasilkan laporan

Status keluar


### Langkah 3: Daftarkan Skill

Tambahkan ke `.claude/skills.md`:

```markdown
# Skills yang Tersedia

## Keamanan & Kualitas

### /security-review
Pemindaian keamanan untuk kerentanan dan rahasia.
- **Versi**: 1.0.0
- **Penggunaan**: `/security-review [--all] [--file PATH]`
- **Kapan digunakan**: Sebelum komit, selama peninjauan PR

Langkah 4: Uji Skill

# Di Claude Code
/security-review

Claude sekarang akan mengeksekusi alur kerja tinjauan keamanan, memeriksa kode Anda untuk masalah.

Pola Skill Tingkat Lanjut

Pola 1: Alur Kerja Stateful dengan Planning Files

Untuk proses multi-langkah, gunakan planning files untuk melacak kemajuan:

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

# Manajer Rilis

Mengelola proses rilis lengkap.

## Manajemen Status

Skill ini menggunakan `planning.md` untuk melacak kemajuan rilis:

```markdown
# Kemajuan Rilis v2.5.0

## Fase 1: Validasi Pra-Rilis [SELESAI]
- [x] Jalankan rangkaian pengujian lengkap
- [x] Periksa cakupan kode > 80%
- [x] Pindai masalah keamanan

## Fase 2: Peningkatan Versi [DALAM PROSES]
- [x] Perbarui package.json
- [ ] Perbarui CHANGELOG.md
- [ ] Perbarui dokumentasi

## Fase 3: Build & Tag [TERTUNDA]
- [ ] Buat build produksi
- [ ] Jalankan pengujian dasar (smoke tests)
- [ ] Buat tag git
- [ ] Dorong ke registri

## Fase 4: Pasca-Rilis [TERTUNDA]
- [ ] Buat rilis GitHub
- [ ] Perbarui catatan rilis
- [ ] Beri tahu tim

Instruksi

Periksa apakah planning.md ada

Eksekusi setiap fase:

Untuk setiap tugas:


### Pola 2: Alur Kerja Kondisional

Skills dapat beradaptasi berdasarkan jenis proyek:

```markdown
## Instruksi

1. **Deteksi jenis proyek**
   - Periksa `package.json` → Proyek Node.js
   - Periksa `requirements.txt` → Proyek Python
   - Periksa `Cargo.toml` → Proyek Rust

2. **Jalankan pengujian yang sesuai**
   - Node.js: `npm test`
   - Python: `pytest`
   - Rust: `cargo test`

3. **Hasilkan laporan cakupan**
   - Node.js: Gunakan Jest/Istanbul
   - Python: Gunakan pytest-cov
   - Rust: Gunakan tarpaulin

Pola 3: Eksekusi Paralel

Untuk tugas-tugas independen, jalankan secara bersamaan:

## Instruksi

1. **Pemeriksaan paralel** (jalankan secara bersamaan):
   - Linting (ESLint, Prettier)
   - Pemeriksaan tipe (TypeScript)
   - Pemindaian keamanan (npm audit)
   - Build dokumentasi

2. **Kumpulkan hasil**
   - Tunggu semua tugas selesai
   - Agregasikan temuan
   - Laporkan kegagalan apa pun

Pola 4: Pengambilan Keputusan Interaktif

Skills dapat meminta input pengguna:

## Instruksi

1. **Analisis risiko deployment**
   - Periksa perubahan yang merusak
   - Tinjau skrip migrasi
   - Nilai kompleksitas rollback

2. **Jika risiko TINGGI terdeteksi**
   - Sajikan temuan kepada pengguna
   - Tanyakan: "Deploy tetap? (ya/tidak/batal)"
   - Jika ya: lanjutkan dengan deployment
   - Jika tidak: batalkan dan catat keputusan
   - Jika batal: keluar tanpa tindakan

3. **Jika risiko RENDAH**
   - Otomatis setujui deployment
   - Catat keputusan untuk audit

Mengintegrasikan Skills dengan GitHub Actions

Metode 1: Pemanggilan Skill Langsung

Tambahkan Claude Code ke alur kerja GitHub Actions Anda:

# .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/

Metode 2: GitHub Action Kustom

Buat action yang dapat digunakan kembali:

# .github/actions/claude-skill/action.yml
name: 'Jalankan Claude Code Skill'
description: 'Eksekusi skill Claude Code di CI'
inputs:
  skill-name:
    description: 'Nama skill yang akan dijalankan'
    required: true
  skill-args:
    description: 'Argumen untuk diteruskan ke skill'
    required: false
    default: ''
  api-key:
    description: 'Kunci API Anthropic'
    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 }}

Penggunaan dalam alur kerja:

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

on:
  push:
    branches: [main]

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

      - name: Validasi Pra-Deployment
        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: Pemeriksaan Pasca-Deployment
        uses: ./.github/actions/claude-skill
        with:
          skill-name: health-check
          skill-args: '--url https://api.example.com'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}

Metode 3: Pengujian Matriks

Jalankan skill di berbagai lingkungan:

# .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 }}

Integrasi Git Hooks

Menyiapkan Git Hooks

Git hooks memungkinkan skill berjalan otomatis pada event git.

Pre-Commit Hook

Mencegah komit buruk sebelum terjadi:

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

echo "Menjalankan tinjauan keamanan pra-komit..."

# Jalankan tinjauan keamanan Claude Code
claude /security-review

if [ $? -ne 0 ]; then
    echo "GAGAL: Masalah keamanan terdeteksi. Komit diblokir."
    echo "Perbaiki masalah di atas atau gunakan 'git commit --no-verify' untuk melewati (tidak disarankan)"
    exit 1
fi

echo "LULUS: Pemeriksaan keamanan lulus"
exit 0

Jadikan dapat dieksekusi:

chmod +x .git/hooks/pre-commit

Pre-Push Hook

Validasi sebelum mendorong ke remote:

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

echo "Menjalankan validasi pra-push..."

# Dapatkan branch yang sedang didorong
BRANCH=$(git rev-parse --abbrev-ref HEAD)

# Jalankan pemeriksaan yang berbeda berdasarkan branch
if [ "$BRANCH" = "main" ]; then
    echo "Mendorong ke main - menjalankan validasi penuh..."
    claude /deploy-validation --env production
elif [ "$BRANCH" = "develop" ]; then
    echo "Mendorong ke develop - menjalankan validasi staging..."
    claude /deploy-validation --env staging
else
    echo "Branch fitur - menjalankan validasi cepat..."
    claude /quick-check
fi

if [ $? -ne 0 ]; then
    echo "GAGAL: Validasi gagal. Push diblokir."
    exit 1
fi

echo "LULUS: Validasi lulus"
exit 0

Post-Merge Hook

Jalankan setelah menggabungkan branch:

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

echo "Pemeriksaan pasca-gabung..."

# Periksa apakah dependensi berubah
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "package-lock.json"; then
    echo "Dependensi berubah - menjalankan audit keamanan..."
    claude /dependency-audit
fi

# Periksa apakah migrasi database ada
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "migrations/"; then
    echo "Migrasi terdeteksi - memvalidasi..."
    claude /migration-validator
fi

exit 0

Integrasi Husky

Untuk tim yang menggunakan Husky untuk mengelola 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"
    }
  }
}

Atau dengan Husky v6+:

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

claude /security-review
claude /lint-check

Kesimpulan

Claude Code Skills mengubah CI/CD dari skrip yang rapuh menjadi alur kerja yang cerdas dan adaptif. Dengan menggabungkan penalaran AI dengan otomatisasi tradisional, skill dapat:

Jika pipeline CI/CD Anda menyertakan endpoint API, menggabungkan Claude Code Skills dengan Apidog memberi Anda yang terbaik dari kedua dunia:

FiturManfaat
Pengujian API VisualBangun kasus uji tanpa menulis kode
Impor OpenAPIHasilkan pengujian secara otomatis dari spesifikasi Anda
Server MockUji integrasi sebelum backend siap
CLI CI/CDJalankan pengujian Apidog di pipeline apa pun
Kolaborasi TimBagikan koleksi pengujian di seluruh tim Anda

Siap untuk menyederhanakan alur kerja API Anda? Unduh Apidog gratis dan buat koleksi pengujian API pertama Anda dalam hitungan menit.

button

Mengembangkan API dengan Apidog

Apidog adalah alat pengembangan API yang membantu Anda mengembangkan API dengan lebih mudah dan efisien.

Daftar gratisUnduh