Cara Membuat Skill Kode Claude Secara Otomatis dengan Skill Creator

Singkatan

Keterampilan Kode Claude adalah kapabilitas kustom yang memperluas fungsionalitas Claude untuk alur kerja tertentu. Sistem Skill Creator mengotomatiskan pembuatan keterampilan melalui proses terstruktur: definisikan tujuan keterampilan Anda, susun berkas SKILL.md, buat kasus uji, jalankan evaluasi dengan tolok ukur kuantitatif, dan tingkatkan secara iteratif berdasarkan umpan balik.

Pengantar

Anda menggunakan Kode Claude setiap hari. Anda menyadari diri Anda mengulangi urutan yang sama: menyiapkan struktur proyek, menjalankan perintah uji tertentu, memformat keluaran dengan cara tertentu. Setiap kali, Anda menjelaskan alur kerja dari awal. Bagaimana jika Claude mengingatnya? Bagaimana jika Anda bisa menangkap alur kerja itu sekali, dan menyediakannya selamanya? Itulah yang dilakukan Keterampilan Kode Claude. Mereka adalah kapabilitas kustom yang Anda buat untuk memperluas fungsionalitas Claude untuk alur kerja spesifik Anda. Dan dengan Skill Creator, prosesnya otomatis dan sistematis.

Panduan ini akan memandu Anda melalui seluruh proses. Anda akan mempelajari anatomi keterampilan, alur kerja pembuatan, sistem evaluasi, dan cara mengoptimalkan untuk pemicuan yang andal. Anda akan melihat contoh kerja dari repositori keterampilan resmi Anthropic.

💡

Jika Anda membangun keterampilan terkait API, Apidog terintegrasi secara alami. Uji titik akhir API Anda, validasi respons, dan hasilkan dokumentasi semua dalam satu alur kerja keterampilan.

tombol

Apa Itu Keterampilan Kode Claude?

Keterampilan Kode Claude adalah set instruksi khusus yang memperluas kapabilitas Claude untuk domain atau alur kerja tertentu. Anggaplah mereka sebagai plugin kustom yang tersimpan dalam berkas markdown.

Arsitektur Sistem Keterampilan

Keterampilan menggunakan sistem pemuatan tiga tingkat:

Metadata (~100 kata) - Nama dan deskripsi, selalu dalam konteks
Isi SKILL.md (<500 baris) - Instruksi inti, dimuat saat keterampilan dipicu
Sumber daya terpaket (tidak terbatas) - Skrip, referensi, aset yang dimuat sesuai permintaan

skill-name/
├── SKILL.md (wajib)
│   ├── YAML frontmatter (nama, deskripsi)
│   └── Instruksi Markdown
└── Sumber Daya Terpaket (opsional)
    ├── scripts/    - Kode yang dapat dieksekusi untuk tugas berulang
    ├── references/ - Dokumentasi dimuat sesuai kebutuhan
    └── assets/     - Templat, ikon, font

Kapan Keterampilan Dipicu

Keterampilan muncul dalam daftar available_skills Claude dengan nama dan deskripsinya. Claude memutuskan apakah akan berkonsultasi dengan suatu keterampilan berdasarkan deskripsi tersebut.

Penting: Keterampilan hanya akan dipicu untuk tugas yang tidak dapat ditangani Claude secara langsung. Permintaan sederhana seperti “baca berkas ini” tidak akan memicu keterampilan meskipun dengan deskripsi yang cocok. Alur kerja kompleks dengan banyak langkah akan dipicu secara andal jika deskripsinya cocok.

Contoh Nyata dari Repositori Anthropic

Keterampilan	Tujuan	Fitur Utama
skill-creator	Membuat keterampilan baru	Pembuatan kasus uji, evaluasi tolok ukur, optimasi deskripsi
mcp-builder	Membangun server MCP	Templat Python/Node, kerangka evaluasi, praktik terbaik
docx	Membuat dokumen Word	Skrip python-docx, sistem templat, panduan gaya
pdf	Mengekstrak dan memanipulasi PDF	Penanganan formulir, ekstraksi teks, dokumen referensi
frontend-design	Membuat antarmuka web	Pustaka komponen, pola Tailwind, pemeriksaan aksesibilitas

