bkit — Menggunakan Claude Code dengan “benar” lewat Context Engineering
Pada Desember 2025, saya meluncurkan layanan bernama bkamp.ai.
- 11 microservice
- Portal berbasis Next.js
- AWS EKS + GitOps (ArgoCD)
- Infrastruktur Terraform
Dan semua ini naik ke production hanya dalam 9 hari.
Pengembangnya hanya saya sendiri,
AI yang digunakan adalah Claude Code.
Tulisan ini bukan soal “membangun dengan cepat”
Banyak contoh pengembangan dengan AI dijelaskan seperti ini:
- “Dibuat dengan AI dalam N hari”
- “Cukup pandai menulis prompt”
Tapi yang benar-benar saya rasakan selama 9 hari pengembangan justru sangat berbeda.
Memang benar AI bisa menulis kode dengan baik.
Tetapi AI tidak memutuskan apa yang harus ditulis.
Yang pada akhirnya menentukan itu adalah:
- desain
- aturan
- unit kerja
- metode validasi
Inilah yang saya definisikan sebagai Context Engineering.
Apa itu Context Engineering
Sederhananya:
Bukan menulis prompt dengan baik,
melainkan merancang lingkungan kerja AI itu sendiri
Misalnya:
- membuat dokumen desain terlebih dahulu
- membagi unit kerja berdasarkan dokumen
- membuat aturan untuk memvalidasi hasil
- membuat siklus yang bisa diulang
Dengan kata lain,
AI bukan lagi “penulis”,
melainkan mesin yang merender konteks yang telah ditentukan
Cara yang benar-benar saya lakukan di bkamp
1. Day 0 — Membuat aturan sebelum menulis kode
Commit pertama tidak berisi kode.
Sebagai gantinya, saya membuat:
.claude/CLAUDE.md(sekitar 150 baris)- dokumen kebutuhan
- dokumen strategi
Di dalamnya didefinisikan hal-hal berikut:
- siklus PDCA (Plan → Do → Check → Act)
- semua hasil divalidasi oleh manusia
- perencanaan dalam bahasa Korea, kode dalam bahasa Inggris, commit dalam bahasa Korea
- unit kerja dan cara progresnya
Sekitar 100 baris aturan ini kemudian menentukan seluruh pengembangan setelahnya.
2. Unit kerja bukan “fitur”, melainkan “dokumen”
Biasanya permintaan diberikan seperti ini:
- “Buatkan fitur chat”
Tetapi dalam praktiknya saya bekerja seperti ini:
- “Implementasikan bagian 3.2 dari dokumen 7”
Perbedaannya sangat besar.
Dari sudut pandang AI:
- fitur → perlu interpretasi (ketidakpastian)
- dokumen → tinggal diimplementasikan apa adanya (deterministik)
Hasilnya:
Variabilitas output hampir hilang sama sekali
3. Satu hari = satu siklus PDCA
Pengembangan berjalan seperti ini:
- Plan (desain)
- Do (implementasi)
- Check (analisis gap)
- Act (perbaikan)
Lalu siklus ini diulang per hari.
Keunggulan pendekatan ini:
- konteks selalu terjaga sebagai versi terbaru
- cakupan kerja jelas
- AI menjadi jelas soal “apa yang harus dilakukan sekarang”
4. Buat checkpoint lalu rombak tanpa ragu
Pada hari ke-4, saya merombak total frontend.
Tetapi ada satu hal yang selalu dilakukan sebelumnya:
- membuat checkpoint yang bisa di-rollback
Dengan begitu:
Sekalipun gagal tetap aman
→ perubahan struktur besar bisa dilakukan dengan berani
5. Infrastruktur ditempelkan sekaligus di tahap akhir
Pada hari ke-8, selama satu hari penuh:
- Terraform
- Kubernetes
- CI/CD
- ArgoCD
semuanya dipasang sekaligus.
Alasan hal ini bisa dilakukan sederhana:
Karena sebelumnya seluruh strukturnya sudah selaras
Pola inti yang saya dapatkan dari sini
Pola yang berulang selama 9 hari ini adalah sebagai berikut:
- definisikan aturan terlebih dahulu
- buat desain terlebih dahulu
- kerjakan berdasarkan dokumen
- ulangi dengan siklus PDCA
- buat checkpoint
- selesaikan ketidaksesuaian di dokumen
- kode ada di tahap terakhir
Tapi apakah ini bisa terus dipertahankan?
Di sinilah muncul masalah.
Pendekatan ini memang kuat, tetapi:
Terlalu berat jika manusia harus terus menjaganya sendiri
- aturan harus terus diingat
- dokumen harus terus diselaraskan
- PDCA harus dipatuhi setiap saat
Karena itulah saya membuat bkit.
Apa itu bkit
bkit adalah plugin Claude Code.
Tetapi ini bukan sekadar alat biasa.
Cara kerja yang digunakan di bkamp
dibuat ulang apa adanya menjadi sebuah sistem
Konsep terpenting: PDCA = state machine
Di bkit, PDCA diimplementasikan seperti ini:
- state: plan, design, do, check, act, dan seterusnya
- transisi: aturan perpindahan antar-state
- guard: pemeriksaan kondisi
Misalnya:
- tingkat kesesuaian antara desain dan implementasi 90% atau lebih → lolos
- jika tidak → loop perbaikan dijalankan otomatis
Artinya,
“review → perbaikan” akan berulang secara otomatis
Struktur yang menjadikan Context Engineering sebagai sistem
bkit terdiri dari elemen-elemen berikut:
- Skills (pengetahuan domain)
- Agents (perilaku berbasis peran)
- PDCA state machine
- sistem injeksi context
- Quality Gate (validasi)
- Audit Log (pencatatan)
- Feedback Loop (pengulangan otomatis)
Jika diringkas dalam satu kalimat:
Bukan sekadar menggunakan AI,
melainkan membangun sistem tempat AI bekerja
Hasil
Hasil yang didapat dengan pendekatan ini adalah sebagai berikut:
- kompatibel terus-menerus dengan 79 versi Claude Code
- 4.000+ test, 0 kegagalan
- 200+ aturan validasi CI
- sinkronisasi penuh antara docs dan code
Kesimpulan
Ini bukan cerita tentang AI yang menjadi lebih pintar.
Ini adalah cerita tentang pekerjaan manusia yang dimajukan ke tahap awal
- desain lebih dulu
- aturan lebih dulu
- validasi lebih dulu
Setelah itu:
- AI mengeksekusi
- sistem memvalidasi
- manusia menyetujui
TL;DR
- Hanya mengandalkan prompt ada batasnya
- Context Engineering adalah inti
- AI bukan penulis, melainkan renderer
- workflow lebih penting daripada model
Link
- bkit: https://github.com/popup-studio-ai/bkit-claude-code
- studi kasus: https://bkamp.ai
Saya benar-benar menyambut opini atau feedback apa pun tentang pendekatan ini.
Belum ada komentar.