Alur Kerja Pembuatan Keterampilan

Proses pembuatan keterampilan mengikuti siklus sistematis:

Tangkap tujuan - Apa yang harus dilakukan keterampilan ini?
Tulis draf - Buat berkas SKILL.md
Buat kasus uji - Definisikan prompt yang realistis
Jalankan evaluasi - Jalankan dengan dan tanpa keterampilan
Tinjau hasil - Umpan balik kualitatif + metrik kuantitatif
Iterasi - Tingkatkan berdasarkan temuan
Optimalkan deskripsi - Maksimalkan akurasi pemicuan
Paket - Distribusikan sebagai berkas .skill

Mari kita bahas setiap langkah.

Langkah 1: Tangkap Tujuan

Mulailah dengan memahami apa yang ingin Anda capai dengan keterampilan ini. Jika Anda menangkap alur kerja yang sudah Anda lakukan, ekstrak polanya dari riwayat percakapan Anda.

Ajukan empat pertanyaan ini:

Apa yang harus dilakukan keterampilan ini agar Claude dapat melakukannya? Spesifikasikan hasilnya.
Kapan keterampilan ini harus dipicu? Frasa atau konteks pengguna apa?
Apa format keluaran yang diharapkan? Berkas, kode, laporan?
Haruskah kita menyiapkan kasus uji? Keterampilan dengan keluaran yang dapat diverifikasi (pembuatan kode, ekstraksi data, transformasi berkas) mendapat manfaat dari kasus uji. Keterampilan dengan keluaran subjektif (gaya penulisan, desain) seringkali tidak membutuhkannya.

Contoh: Keterampilan Pengujian API

Tujuan: Membantu pengembang menguji API REST secara sistematis
Pemicu: Ketika pengguna menyebutkan pengujian API, titik akhir, REST, GraphQL, atau ingin memvalidasi respons
Keluaran: Laporan uji dengan status lulus/gagal, perintah curl, perbandingan respons
Kasus uji: Ya - keluaran dapat diverifikasi secara objektif

Langkah 2: Tulis Berkas SKILL.md

Setiap keterampilan dimulai dengan berkas SKILL.md yang berisi frontmatter YAML dan instruksi markdown.

Anatomi Keterampilan

---
name: api-tester
description: Cara menguji API REST secara sistematis. Gunakan saat pengguna menyebutkan pengujian API, titik akhir, REST, GraphQL, atau ingin memvalidasi respons API. Pastikan untuk menyarankan keterampilan ini kapan pun pengujian terlibat.
compatibility: Membutuhkan curl atau alat klien HTTP
---

# Keterampilan Penguji API

## Alur Kerja Inti

Saat menguji API, ikuti langkah-langkah berikut:

1. **Pahami titik akhir** - Baca spesifikasi atau minta skema
2. **Rancang kasus uji** - Jalur sukses, kasus batas, kondisi kesalahan
3. **Jalankan uji** - Gunakan curl atau Apidog untuk permintaan
4. **Validasi respons** - Periksa kode status, header, struktur badan
5. **Laporkan hasil** - Ringkas lulus/gagal dengan bukti

## Templat Kasus Uji

Untuk setiap titik akhir, uji:

- Autentikasi valid dengan payload yang benar
- Autentikasi valid dengan bidang wajib yang hilang
- Autentikasi tidak valid (401 diharapkan)
- Perilaku pembatasan laju
- Waktu respons di bawah beban

## Format Keluaran

Selalu susun laporan seperti ini:

# Laporan Uji API

## Ringkasan
- Uji dijalankan: X
- Lulus: Y
- Gagal: Z

## Uji Gagal

### Nama Uji
**Diharapkan:** 200 OK
**Aktual:** 400 Permintaan Buruk
**Respons:** {...}

## Rekomendasi
...

Praktik Terbaik Penulisan

Gunakan pengungkapan progresif: Pertahankan SKILL.md di bawah 500 baris. Pindahkan referensi rinci ke berkas terpisah.

api-tester/
├── SKILL.md (ikhtisar alur kerja)
└── references/
    ├── authentication.md
    ├── rate-limiting.md
    └── response-codes.md

Jelaskan alasannya: Jangan hanya mencantumkan aturan. Jelaskan mengapa aturan tersebut penting.

## Mengapa kita menguji kasus kesalahan terlebih dahulu

Menguji kondisi kesalahan sebelum jalur sukses menangkap 80% masalah lebih cepat.
Ketika autentikasi gagal secara diam-diam, uji jalur sukses menjadi tidak berarti.
Mulailah dengan pemeriksaan 401.

Gunakan bentuk imperatif: “Selalu validasi kode status terlebih dahulu” bukan “Anda harus memvalidasi...”

Sertakan contoh: Tunjukkan masukan dan keluaran yang diharapkan.

## Format pesan komit

**Contoh:**
Masukan: Menambahkan autentikasi pengguna dengan token JWT
Keluaran: feat(auth): implementasi autentikasi berbasis JWT

Langkah 3: Buat Kasus Uji

Setelah menyusun keterampilan, buat 2-3 prompt uji yang realistis. Ini adalah jenis permintaan yang benar-benar akan dibuat oleh pengguna.

Format Kasus Uji

Simpan kasus uji ke evals/evals.json:

{
  "skill_name": "api-tester",
  "evals": [
    {
      "id": 1,
      "prompt": "Uji titik akhir /users di api.example.com - ini membutuhkan token Bearer dan mengembalikan daftar pengguna dengan bidang id, nama, email",
      "expected_output": "Laporan uji dengan setidaknya 5 kasus uji termasuk kegagalan auth, keberhasilan, dan uji paginasi",
      "files": []
    },
    {
      "id": 2,
      "prompt": "Saya perlu memverifikasi titik akhir POST /orders baru kami menangani kuantitas tidak valid dengan benar",
      "expected_output": "Kasus uji yang mengirim kuantitas negatif, nol, dan non-numerik dengan respons kesalahan yang sesuai",
      "files": ["openapi.yaml"]
    }
  ]
}

Apa yang Membuat Prompt Uji yang Baik

Buruk: “Uji API ini”

Baik: “ok tim saya baru saja menyebarkan titik akhir pembayaran baru ini di https://api.stripe.com/v1/charges dan saya perlu memverifikasi bahwa itu menangani kasus batas — khususnya apa yang terjadi ketika Anda mengirim jumlah negatif atau kode mata uang yang tidak ada. Dokumen mengatakan itu harus mengembalikan 400 tetapi saya ingin melihat pesan kesalahan yang sebenarnya”

Prompt uji yang baik meliputi:

URL Spesifik
Skenario Konkret
Perilaku yang Diharapkan
Konteks dunia nyata

Bagikan kasus uji Anda dengan pengguna sebelum menjalankannya: “Berikut adalah beberapa skenario uji yang ingin saya coba. Apakah ini terlihat benar, atau Anda ingin menambahkan lebih banyak?”

Langkah 4: Jalankan Evaluasi

Di sinilah Skill Creator unggul. Anda akan menjalankan setiap kasus uji dua kali: sekali dengan keterampilan, sekali tanpa (atau dengan versi lama jika meningkatkan keterampilan yang sudah ada).

Struktur Ruang Kerja

Hasil masuk ke <skill-name>-workspace/ sebagai saudara dari direktori keterampilan:

api-tester-workspace/
├── iteration-1/
│   ├── eval-0-auth-failure/
│   │   ├── with_skill/
│   │   │   ├── outputs/
│   │   │   └── timing.json
│   │   ├── without_skill/
│   │   │   ├── outputs/
│   │   │   └── timing.json
│   │   └── eval_metadata.json
│   ├── eval-1-pagination/
│   │   └── ...
│   ├── benchmark.json
│   └── benchmark.md
├── iteration-2/
└── feedback.json

Luncurkan Eksekusi Paralel

Untuk setiap kasus uji, buat dua subagen dalam giliran yang sama:

Eksekusi dengan keterampilan:

Jalankan tugas ini:
- Jalur keterampilan: /path/to/api-tester
- Tugas: Uji titik akhir /users di api.example.com
- Berkas masukan: tidak ada
- Simpan keluaran ke: api-tester-workspace/iteration-1/eval-0/with_skill/outputs/

Eksekusi dasar:

Jalankan tugas ini:
- Jalur keterampilan: (tidak ada)
- Tugas: Uji titik akhir /users di api.example.com
- Berkas masukan: tidak ada
- Simpan keluaran ke: api-tester-workspace/iteration-1/eval-0/without_skill/outputs/

Tangkap Data Waktu

Ketika setiap subagen selesai, Anda menerima total_tokens dan duration_ms. Simpan segera ke timing.json:

{
  "total_tokens": 84852,
  "duration_ms": 23332,
  "total_duration_seconds": 23.3
}

Data ini hanya datang melalui notifikasi tugas. Proses setiap data saat tiba.

Langkah 5: Susun Pernyataan Saat Eksekusi Selesai

Jangan hanya menunggu eksekusi selesai. Gunakan waktu itu secara produktif dengan menyusun pernyataan kuantitatif.

Apa yang Membuat Pernyataan yang Baik

Pernyataan yang baik adalah:

Dapat diverifikasi secara objektif - Lulus/gagal tidak ambigu
Dinamai secara deskriptif - Jelas apa yang sedang diperiksa
Dapat digunakan kembali - Berfungsi di seluruh iterasi

Contoh pernyataan untuk keterampilan pengujian API:

{
  "assertions": [
    {
      "name": "includes_auth_failure_test",
      "description": "Laporan uji mencakup setidaknya satu kasus uji kegagalan autentikasi",
      "type": "contains",
      "value": "401"
    },
    {
      "name": "includes_success_test",
      "description": "Laporan uji mencakup setidaknya satu uji permintaan yang berhasil",
      "type": "contains",
      "value": "200"
    },
    {
      "name": "includes_curl_commands",
      "description": "Setiap kasus uji mencakup perintah curl yang dapat dieksekusi",
      "type": "regex",
      "value": "curl -"
    },
    {
      "name": "includes_response_validation",
      "description": "Laporan memvalidasi struktur respons terhadap skema",
      "type": "contains",
      "value": "schema"
    }
  ]
}

Perbarui eval_metadata.json dan evals/evals.json dengan pernyataan setelah disusun.

Langkah 6: Nilai dan Agregasikan

Setelah semua eksekusi selesai:

Nilai Setiap Eksekusi

Buat subagen penilai yang membaca agents/grader.md dan mengevaluasi setiap pernyataan terhadap keluaran. Simpan hasilnya ke grading.json di setiap direktori eksekusi:

{
  "eval_id": 0,
  "grading": [
    {
      "text": "includes_auth_failure_test",
      "passed": true,
      "evidence": "Ditemukan kode status 401 di kasus uji 3"
    },
    {
      "text": "includes_curl_commands",
      "passed": true,
      "evidence": "Ditemukan 'curl -X POST' di kasus uji 1"
    }
  ]
}

Penting: Array ekspektasi grading.json harus menggunakan nama bidang text, passed, dan evidence. Penampil bergantung pada nama-nama ini.

Agregasikan ke Tolok Ukur

Jalankan skrip agregasi dari direktori skill-creator:

python -m scripts.aggregate_benchmark api-tester-workspace/iteration-1 --skill-name api-tester

Ini menghasilkan benchmark.json dan benchmark.md dengan pass_rate, waktu, dan token untuk setiap konfigurasi, termasuk rata-rata ± stddev dan delta.

Lakukan Analisis

Baca data tolok ukur dan cari pola:

Pernyataan non-diskriminatif - Selalu lulus terlepas dari keterampilan (tidak berguna)
Evaluasi varians tinggi - Mungkin tidak stabil, perlu investigasi
Pertukaran waktu/token - Apakah keterampilan meningkatkan kualitas dengan biaya yang wajar?

Lihat agents/analyzer.md untuk panduan rinci.

Langkah 7: Luncurkan Penampil Evaluasi

Penampil evaluasi menunjukkan keluaran kualitatif dan metrik kuantitatif dalam antarmuka peramban.

Buat Penampil

nohup python /path/to/skill-creator/eval-viewer/generate_review.py \
  api-tester-workspace/iteration-1 \
  --skill-name "api-tester" \
  --benchmark api-tester-workspace/iteration-1/benchmark.json \
  > /dev/null 2>&1 &
VIEWER_PID=$!

Untuk iterasi 2+, juga lewatkan --previous-workspace:

--previous-workspace api-tester-workspace/iteration-1

Apa yang Dilihat Pengguna

Tab Keluaran menunjukkan satu kasus uji pada satu waktu:

Prompt - Tugas yang diberikan
Keluaran - Berkas yang dihasilkan, dirender secara inline
Keluaran Sebelumnya (iterasi 2+) - Bagian yang diciutkan dengan keluaran iterasi terakhir
Nilai Formal - Lulus/gagal pernyataan yang diciutkan
Umpan Balik - Kotak teks yang menyimpan otomatis saat mereka mengetik
Umpan Balik Sebelumnya (iterasi 2+) - Komentar dari iterasi terakhir

Tab Tolok Ukur menunjukkan:

Tingkat kelulusan untuk setiap konfigurasi
Perbandingan waktu
Penggunaan token
Rincian per-evaluasi
Observasi analis

Beri tahu pengguna: “Saya telah membuka hasil di peramban Anda. Ada dua tab - 'Keluaran' memungkinkan Anda mengklik setiap kasus uji dan memberikan umpan balik, 'Tolok Ukur' menunjukkan perbandingan kuantitatif. Setelah selesai, kembali ke sini dan beri tahu saya.”

Lingkungan Cowork / Headless

Jika webbrowser.open() tidak tersedia, gunakan --static untuk menulis berkas HTML mandiri:

--static /path/to/output/review.html

Umpan balik diunduh sebagai feedback.json ketika pengguna mengklik “Submit All Reviews” (Kirim Semua Ulasan).

Langkah 8: Baca Umpan Balik dan Iterasi

Ketika pengguna selesai, baca feedback.json:

{
  "reviews": [
    {
      "run_id": "eval-0-with_skill",
      "feedback": "grafik tidak memiliki label sumbu",
      "timestamp": "2026-03-23T10:30:00Z"
    },
    {
      "run_id": "eval-1-with_skill",
      "feedback": "",
      "timestamp": "2026-03-23T10:31:00Z"
    },
    {
      "run_id": "eval-2-with_skill",
      "feedback": "sempurna, suka ini",
      "timestamp": "2026-03-23T10:32:00Z"
    }
  ],
  "status": "complete"
}

Umpan balik kosong berarti pengguna menganggapnya baik-baik saja. Fokuskan perbaikan pada kasus uji dengan keluhan spesifik.

Cara Berpikir tentang Perbaikan

Generalisasi dari umpan balik: Anda membuat keterampilan yang digunakan ribuan kali di banyak prompt. Jangan terlalu menyesuaikan dengan kasus uji spesifik. Jika ada masalah yang membandel, coba metafora atau pola yang berbeda daripada pernyataan HARUS yang membatasi.

Pertahankan prompt yang ramping: Hapus apa yang tidak memberikan nilai. Baca transkrip, bukan hanya keluaran akhir. Jika keterampilan membuat model membuang waktu pada langkah yang tidak produktif, hapus bagian-bagian itu.

Jelaskan alasannya: LLM memiliki teori pikiran yang baik. Ketika diberikan kendali yang baik, mereka melampaui instruksi hafalan. Jelaskan mengapa setiap persyaratan penting. Jika Anda mendapati diri Anda menulis SELALU atau TIDAK PERNAH dengan huruf kapital, ubah bingkai dan jelaskan alasannya sebagai gantinya.

Cari pekerjaan yang berulang: Apakah semua kasus uji secara independen menulis skrip pembantu serupa? Itu adalah sinyal bahwa keterampilan harus membundel skrip itu. Tulis sekali, masukkan ke scripts/, dan beri tahu keterampilan untuk menggunakannya.

Siklus Iterasi

Terapkan perbaikan pada keterampilan
Jalankan kembali semua kasus uji ke iteration-<N+1>/ dengan eksekusi dasar
Luncurkan penampil dengan --previous-workspace menunjuk ke iterasi sebelumnya
Tunggu ulasan pengguna
Baca umpan balik baru, tingkatkan lagi, ulangi

Lanjutkan hingga:

Pengguna mengatakan mereka senang
Umpan balik semuanya kosong (semuanya terlihat baik)
Anda tidak membuat kemajuan yang berarti

Matikan penampil setelah selesai:

kill $VIEWER_PID 2>/dev/null

Langkah 9: Optimalkan Deskripsi Keterampilan

Bidang deskripsi dalam SKILL.md frontmatter adalah mekanisme pemicu utama. Setelah membuat atau meningkatkan keterampilan, optimalkan untuk akurasi pemicu yang lebih baik.

Hasilkan Kueri Evaluasi Pemicu

Buat 20 kueri evaluasi - campuran dari yang harus memicu dan yang tidak boleh memicu:

[
  {
    "query": "ok bos saya baru saja mengirimkan saya berkas xlsx ini (ada di unduhan saya, namanya seperti 'Q4 sales final FINAL v2.xlsx') dan dia ingin saya menambahkan kolom yang menunjukkan margin keuntungan sebagai persentase. Pendapatan ada di kolom C dan biaya di kolom D saya rasa",
    "should_trigger": true
  },
  {
    "query": "Saya perlu membuat tabel pivot dari CSV ini dan mengirimkannya melalui email ke tim",
    "should_trigger": false
  }
]

Untuk kueri yang harus memicu (8-10):

Frasa yang berbeda dengan tujuan yang sama
Bahasa formal dan kasual
Kasus di mana pengguna tidak secara eksplisit menamai keterampilan tetapi jelas membutuhkannya
Kasus batas dan kasus penggunaan yang tidak umum

Untuk kueri yang tidak boleh memicu (8-10):

Hampir cocok yang berbagi kata kunci tetapi membutuhkan sesuatu yang berbeda
Domain yang berdekatan di mana alat lain lebih sesuai
Frasa ambigu di mana pencocokan kata kunci yang naif akan memicu secara tidak benar

Uji negatif yang buruk: “Tulis fungsi fibonacci” sebagai uji negatif untuk keterampilan PDF terlalu mudah. Kasus negatif harus benar-benar rumit.

Tinjau dengan Pengguna

Sajikan set evaluasi menggunakan templat HTML:

Baca assets/eval_review.html
Ganti placeholder dengan data evaluasi, nama keterampilan, dan deskripsi
Tulis ke berkas sementara dan buka: open /tmp/eval_review_api-tester.html
Pengguna dapat mengedit kueri, mengaktifkan/menonaktifkan pemicu, menambah/menghapus entri
Pengguna mengklik “Export Eval Set”
Berkas diunduh ke ~/Downloads/eval_set.json

Langkah ini penting. Kueri evaluasi yang buruk mengarah pada deskripsi yang buruk.

Jalankan Siklus Optimasi

python -m scripts.run_loop \
  --eval-set /path/to/trigger-eval.json \
  --skill-path /path/to/api-tester \
  --model claude-sonnet-4-6 \
  --max-iterations 5 \
  --verbose

Gunakan ID model yang menggerakkan sesi Anda saat ini agar uji pemicuan sesuai dengan apa yang dialami pengguna.

Skrip:

Membagi set evaluasi menjadi 60% latih, 40% uji tahanan
Mengevaluasi deskripsi saat ini (3 eksekusi masing-masing untuk keandalan)
Memanggil Claude untuk mengusulkan perbaikan berdasarkan kegagalan
Mengevaluasi ulang pada latih dan uji
Beriterasi hingga 5 kali
Mengembalikan best_description yang dipilih berdasarkan skor uji (bukan skor latih untuk menghindari overfitting)

Terapkan Hasil

Ambil best_description dari keluaran JSON dan perbarui frontmatter SKILL.md keterampilan. Tunjukkan kepada pengguna sebelum/sesudah dengan skor.

Sebelum:

description: Cara menguji API REST secara sistematis

Sesudah:

description: Cara menguji API REST secara sistematis. Gunakan saat pengguna menyebutkan pengujian API, titik akhir, REST, GraphQL, atau ingin memvalidasi respons API. Pastikan untuk menyarankan keterampilan ini kapan pun pengujian terlibat, bahkan jika mereka tidak secara eksplisit menyebutkan 'pengujian'.

Langkah 10: Paket dan Distribusikan

Setelah keterampilan selesai, paketkan untuk distribusi:

python -m scripts.package_skill /path/to/api-tester

Ini membuat berkas .skill yang dapat diinstal oleh pengguna. Arahkan pengguna ke jalur berkas yang dihasilkan.

Instalasi

Pengguna menginstal keterampilan dengan menempatkan berkas .skill di direktori keterampilan mereka atau menggunakan perintah instal keterampilan Claude Code.

Kesalahan Umum dalam Pembuatan Keterampilan

Kesalahan 1: Deskripsi yang Tidak Jelas

Buruk:

description: Keterampilan untuk bekerja dengan API

Baik:

description: Cara menguji API REST secara sistematis. Gunakan saat pengguna menyebutkan pengujian API, titik akhir, REST, GraphQL, atau ingin memvalidasi respons API. Pastikan untuk menyarankan keterampilan ini kapan pun pengujian terlibat, bahkan jika mereka tidak secara eksplisit menyebutkan 'pengujian'.

Kesalahan 2: Instruksi Terlalu Membatasi

Buruk:

SELALU gunakan format ini. JANGAN PERNAH menyimpang. HARUS menyertakan bagian-bagian ini.

Baik:

Gunakan format ini karena memastikan pemangku kepentingan dapat dengan cepat menemukan informasi yang mereka butuhkan. Jika audiens Anda memiliki kebutuhan yang berbeda, sesuaikan struktur tersebut.

Kesalahan 3: Melewatkan Kasus Uji

Kasus uji menangkap masalah sebelum pengguna menemukannya. Bahkan untuk keterampilan subjektif, jalankan 2-3 contoh untuk memverifikasi kualitas keluaran.

Kesalahan 4: Mengabaikan Data Waktu

Keterampilan yang membutuhkan waktu 10x lebih lama tidak berkelanjutan. Tangkap data waktu dan optimalkan untuk efisiensi di samping kualitas.

Kesalahan 5: Tidak Menggabungkan Skrip Berulang

Jika setiap uji coba secara independen menulis generate_report.py, gabungkan dalam keterampilan. Menghemat waktu dan memastikan konsistensi.

Contoh Keterampilan Dunia Nyata

Keterampilan Pembangun MCP

Dibuat oleh Anthropic untuk membangun server MCP (Model Context Protocol).

Fitur utama:

Templat Python dan Node.js
Kerangka evaluasi untuk server MCP
Dokumen referensi praktik terbaik

Struktur:

mcp-builder/
├── SKILL.md
├── reference/
│   ├── mcp_best_practices.md
│   ├── python_mcp_server.md
│   └── node_mcp_server.md
└── evaluation/
    └── evaluation.md

Keterampilan Docx

Menghasilkan dokumen Word secara terprogram.

Fitur utama:

Skrip python-docx terpaket
Sistem templat untuk dokumen umum
Panduan gaya untuk pemformatan yang konsisten

Alur kerja:

Pahami persyaratan dokumen
Pilih atau buat templat
Hasilkan melalui skrip python-docx
Validasi struktur keluaran

Keterampilan Desain Frontend

Membangun antarmuka web dengan pola modern.

Fitur utama:

Pustaka komponen
Pola Tailwind CSS
Pemeriksaan aksesibilitas

Pengungkapan progresif: Alur kerja inti di SKILL.md, dokumen komponen di references/.

Menguji Keterampilan Anda dengan Apidog

Jika Anda membangun keterampilan terkait API, Apidog terintegrasi secara alami ke dalam alur kerja.

Contoh: Integrasi Keterampilan Pengujian API

## Menjalankan Uji API

Gunakan Apidog untuk pengujian sistematis:

1. Impor spesifikasi OpenAPI ke Apidog
2. Hasilkan kasus uji dari spesifikasi
3. Jalankan uji dan ekspor hasil sebagai JSON
4. Validasi respons terhadap skema yang diharapkan

Untuk pernyataan kustom, gunakan fitur skrip Apidog.

Paket Skrip Apidog

api-tester/
├── SKILL.md
└── scripts/
    ├── run-apidog-tests.py
    └── generate-report.py

Ini mencegah setiap pemanggilan di masa depan dari menciptakan kembali roda.

Kesimpulan

Keterampilan Kode Claude memperluas kapabilitas Claude untuk alur kerja spesifik Anda. Sistem Skill Creator menyediakan proses sistematis:

Tangkap tujuan - Definisikan apa yang harus dilakukan keterampilan
Susun SKILL.md - Tulis instruksi yang jelas dengan contoh
Buat kasus uji - Prompt realistis yang benar-benar akan dibuat pengguna
Jalankan evaluasi - Eksekusi paralel dengan dan tanpa keterampilan
Tinjau hasil - Umpan balik kualitatif + tolok ukur kuantitatif
Iterasi - Tingkatkan berdasarkan temuan
Optimalkan deskripsi - Maksimalkan akurasi pemicu
Paket - Distribusikan sebagai berkas .skill

tombol

FAQ

Berapa lama waktu yang dibutuhkan untuk membuat keterampilan?

Keterampilan sederhana membutuhkan 15-30 menit. Keterampilan kompleks dengan banyak berkas referensi dan skrip terpaket dapat memakan waktu 2-3 jam termasuk iterasi evaluasi.

Apakah saya perlu menulis kasus uji untuk setiap keterampilan?

Tidak. Keterampilan dengan keluaran yang dapat diverifikasi secara objektif (pembuatan kode, transformasi berkas, ekstraksi data) mendapat manfaat dari kasus uji. Keterampilan dengan keluaran subjektif (gaya penulisan, kualitas desain) lebih baik dievaluasi secara kualitatif.

Bagaimana jika keterampilan saya tidak dipicu secara andal?

Optimalkan bidang deskripsi. Sertakan frasa pemicu dan konteks spesifik. Buat sedikit "mendorong" - secara eksplisit nyatakan kapan harus menggunakan keterampilan. Jalankan siklus optimasi deskripsi dengan 20 kueri evaluasi.

Bagaimana cara saya berbagi keterampilan dengan tim saya?

Paketkan keterampilan dengan python -m scripts.package_skill <path>, lalu distribusikan berkas .skill. Anggota tim menempatkannya di direktori keterampilan mereka.

Bisakah keterampilan memanggil API eksternal?

Ya. Paketkan skrip yang membuat panggilan API. Instruksi keterampilan memberi tahu Claude kapan dan bagaimana menggunakannya. Simpan kunci API dalam variabel lingkungan, bukan dalam keterampilan itu sendiri.

Berapa batas ukuran berkas untuk keterampilan?

Tidak ada batas keras, tetapi pertahankan SKILL.md di bawah 500 baris. Pindahkan referensi rinci ke berkas terpisah. Skrip dan aset tidak dihitung terhadap batas baris karena dimuat sesuai permintaan.

Bagaimana cara saya memperbarui keterampilan yang sudah ada?

Salin keterampilan yang terinstal ke lokasi yang dapat ditulisi, edit di sana, dan paketkan ulang. Pertahankan nama asli - jangan menambahkan akhiran versi kecuali membuat varian yang berbeda.