Selama beberapa dekade, hubungan kita dengan komputer punya bentuk yang tetap: kita mengetik perintah atau kode, komputer menjalankannya persis huruf demi huruf. Kita yang berpikir, ia yang menuruti. Editor teks, autocomplete, bahkan penyaran kode generasi awal tidak mengubah pembagian peran itu — mereka mempercepat pengetikan, bukan menggantikan proses berpikir dan bertindak. Anda tetap sopir yang memegang setiap detail kemudi.

Claude Code menandai pergeseran itu. Ia bukan sekadar melengkapi baris kode yang sedang Anda tulis; ia membaca berkas Anda, memahami struktur proyek, menyusun rencana, mengedit banyak berkas sekaligus, menjalankan perintah di terminal, membaca hasilnya, dan memperbaiki dirinya sendiri bila ada yang gagal — semuanya dari dalam jendela terminal yang sudah Anda kenal. Peran Anda naik satu tingkat: dari pengetik menjadi pengarah. Anda menyatakan maksud, meninjau rencana, menyetujui atau menolak tindakan, dan menjaga mutu. Mesin mengurus mekanika.

Pergeseran ini menakjubkan sekaligus menuntut. Menakjubkan karena hal yang dulu memakan sore penuh — memindai puluhan berkas mencari sebuah bug, menulis serangkaian tes, melakukan refaktor yang membosankan — kini bisa selesai dalam menit. Menuntut karena alat yang bisa mengubah berkas dan menjalankan perintah adalah alat yang, bila disalahpahami, bisa menghapus pekerjaan Anda atau menjalankan sesuatu yang tak Anda inginkan. Karena itu buku ini menaruh porsi besar pada izin, mode, dan keamanan, bukan sekadar daftar fitur berkilau.

Buku ini ditulis untuk semua level. Bila Anda baru pertama kali mendengar istilah "agentic coding", bab-bab awal menuntun Anda dari nol: apa itu, cara memasang, sesi pertama. Bila Anda sudah memakainya sehari-hari, bab-bab tengah dan akhir menggali skills, subagents, hooks, MCP, dan alur kerja profesional yang jarang dibahas tuntas. Dan karena buku ini juga dirancang agar bisa dibaca oleh AI, ada satu bab khusus — "Cara Dibaca AI" — yang menjelaskan strukturnya bagi mesin yang mungkin ikut menelaahnya.

Selamat datang. Mari kita ubah cara Anda bekerja dengan kode.

— Galih Prasetyo, 2026

Buku ini padat karena dirancang sebagai panduan sekaligus rujukan. Anda tidak wajib membacanya berurutan dari awal ke akhir, meski pemula sangat disarankan melakukannya untuk lima bab pertama.

Peta buku

• Fondasi (Bab 1–4): apa itu Claude Code, memasangnya, sesi pertama, dan CLAUDE.md sebagai memori proyek. Wajib bagi pemula.
• Kendali (Bab 5–9): slash commands, izin & mode, skills & subagents, hooks, dan MCP. Inilah tempat Anda berubah dari pengguna biasa menjadi pengguna mahir.
• Praktik (Bab 10–13): alur kerja nyata end-to-end, seni menyusun prompt, tips & batasan & biaya, dan perbandingan jujur dengan alat lain.
• Penutup (Bab 14–15): bab khusus "Cara Dibaca AI", lalu FAQ, glosarium, dan checklist.

Konvensi visual

Beberapa elemen berulang sepanjang buku:

• Screenshot terminal — jendela hitam bertitik tiga yang menampilkan sesi Claude Code (perintah, output, diff, penggunaan tool). Ini pengganti tangkapan layar foto agar tetap tajam di cetakan maupun layar.
• Kotak catatan — kuning untuk "verifikasi ke dokumentasi resmi", hijau untuk tip, merah untuk peringatan.
• Penjelajah interaktif di Bab 5 — pilih fitur/slash command dan lihat penjelasan plus contohnya langsung di halaman.
• Cheatsheet klik-salin — perintah yang bisa Anda salin ke clipboard dengan satu klik.

Contoh anatomi sebuah screenshot terminal yang akan sering Anda jumpai:

Menandai tingkat

Setiap bab dapat dibaca berdiri sendiri, tetapi bila sebuah bab mengandalkan konsep dari bab lain, kami sebutkan secara eksplisit. Bila Anda hanya ingin cepat produktif, baca Bab 1, 2, 3, dan 5 lalu langsung ke Bab 10.

Claude Code adalah alat baris perintah (command-line tool) buatan Anthropic yang menempatkan model Claude langsung di dalam terminal Anda, dengan kemampuan membaca dan menulis berkas serta menjalankan perintah di proyek Anda. Alih-alih menyalin-tempel kode bolak-balik antara editor dan sebuah kotak obrolan, Anda memberi Claude Code sebuah maksud — "perbaiki bug ini", "tambahkan endpoint", "refaktor modul ini" — dan ia mengerjakannya di tempat.

Kata kuncinya adalah agentic. Sebuah "agen" di sini berarti model yang tidak hanya menghasilkan teks jawaban, melainkan bertindak dalam sebuah lingkaran (loop): ia memutuskan langkah, memakai tool untuk melakukannya, mengamati hasilnya, lalu memutuskan langkah berikutnya — berulang sampai tugas selesai. Tool di sini nyata: membaca berkas, mengedit berkas, menjalankan shell, mencari di seluruh repositori, memanggil server eksternal. Itulah yang membedakannya dari sekadar chatbot yang pintar.

Agentic Coding: Loop, Bukan Balasan

Untuk memahami mengapa Claude Code terasa berbeda, bayangkan tiga generasi bantuan menulis kode:

Pada generasi ketiga, siklus "menyalin kode → tempel ke editor → jalankan → baca error → kembali bertanya" runtuh menjadi satu percakapan. Claude Code melihat error itu sendiri karena ia yang menjalankan perintahnya, dan ia bisa langsung mencoba perbaikan. Inilah "loop" yang membuatnya terasa seperti rekan kerja, bukan mesin jawab.

Perhatikan loop itu bekerja pada perbaikan bug nyata: Claude menjalankan tes, melihat kegagalan, membaca berkas, memperbaiki, lalu menjalankan tes lagi — tanpa Anda menjadi kurir di antara langkah-langkah itu.

Kenapa Claude Code Berbeda

Ada beberapa keputusan desain yang membuat Claude Code khas:

Ia hidup di terminal

Terminal bukan pilihan nostalgia. Terminal adalah tempat semua alat pengembang bertemu: git, npm, docker, pengujian, linter, skrip build. Dengan berdiam di terminal, Claude Code otomatis punya akses ke seluruh perkakas itu tanpa integrasi khusus. Ia bisa menjalankan git diff, npm test, atau docker compose up semudah Anda mengetiknya. Ia juga tidak terkurung pada satu editor — bekerja sama baik entah Anda pemakai VS Code, Neovim, JetBrains, atau tanpa editor sama sekali.

Ia memakai model frontier

Claude Code dijalankan oleh model keluarga Claude (Opus, Sonnet, Haiku), yang memang dirancang kuat untuk penalaran kode dan penggunaan tool. Anda bisa berganti model sesuai kebutuhan: model paling cerdas untuk tugas rumit, model lebih cepat/murah untuk tugas ringan.

Kendali tetap di tangan Anda

Secara bawaan, Claude Code meminta izin sebelum tindakan yang berdampak — mengedit berkas, menjalankan perintah shell. Anda melihat persis apa yang akan dilakukan dan menyetujuinya. Model perizinan ini (dibahas tuntas di Bab 6) adalah alasan alat sekuat ini tetap aman dipakai sehari-hari.

Ia pengganda, bukan pengganti

Penting menetapkan harapan sejak awal. Claude Code bukan mesin yang menggantikan keputusan Anda. Ia mempercepat mekanika — mengetik, mencari, menjalankan, mencoba lagi — sementara bagian yang benar-benar bernilai tetap milik Anda: menentukan apa yang layak dibangun, menilai apakah solusinya benar, dan menjaga agar sistem tetap sehat. Insinyur yang paling diuntungkan bukan yang menyerahkan penilaian, melainkan yang mengarahkan dengan penilaian yang tajam.

"Claude Code is intentionally low-level and unopinionated, providing close to raw model access without forcing specific workflows."

— Anthropic, Claude Code best practices (engineering blog)

Ia dapat dikomposisi

Karena berupa alat baris perintah, Claude Code bisa dipakai secara interaktif (Anda mengobrol dengannya) maupun secara headless di dalam skrip dan pipeline CI. Ia bisa menerima prompt lewat argumen, membaca dari pipe, dan mengeluarkan hasil yang bisa diproses program lain. Ini menjadikannya blok bangunan, bukan aplikasi tertutup.

Anatomi Sebuah Sesi

Ketika Anda mengetik claude di sebuah folder proyek dan menekan Enter, sebuah sesi interaktif dimulai. Sesi ini punya konteks: daftar berkas yang sudah dibaca, percakapan sejauh ini, dan memori proyek dari CLAUDE.md. Di dalam sesi, Anda mengetik maksud dalam bahasa biasa, menyisipkan berkas dengan @, menjalankan perintah cepat dengan /, atau menyelipkan perintah bash dengan !. Screenshot berikut menunjukkan pembukaan sesi yang khas.

Perhatikan bahwa Claude Code menjawab bukan dari tebakan, melainkan setelah membaca berkas nyata di proyek. Kemampuan menavigasi kode inilah fondasi semua yang akan kita bahas. Di bab berikutnya kita pasang alatnya dan masuk ke sesi pertama Anda sendiri.

Satu hal yang perlu ditegaskan sejak awal: sesi Claude Code bukan kotak hitam. Setiap tool yang ia pakai — setiap pembacaan berkas, setiap edit, setiap perintah shell — tampil di layar dengan jelas, dan tindakan yang berdampak menunggu persetujuan Anda. Anda tak pernah kehilangan jejak apa yang sedang terjadi; transparansi inilah yang membuat alat sekuat ini tetap layak dipercaya untuk pekerjaan sehari-hari.

Memasang Claude Code adalah urusan beberapa menit. Bagian ini menuntun Anda dari nol: memastikan sistem siap, memasang alatnya, masuk ke akun, dan menjalankan sesi pertama untuk memastikan semuanya bekerja.

Syarat Sistem

Claude Code berjalan di macOS, Linux, dan Windows. Kebutuhan intinya sederhana:

• Node.js versi LTS yang masih didukung (umumnya Node 18 ke atas). Metode instalasi lewat npm membutuhkan Node dan npm terpasang.
• Terminal apa pun: Terminal/iTerm di macOS, terminal Linux, atau Windows Terminal / PowerShell. Di Windows, dukungan juga tersedia melalui WSL bila Anda memakainya.
• Koneksi internet, karena inferensi model berjalan di server Anthropic.
• Akun: langganan Claude (Pro atau Max) untuk penagihan berbasis langganan, atau akun Anthropic Console dengan kredit API untuk penagihan pay-as-you-go.

Langkah Instalasi

Cara paling umum adalah melalui npm sebagai paket global:

npm install -g @anthropic-ai/claude-code

Setelah selesai, perintah claude tersedia di terminal Anda. Verifikasi dengan:

claude --version
claude --help

Selain npm, Anthropic juga menyediakan skrip pemasang natif (installer) untuk sebagian platform yang tidak mengharuskan Node terpasang lebih dulu. Cara ini berguna bila Anda tidak ingin mengelola instalasi Node global.

Kedua cara sama-sama sah; pilih sesuai kondisi Anda.

Screenshot berikut menunjukkan proses pemasangan lewat npm dan pemeriksaan cepat sesudahnya.

Perintah claude doctor (atau /doctor di dalam sesi) memeriksa kesehatan instalasi Anda dan sering menjadi langkah pertama saat menelusuri masalah.

Login & Akun

Jalankan claude untuk pertama kali, dan Anda akan diminta masuk. Ada dua jalur utama:

• Langganan Claude (Pro / Max): Anda masuk dengan akun Claude Anda. Pemakaian Claude Code dihitung terhadap kuota langganan. Cocok bila Anda sudah berlangganan dan ingin biaya tetap yang bisa diprediksi.
• API Anthropic Console: Anda memakai kredit/penagihan API. Pemakaian dihitung per token. Cocok untuk tim, otomasi, atau pemakaian yang perlu penagihan terpisah.

Perintah /login memulai proses masuk (biasanya membuka browser untuk otorisasi), dan /logout mengakhirinya. Setelah masuk, kredensial disimpan aman di mesin Anda sehingga Anda tidak perlu masuk setiap kali.

Untuk lingkungan tanpa interaksi (CI, container), setel kunci lewat variabel lingkungan alih-alih login interaktif:

Update, Konfigurasi Awal, & Uninstall

Bila Anda memasang lewat npm, memperbarui semudah:

npm update -g @anthropic-ai/claude-code

Claude Code juga dapat memberi tahu Anda saat versi baru tersedia. Untuk mencopot, gunakan npm uninstall -g @anthropic-ai/claude-code.

Beberapa penyiapan awal yang berguna:

• /config — membuka pengaturan (mis. tema, model default, perilaku editor).
• /terminal-setup — mengatur integrasi terminal seperti kombinasi tombol untuk baris baru (Shift+Enter) pada terminal tertentu.
• /status — menampilkan status akun, model aktif, dan direktori kerja.

Menelusuri masalah instalasi

Bila ada yang tak beres, langkah pertama hampir selalu claude doctor. Tabel berikut merangkum gejala umum dan arah perbaikannya.

"The best way to learn Claude Code is to use it on your own codebase — start small, watch what it does, and grow your trust from there."

— Prinsip yang berulang dalam panduan resmi Anthropic

Dengan alat terpasang dan akun tersambung, Anda siap masuk ke sesi pertama yang sesungguhnya — bukan sekadar mengecek versi, melainkan meminta Claude Code melakukan pekerjaan nyata. Itu isi bab berikutnya.

Mari lakukan sesuatu yang nyata. Di bab ini Anda akan menjalankan sesi pertama dari awal sampai akhir: memberi maksud, melihat rencana, menyetujui perubahan, menjalankan tes, dan mengakhiri sesi. Pola yang Anda pelajari di sini berlaku untuk hampir semua pekerjaan sesudahnya.

Alur Dasar: Prompt → Rencana → Edit → Jalankan

Buka terminal, masuk ke folder proyek Anda, lalu ketik claude. Di dalam sesi, alur kerja umumnya bergerak melalui empat fase yang sama:

1. Prompt — Anda menyatakan maksud dalam bahasa biasa. Semakin jelas hasil yang diinginkan dan batasannya, semakin baik.
2. Rencana — Claude Code menjelaskan apa yang akan dilakukannya: berkas mana yang disentuh, langkah apa yang diambil. Untuk tugas besar, Anda bisa memaksanya merencanakan dulu tanpa mengeksekusi (Plan Mode, Bab 6).
3. Edit — Ia mengusulkan perubahan berkas sebagai diff. Anda meninjau dan menyetujui (atau menolak/mengoreksi).
4. Jalankan — Ia menjalankan perintah (tes, build, linter), membaca hasilnya, dan memperbaiki bila perlu.

Contoh Sesi Nyata dari Awal ke Akhir

Misalkan proyek kita adalah aplikasi Express, dan kita ingin menambahkan validasi ke endpoint pendaftaran. Berikut sesi lengkapnya, ditampilkan sebagai rangkaian screenshot terminal.

Langkah 1 — memberi maksud. Kita sebutkan berkas dengan @ agar Claude langsung tahu titik masuknya.

Langkah 2 — meninjau diff. Setelah kita setujui, Claude menampilkan perubahan sebagai diff dan meminta izin menulis.

Langkah 3 — menjalankan tes. Claude menulis tes, menjalankannya, membaca hasil, dan mengonfirmasi hijau.

Menyebut berkas dengan @ bukan sekadar kenyamanan — ia adalah cara Anda mengarahkan perhatian. Anda bisa menyebut satu berkas (@src/app.ts), sebuah folder (@src/routes/), atau beberapa sekaligus. Konteks yang Anda arahkan sendiri hampir selalu lebih tepat dan lebih murah daripada membiarkan Claude membaca banyak berkas untuk mencari titik masuknya.

Mengelola Konteks Sesi

Selama sesi berjalan, "konteks" (percakapan + berkas yang dibaca) makin panjang. Ada beberapa perintah untuk mengelolanya, yang akan kita dalami di Bab 5:

• /clear — mengosongkan konteks dan memulai bersih. Pakai saat berpindah ke tugas yang sama sekali berbeda.
• /compact — meringkas percakapan panjang menjadi ringkasan padat agar hemat token tapi tetap ingat inti.
• Esc — menyela Claude di tengah tindakan. Menekan Esc dua kali memungkinkan Anda mundur dan menyunting pesan sebelumnya.

Pintasan Keyboard yang Wajib Dikuasai

Kecepatan di terminal datang dari jari, bukan menu. Beberapa pintasan berikut cepat menjadi refleks. Sebagian bergantung pada terminal dan platform Anda; jalankan /terminal-setup bila kombinasi tertentu belum aktif.

Anda kini sudah melihat lingkaran penuh: maksud, rencana, edit, jalankan, selesai. Tetapi sesi yang benar-benar produktif butuh satu hal lagi — memori proyek yang menjelaskan konvensi dan konteks Anda kepada Claude. Itulah CLAUDE.md, bintang bab berikutnya.

Bayangkan seorang rekan baru yang sangat cakap tetapi belum tahu konvensi tim Anda: bagaimana Anda menamai berkas, framework apa yang dipakai, perintah apa untuk menjalankan tes, apa yang boleh dan tak boleh disentuh. Anda tidak ingin menjelaskan semua itu setiap pagi. CLAUDE.md adalah tempat Anda menuliskannya sekali, dan Claude Code membacanya otomatis setiap sesi.

Apa Itu CLAUDE.md

CLAUDE.md adalah berkas teks biasa (format Markdown) yang berisi memori proyek: petunjuk, konvensi, dan konteks yang ingin Anda sampaikan ke Claude Code untuk proyek ini. Saat sesi dimulai, isinya otomatis dimuat ke konteks sehingga Claude "mengingat" hal-hal itu tanpa Anda ulang-ulang.

Ini bukan berkas ajaib berformat khusus — ia hanya Markdown. Kekuatannya justru pada kesederhanaannya: Anda bisa menyuntingnya seperti dokumen apa pun, memasukkannya ke version control, dan meninjaunya bersama tim seperti kode lain.

Efeknya terlihat langsung. Dengan CLAUDE.md yang menyebut "pakai pnpm, bukan npm", Claude tak lagi menebak — ia memakai perintah yang benar sejak awal.

Perintah /init

Cara termudah membuat CLAUDE.md adalah membiarkan Claude Code menuliskannya untuk Anda. Di dalam sesi, jalankan /init. Claude akan memindai proyek — bahasa, framework, skrip di package.json, struktur folder — lalu menyusun draf CLAUDE.md yang menggambarkan proyek Anda.

Draf ini titik awal, bukan titik akhir. Bacalah dan sesuaikan: tambahkan hal yang hanya Anda dan tim tahu (misalnya "jangan pernah menyentuh folder legacy/", atau "selalu pakai pnpm, bukan npm").

Apa yang Sebaiknya Ditulis

CLAUDE.md yang baik singkat, konkret, dan bebas basa-basi. Beberapa isi yang paling berguna:

• Perintah penting — cara menjalankan dev server, tes, lint, build. Ini menghemat Claude dari menebak.
• Stack & versi — bahasa, framework, manajer paket. Cegah ia memakai pustaka yang tak Anda pakai.
• Konvensi kode — gaya penamaan, pola folder, aturan impor, format commit.
• Pantangan — folder atau berkas yang tak boleh diubah, perintah berbahaya yang tak boleh dijalankan.
• Konteks domain — istilah bisnis, singkatan internal, keputusan arsitektur yang tak terlihat dari kode.

# CLAUDE.md

## Perintah
- Dev:   pnpm dev
- Tes:   pnpm test
- Lint:  pnpm lint --fix
- Build: pnpm build

## Stack
- TypeScript strict, React 18, Vite, Tailwind
- Manajer paket: pnpm (JANGAN pakai npm/yarn)

## Konvensi
- Komponen: PascalCase di src/components/
- Selalu tulis tes untuk logika baru (Vitest)
- Pesan commit: Conventional Commits (feat:, fix:, ...)

## Pantangan
- Jangan ubah apa pun di folder legacy/
- Jangan jalankan migrasi database tanpa diminta

Menambah memori di tengah kerja semudah mengetik #. Claude menawarkan menyimpannya ke CLAUDE.md, sehingga pelajaran dari satu sesi terbawa ke sesi berikutnya.

Hierarki Memori

CLAUDE.md tidak hanya satu. Ada beberapa lapis yang digabungkan, dari yang paling umum ke paling spesifik:

Anda juga dapat menyisipkan berkas lain memakai sintaks impor @path/ke/berkas.md di dalam CLAUDE.md, sehingga dokumen panjang bisa dipecah rapi. Perintah /memory membuka dan menyunting berkas memori yang aktif.

Contoh CLAUDE.local.md untuk catatan pribadi yang tak ingin Anda bagikan ke tim:

# CLAUDE.local.md (masuk .gitignore)

- Database dev lokal saya: postgres://localhost:5433/toko
- Saya pakai iTerm + tema gelap; ringkas saja outputnya
- Fokus saya minggu ini: modul pembayaran

"A well-tuned CLAUDE.md is one of the highest-leverage things you can do — it turns a generic assistant into one that knows your project."

— Rangkuman praktik dari komunitas & dokumentasi Claude Code

Dengan memori proyek terpasang, sesi Anda jadi jauh lebih tajam. Kini saatnya menguasai perbendaharaan perintah yang membuat Anda gesit di dalam sesi: slash commands.

Di dalam sesi, mengetik garis miring / memunculkan menu perintah cepat — slash commands. Ini adalah tombol pintas Claude Code: mengosongkan konteks, meringkas percakapan, meninjau kode, mengatur agen, menyambung MCP, dan banyak lagi. Menguasai segelintir yang paling sering dipakai akan langsung melipatgandakan kecepatan Anda.

Slash Commands yang Paling Penting

Berikut perintah inti yang dipakai sehari-hari. Daftar lengkap selalu bisa Anda lihat dengan /help.

Tampilan /help memberi Anda daftar hidup di instalasi Anda — selalu jadikan ia sumber kebenaran, bukan tabel di buku mana pun.

Selain slash command, ada beberapa awalan khusus yang berguna di baris prompt:

• @ — menyebut berkas atau folder agar langsung masuk konteks (mis. @src/app.ts).
• ! — menjalankan perintah bash cepat tanpa keluar sesi (mode bash).
• # — menyimpan sepotong memori ke CLAUDE.md.
• Shift+Tab — mengganti permission mode (Bab 6).

Penjelajah Slash Command & Fitur

Alih-alih menghafal tabel, pakai penjelajah interaktif di bawah. Klik sebuah fitur atau perintah di panel kiri untuk melihat penjelasan dan contohnya. Cocok untuk menjelajah tanpa urutan.

Cheatsheet Klik-Salin

Perintah yang paling sering diketik, siap disalin ke clipboard dengan satu klik.

Bila Anda perlu kembali ke pekerjaan kemarin, /resume (atau menjalankan claude --continue saat membuka terminal) memulihkan percakapan sebelumnya lengkap dengan konteksnya.

Membuat slash command kustom

Anda bisa membuat perintah sendiri dengan menaruh berkas Markdown di .claude/commands/ (untuk proyek) atau ~/.claude/commands/ (global). Nama berkas menjadi nama perintah. Isi berkas adalah prompt yang akan dijalankan, dan Anda bisa menyisipkan argumen dengan penanda seperti $ARGUMENTS.

# .claude/commands/tulis-tes.md
Tulis pengujian unit menyeluruh untuk: $ARGUMENTS
Pakai framework tes yang sudah ada di proyek. Sertakan
kasus tepi (edge case) dan jalankan tesnya setelah ditulis.

Kini /tulis-tes src/utils/harga.ts menjalankan prompt itu dengan argumennya. Perintah kustom adalah cara ampuh mengabadikan alur kerja berulang tim Anda.

Alat yang bisa mengubah berkas dan menjalankan perintah adalah alat yang perlu pagar. Bab ini menjelaskan sistem izin Claude Code — cara Anda mengendalikan persis apa yang boleh dilakukannya, kapan ia bertanya, dan kapan ia bertindak otomatis. Menguasai bab ini adalah selisih antara memakai Claude Code dengan tenang dan memakainya dengan waswas.

Permission Modes

Claude Code beroperasi dalam salah satu mode izin. Mode menentukan seberapa banyak ia bertanya sebelum bertindak. Anda berpindah mode dengan menekan Shift+Tab berulang, dan mode aktif tampil di bilah bawah.

Allow, Deny, & Ask per Tool

Di luar mode global, Anda bisa mengatur izin per jenis tool secara halus. Ada tiga sikap:

• allow — tool ini boleh berjalan tanpa bertanya.
• ask — tanya dulu sebelum menjalankan (perilaku hati-hati bawaan).
• deny — tool/perintah ini dilarang total.

Aturan ini disimpan di settings.json (dibahas penuh di Bab 8) dan bisa dilihat/diubah lewat /permissions. Yang ampuh: aturan bisa spesifik. Anda dapat mengizinkan Bash(npm test) tetapi menolak Bash(rm -rf *), atau mengizinkan pembacaan berkas tetapi menolak penulisan ke direktori tertentu.

// .claude/settings.json (contoh — verifikasi format terbaru)
{
  "permissions": {
    "allow": [
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Read(./src/**)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Read(./.env)",
      "Write(./legacy/**)"
    ]
  }
}

Saat sebuah tindakan butuh persetujuan, Claude menampilkan prompt izin dengan pilihan yang jelas. Screenshot berikut memperlihatkan bentuknya untuk sebuah perintah shell.

Plan Mode: Berpikir Sebelum Bertindak

Plan mode layak sorotan tersendiri. Dalam mode ini, Claude Code tidak mengubah apa pun — ia hanya membaca, menganalisis, dan menyusun rencana untuk Anda tinjau. Ini ideal untuk tugas besar atau berisiko: refaktor lintas modul, perubahan skema, migrasi. Anda menyetujui rencananya lebih dulu, baru keluar dari plan mode untuk mengeksekusi.

Pola kerja yang sehat dengan plan mode adalah siklus dua langkah: rancang lalu jalankan. Anda masuk plan mode, mendorong Claude memikirkan pendekatan dan menyebut trade-off, lalu menyetujui rencana yang benar. Baru setelah itu Anda keluar dari plan mode agar eksekusi berjalan di atas fondasi yang sudah Anda setujui. Untuk perubahan yang menyentuh banyak berkas atau menyangkut data, langkah perencanaan ini kerap menghemat lebih banyak waktu daripada yang ia habiskan.

Prinsip Keamanan Praktis

Rangkuman kebiasaan aman yang membuat pemakaian Claude Code tetap tenang:

• Mulai dari default mode. Longgarkan hanya setelah Anda percaya pada tugas dan arah kerjanya.
• Pakai version control. Dengan git, perubahan apa pun dapat dibalik. Biasakan git status/git diff sebelum menerima banyak perubahan.
• Isolasi untuk mode agresif. Bila butuh bypass izin (mis. otomasi), jalankan di kontainer/VM sekali pakai tanpa akses produksi.
• Waspadai konten tak tepercaya. Bila Claude membaca data dari sumber luar (isu, halaman web, keluaran tool), perlakukan sebagai masukan yang mungkin berisi instruksi menyesatkan (prompt injection). Tetap tinjau tindakan yang berdampak.
• Tinjau perintah shell. Perhatikan perintah yang menghapus, memindahkan massal, atau menjangkau jaringan sebelum menyetujuinya.

"Permissions are the steering wheel. The model proposes; you decide what actually runs."

— Filosofi keamanan Claude Code

Dengan pemahaman izin yang kokoh, Anda siap melepas fitur yang lebih kuat — mendelegasikan pekerjaan ke skills dan subagents — tanpa kehilangan kendali.

Sejauh ini Claude Code bekerja sebagai satu agen serba-bisa. Dua fitur mengubahnya menjadi tim: Skills memberinya keahlian khusus yang bisa dipanggil saat relevan, dan Subagents memungkinkannya mendelegasikan tugas ke pekerja terpisah yang berjalan dengan konteksnya sendiri — bahkan paralel.

Skills (SKILL.md)

Sebuah Skill adalah paket instruksi (dan opsional skrip/berkas pendukung) yang mengajari Claude cara melakukan sesuatu yang spesifik: membuat diagram dengan gaya tertentu, mengikuti prosedur rilis tim Anda, memformat laporan, dan seterusnya. Skill disimpan sebagai folder berisi berkas SKILL.md.

Inti Skill adalah frontmatter yang menjelaskan nama dan kapan ia dipakai. Claude membaca deskripsi itu dan memanggil skill secara otomatis ketika tugas Anda cocok — Anda tidak perlu menyebutnya eksplisit.

---
name: buat-changelog
description: Menyusun CHANGELOG dari commit sejak tag terakhir,
  mengikuti format Keep a Changelog. Pakai saat user minta
  "buat changelog", "rangkum rilis", atau menyiapkan release notes.
---

# Cara membuat changelog
1. Ambil commit sejak tag terbaru: `git log ..HEAD`
2. Kelompokkan ke Added / Changed / Fixed / Removed
3. Tulis ke CHANGELOG.md di bagian paling atas
4. Gunakan bahasa yang jelas untuk pengguna akhir

Struktur foldernya sederhana:

.claude/skills/
  buat-changelog/
    SKILL.md          # instruksi + frontmatter
    template.md       # (opsional) berkas pendukung
    scripts/format.js # (opsional) skrip yang bisa dijalankan

Karena deskripsinya menentukan kapan skill muncul, tulislah deskripsi yang kaya pemicu: sebutkan frasa yang mungkin dipakai pengguna. Skill yang deskripsinya kabur jarang terpanggil.

Skill juga bisa membungkus prosedur tim yang rumit. Contoh kedua: prosedur rilis yang harus diikuti persis, lengkap dengan langkah verifikasi.

---
name: prosedur-rilis
description: Menjalankan prosedur rilis resmi tim. Pakai saat
  user minta "rilis versi", "deploy", atau "siapkan release".
  Wajib mengikuti urutan langkah tanpa melompat.
---

# Prosedur rilis (WAJIB berurutan)
1. Pastikan branch = main & bersih (`git status`)
2. Jalankan seluruh tes + typecheck; berhenti bila merah
3. Naikkan versi (semver) di package.json
4. Perbarui CHANGELOG.md (Skill buat-changelog)
5. Buat tag `vX.Y.Z` & dorong
6. JANGAN deploy ke produksi tanpa konfirmasi manusia

Perhatikan langkah keenam: skill boleh — bahkan sebaiknya — menuliskan pagar keputusan yang mengharuskan persetujuan manusia. Skill bukan hanya soal otomatisasi, tetapi juga mengabadikan disiplin tim ke dalam bentuk yang selalu diikuti.

Subagents: Delegasi & Paralel

Subagent adalah agen anak yang dijalankan oleh agen utama untuk menangani sebuah tugas, lalu mengembalikan hanya kesimpulannya. Ini memberi dua manfaat besar:

• Konteks bersih. Subagent bekerja di jendela konteksnya sendiri. Pencarian besar atau pembacaan puluhan berkas terjadi di sana, tidak membanjiri konteks utama Anda. Yang kembali hanya jawabannya.
• Paralelisme. Beberapa subagent bisa berjalan bersamaan untuk pekerjaan yang independen — misalnya menelusuri tiga bagian kode sekaligus.

Subagent didefinisikan mirip skill: berkas Markdown di .claude/agents/ dengan frontmatter yang menyebut nama, deskripsi (kapan dipakai), tool yang boleh dipakainya, dan opsional model. Anda mengelolanya lewat /agents.

---
name: penelusur-kode
description: Agen pencari read-only untuk sapuan luas di
  banyak berkas. Pakai saat perlu menemukan di mana sesuatu
  didefinisikan tanpa membebani konteks utama.
tools: Read, Grep, Glob
model: sonnet
---

Anda agen penelusur. Cari secara menyeluruh, laporkan
lokasi (path + baris) dan kesimpulan singkat. Jangan
mengubah berkas apa pun.

Berikut subagent bekerja: agen utama mendelegasikan penelusuran, subagent menjalankannya di konteks terpisah, dan hanya ringkasan yang kembali — konteks utama tetap bersih.

"Subagents let Claude stay focused: the messy exploration happens elsewhere, and only the answer comes back."

— Ringkasan pola kerja multi-agen Claude Code

Skills dan subagents memperluas apa yang Claude bisa lakukan. Bab berikutnya menambahkan kapan hal terjadi otomatis: hooks.

Skills dan subagents diputuskan oleh model. Hooks berbeda: ia dijalankan oleh harness Claude Code secara deterministik, apa pun keputusan model. Bila Anda ingin sesuatu terjadi setiap kali peristiwa tertentu muncul — memformat kode setiap sesudah edit, menjalankan linter sebelum commit, memblokir perintah berbahaya — itulah pekerjaan hook.

Konsep Hooks

Hook adalah perintah shell yang dijalankan otomatis pada titik-titik tertentu dalam siklus hidup sesi. Karena dijalankan oleh sistem (bukan model), hook adalah cara menegakkan aturan yang tidak boleh bergantung pada apakah model "ingat" untuk melakukannya. Beberapa titik peristiwa yang umum:

settings.json: Pusat Konfigurasi

Hooks, izin, variabel lingkungan, dan preferensi model semuanya tinggal di berkas settings.json. Sama seperti memori, ada beberapa lapis:

Struktur umum sebuah settings.json:

{
  "model": "sonnet",
  "permissions": {
    "allow": ["Bash(npm test)", "Bash(npm run lint)"],
    "deny": ["Bash(rm -rf *)"]
  },
  "env": { "NODE_ENV": "development" },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "command": "npx prettier --write \"$CLAUDE_FILE_PATHS\"" }
        ]
      }
    ]
  }
}

Ketika lapisan berbeda menyebut hal yang sama, yang lebih spesifik menang: pengaturan lokal proyek mengalahkan pengaturan proyek, yang mengalahkan pengaturan pengguna. Ini memungkinkan tim menetapkan kebijakan bersama di .claude/settings.json sambil setiap anggota tetap bisa menyesuaikan preferensinya di berkas lokal tanpa mengganggu yang lain.

Contoh Hook: Format Otomatis Setelah Edit

Skenario paling populer: setiap kali Claude mengedit berkas, jalankan formatter agar kode selalu rapi tanpa Anda memintanya. Screenshot berikut menunjukkan hook PostToolUse yang aktif setelah sebuah Edit.

Hook SessionStart juga sering dipakai untuk menyuntikkan konteks lingkungan begitu sesi dibuka — misalnya menuliskan cabang git aktif, status deploy terakhir, atau catatan "sedang di tengah migrasi" — sehingga Claude memulai dengan gambaran situasi terkini tanpa Anda menjelaskannya tiap kali.

Contoh lain yang berguna:

• PreToolUse guard — memeriksa perintah Bash dan menolak (kode keluar non-nol) bila cocok pola berbahaya, sehingga perintah itu tak pernah berjalan.
• Stop → notifikasi — memutar suara atau mengirim notifikasi desktop saat Claude selesai, berguna untuk tugas panjang.
• UserPromptSubmit → audit — menuliskan setiap prompt ke berkas log untuk kepatuhan/telusur.

Screenshot berikut menunjukkan hook PreToolUse yang menolak sebuah perintah berbahaya sebelum ia sempat berjalan — persis jenis pagar deterministik yang tak boleh bergantung pada ingatan model.

"Hooks turn 'please remember to do X' into 'X always happens'. That reliability is the whole point."

— Pola pemakaian hooks Claude Code

Hooks menyambungkan Claude ke perkakas lokal Anda. Bab berikutnya menyambungkannya ke dunia luar: MCP.

Claude Code hebat di dalam repositori Anda, tetapi pekerjaan nyata sering menjangkau ke luar: basis data, pelacak isu, dokumentasi, layanan cloud, sistem desain. MCP — Model Context Protocol — adalah standar terbuka yang menyambungkan Claude ke sumber data dan alat eksternal itu lewat "server" yang berbicara bahasa yang sama.

Konsep MCP

Bayangkan MCP seperti port USB untuk asisten AI. Alih-alih setiap alat butuh integrasi khusus, siapa pun bisa menulis server MCP yang mengekspos kemampuan (tools), data (resources), atau template prompt. Claude Code bertindak sebagai klien MCP yang bisa menyambung ke server-server itu dan memakai kemampuannya seolah tool bawaan.

Tiga hal yang bisa diekspos sebuah server MCP layak dibedakan: tools adalah aksi yang bisa dipanggil Claude (mis. menjalankan kueri, membuka isu); resources adalah data yang bisa dibaca (dokumen, baris tabel); dan prompts adalah templat siap pakai. Dalam praktik sehari-hari, tools adalah yang paling sering Anda rasakan — dan yang paling perlu diberi izin bijak karena bisa mengubah keadaan.

Karena MCP adalah standar terbuka, ekosistemnya luas: ada server untuk GitHub, basis data Postgres, Sentry, Puppeteer/browser, Google Drive, Slack, dan ratusan lainnya — dibuat oleh Anthropic maupun komunitas. Anda juga bisa menulis sendiri untuk sistem internal perusahaan Anda.

Memasang & Memakai Server MCP

Server MCP ditambahkan lewat perintah claude mcp add. Secara garis besar ada dua kelompok transport:

• stdio — server berjalan sebagai proses lokal dan berkomunikasi lewat input/output standar. Cocok untuk alat yang berjalan di mesin Anda (mis. akses filesystem, basis data lokal).
• jaringan (SSE / HTTP) — server adalah layanan jarak jauh yang dihubungi lewat jaringan. Cocok untuk layanan tim/cloud yang dibagikan banyak orang.

Konfigurasi proyek biasanya disimpan di berkas .mcp.json di akar repo agar bisa dibagikan ke tim, sementara server pribadi bisa ditambahkan hanya untuk Anda.

# Menambahkan server MCP lokal (stdio) — contoh, verifikasi sintaks terbaru
claude mcp add nama-server -- npx -y @contoh/mcp-server

# Menambahkan server jarak jauh (HTTP/SSE)
claude mcp add --transport sse dokumen https://contoh.com/mcp

# Melihat daftar server & statusnya
claude mcp list

Proses menambahkan server dan memverifikasinya tampak seperti ini:

Di dalam sesi, /mcp menampilkan server yang tersambung, status koneksinya, dan tool yang mereka sediakan. Setelah tersambung, Anda memakainya secara alami — cukup minta dalam bahasa biasa, dan Claude memilih tool MCP yang tepat.

Menulis Server MCP Sendiri

Karena MCP adalah protokol terbuka, Anda bisa membungkus sistem internal perusahaan — API pesanan, basis pengetahuan, alat deploy — menjadi server MCP dan memberi Claude akses terkontrol ke sana. Pola umumnya:

• Definisikan tools yang boleh dipanggil (mis. cari_pelanggan, status_deploy), lengkap dengan skema argumen yang jelas.
• Ekspos resources bila ada data yang perlu dibaca (dokumen, tabel).
• Batasi cakupan: beri hanya kemampuan yang perlu, dan gerbang aksi menulis di balik izin.
• Pakai SDK MCP resmi (tersedia untuk beberapa bahasa) agar tak perlu mengimplementasi protokol dari nol.

"MCP is the connective tissue: it lets one assistant reach every tool and data source through a single, open protocol."

— Deskripsi peran MCP dalam ekosistem Claude

Kini Anda punya seluruh perkakas: memori, perintah, izin, skills, subagents, hooks, dan MCP. Saatnya menyatukannya dalam alur kerja nyata dari awal sampai pull request.

Teori sudah cukup. Bab ini menyusuri pekerjaan nyata dari ujung ke ujung: membangun fitur, memperbaiki bug, meninjau diff, melakukan refaktor, menulis tes, membuat commit, dan membuka pull request. Setiap tahap ditampilkan sebagai screenshot terminal agar Anda tahu persis rupanya.

Membangun Sebuah Fitur

Kunci membangun fitur dengan baik adalah merencanakan dulu, mengeksekusi kemudian. Untuk fitur non-trivial, mulai di plan mode: minta pendekatan, tinjau, baru izinkan eksekusi. Contoh: menambahkan fitur "lupa password".

Memperbaiki Bug dari Laporan

Alur perbaikan bug yang efektif: berikan gejala, biarkan Claude mereproduksi, temukan akar masalah, perbaiki, lalu tulis tes regresi agar bug tak kembali.

Meninjau Diff & Refaktor

Sebelum menyerahkan pekerjaan, mintalah Claude meninjau perubahannya sendiri secara kritis — atau tinjau perubahan orang lain. /review dan permintaan lugas "tinjau diff ini" sama-sama bekerja. Untuk refaktor, sebutkan tujuan (keterbacaan, performa, menghapus duplikasi) agar arahnya jelas.

Meninjau pekerjaan orang lain sama mudahnya. Bila gh tersedia, Claude bisa menarik sebuah pull request dan menelaahnya berkas demi berkas.

Menulis Tes

Claude Code kuat menulis tes karena ia bisa menjalankan tesnya sendiri dan memperbaiki yang gagal. Praktik terbaik: minta tes untuk perilaku spesifik, bukan "tes semuanya" yang kabur. Sertakan kasus tepi.

> tulis tes untuk src/utils/harga.ts:
  - pembulatan ke 2 desimal
  - diskon 0% dan 100%
  - input negatif harus melempar error
  jalankan tesnya dan pastikan hijau

Karena Claude menjalankan tesnya sendiri, ia menutup lingkaran: menulis, menjalankan, membaca kegagalan, memperbaiki, mengulang — sampai hijau tanpa Anda bolak-balik.

Refaktor yang aman

Refaktor paling aman ketika ada tes sebagai jaring. Minta Claude memastikan tes hijau sebelum dan sesudah, sehingga perilaku terbukti tak berubah.

Commit & Membuka Pull Request

Ketika pekerjaan siap, Claude Code bisa menyusun pesan commit yang baik dari diff dan — bila gh (GitHub CLI) tersedia — membuka pull request lengkap dengan judul dan deskripsi. Anda tetap yang menyetujui.

Studi Mini: Satu Isu, Satu Sore

Untuk menyatukan semuanya, bayangkan alur nyata dari sebuah isu di pelacak sampai PR yang siap ditinjau. Perhatikan bagaimana fitur-fitur dari bab-bab sebelumnya berpadu:

1. Ambil konteks (MCP). "Ada isu #312 soal ekspor CSV yang rusak untuk data besar — baca detailnya." Claude menarik isu lewat server MCP GitHub.
2. Rencanakan (plan mode). Anda beralih ke plan mode dan meminta pendekatan. Claude membaca kode ekspor, menemukan bahwa seluruh data dimuat ke memori sekaligus, dan mengusulkan streaming.
3. Eksekusi berpagar (izin + hook). Anda setujui. Claude mengubah implementasi menjadi streaming; hook PostToolUse memformat berkas otomatis.
4. Buktikan (tes). Ia menambah tes untuk dataset besar, menjalankannya, memastikan hijau, dan mengukur bahwa penggunaan memori kini datar.
5. Kirim (git + gh). Ia membuat branch, commit dengan pesan yang jelas, dan membuka PR yang menautkan isu #312.
6. Tinjau (Anda). Anda membaca diff akhir, puas, dan meminta rekan menyetujui. Sore yang biasanya habis, selesai dalam sepersekiannya.

Tidak ada langkah tunggal yang ajaib. Keajaibannya adalah semuanya terjadi dalam satu percakapan yang mengalir, dengan Anda memegang kemudi di setiap belokan penting.

Alur Non-Interaktif (Headless & CI)

Tidak semua pekerjaan interaktif. Claude Code bisa dipanggil sekali-jalan lewat flag -p (print), membaca dari pipe, dan mengeluarkan hasil yang bisa diproses program lain. Ini menjadikannya blok bangunan otomasi: menjalankan tugas terjadwal, memproses berkas massal, atau melengkapi langkah dalam pipeline CI.

# Sekali-jalan, hasil ke stdout
claude -p "ringkas perubahan di git diff terakhir jadi 3 poin"

# Dari pipe
git diff | claude -p "tinjau diff ini, sebut risiko keamanan"

# Dalam skrip (pakai ANTHROPIC_API_KEY di lingkungan CI)
claude -p "perbarui CHANGELOG.md untuk rilis $VERSION"

"The magic isn't any single step — it's that plan, edit, test, and ship happen in one continuous conversation."

— Refleksi alur kerja end-to-end Claude Code

Kualitas keluaran Claude Code sangat ditentukan oleh kualitas masukan Anda. Kabar baiknya: menyusun prompt yang baik bukan seni gelap, melainkan segelintir kebiasaan yang bisa dipelajari. Bab ini merangkumnya, lalu memberi pustaka prompt siap-salin.

Prinsip Menyusun Prompt

• Nyatakan hasil, bukan langkah. "Buat endpoint yang mengembalikan 400 untuk input tak valid" lebih baik daripada mendikte tiap baris. Biarkan Claude menentukan caranya, Anda menilai hasilnya.
• Beri konteks yang tepat. Sebut berkas relevan dengan @. Konteks yang terarah mengalahkan prompt panjang yang kabur.
• Sertakan kriteria selesai. "…dan pastikan tes hijau", "…tanpa menambah dependensi baru". Kriteria membuat Claude tahu kapan berhenti.
• Pecah tugas besar. Untuk pekerjaan luas, minta rencana dulu (plan mode), setujui, baru eksekusi bertahap.
• Perbaiki secara iteratif. Bila hasil kurang tepat, jangan mulai ulang — koreksi arah: "bagus, tapi pindahkan validasi ke middleware".
• Jaga konteks tetap bersih. /clear antar tugas, /compact saat percakapan memanjang. Konteks yang fokus = jawaban yang fokus.
• Minta ia menjelaskan sebelum menyetujui. Bila ragu pada sebuah tindakan, tanya "kenapa begitu?" atau "apa risikonya?". Jawabannya sering mengungkap asumsi yang perlu dikoreksi.
• Tunjukkan contoh, bukan hanya aturan. Bila Anda punya pola yang diinginkan, tunjuk berkas yang sudah menerapkannya: "ikuti gaya @src/routes/users.js".

Perbandingan berikut menunjukkan bagaimana prompt yang samar berubah menjadi tajam dengan menambahkan konteks, kriteria selesai, dan batasan.

Pustaka Prompt Siap Salin

Templat berikut bisa Anda salin dan sesuaikan. Ganti bagian dalam kurung siku.

Resep Cepat Sehari-hari

Beberapa pola singkat yang sering menyelamatkan waktu. Masing-masing ditampilkan sebagai potongan sesi nyata.

Memahami repositori asing dalam semenit

Menjelaskan galat yang membingungkan

Menaikkan versi dependensi dengan aman

"Treat Claude like a fast, literal, tireless colleague: be clear about the goal, give it the context it needs, and check its work."

— Ringkasan prinsip prompting yang efektif

Dengan prompt yang tajam, Anda mengambil hasil terbaik dari alat ini. Bab berikut menyeimbangkannya dengan realitas: tips lanjutan, batasan yang jujur, dan biaya.

Buku yang jujur menyebut batas, bukan hanya kilau. Bab ini merangkum kebiasaan yang membuat Anda lebih produktif, menyampaikan batasan Claude Code secara terus terang, dan menjelaskan bagaimana biaya bekerja agar tak ada kejutan di tagihan.

Tips Produktivitas

• Satu tugas, satu konteks. /clear setiap ganti tugas menjaga fokus dan menekan biaya.
• Rencanakan hal besar. Plan mode untuk perubahan berisiko; eksekusi langsung untuk yang kecil.
• Pilih model sesuai tugas. Model tercerdas untuk penalaran berat; model cepat untuk tugas rutin. /model untuk berganti.
• Investasikan di CLAUDE.md. Setiap konvensi yang Anda tulis di sana adalah instruksi yang tak perlu diulang.
• Otomatiskan yang berulang lewat slash command kustom, skills, dan hooks.
• Pakai git sebagai jaring pengaman. Sering commit; bekerja di branch; tinjau diff sebelum menerima.
• Delegasikan penelusuran ke subagent agar konteks utama tetap ramping.
• Sela lebih awal. Bila Claude salah arah, tekan Esc dan koreksi — jangan biarkan ia menyelesaikan jalan yang keliru.

Batasan yang Perlu Diketahui

Claude Code kuat, tetapi bukan sihir. Menyadari batasnya membuat Anda memakainya dengan bijak.

• Bisa keliru dengan percaya diri. Model dapat menghasilkan kode yang tampak benar tetapi salah, atau "berhalusinasi" API yang tak ada. Selalu tinjau, selalu jalankan tes. Anda tetap penanggung jawab akhir.
• Jendela konteks terbatas. Ia tak bisa "melihat" seluruh codebase raksasa sekaligus. Berkas relevan perlu diarahkan; percakapan super panjang perlu /compact.
• Pengetahuan punya batas waktu. Untuk pustaka yang sangat baru atau internal, ia mengandalkan apa yang bisa dibaca di repo/dokumen Anda, bukan pengetahuan latihan yang mutakhir.
• Rentan prompt injection. Konten tak tepercaya (isu, halaman web, keluaran tool) bisa berisi instruksi menyesatkan. Pertahankan izin dan tinjauan.
• Butuh internet. Inferensi berjalan di server Anthropic; tanpa koneksi, ia tak bekerja.
• Tugas sangat besar butuh pemecahan. Refaktor lintas ratusan berkas lebih baik dipecah bertahap daripada dalam satu perintah raksasa.

Bagaimana Biaya Bekerja

Ada dua model penagihan utama, seperti disinggung di Bab 2:

Pada model API, biaya bergerak seiring jumlah token yang diproses. Faktor terbesar adalah ukuran konteks: percakapan panjang dan banyak berkas yang dibaca berulang menaikkan token. Karena itu /clear, /compact, subagent (konteks terpisah), dan pemilihan model yang tepat bukan sekadar soal kerapian — semuanya menghemat uang.

Pantau pemakaian dengan /cost di dalam sesi. Ini menampilkan token dan perkiraan biaya sesi berjalan, membantu Anda menyadari kapan konteks membengkak.

Kapan /clear vs /compact vs subagent

Tiga alat mengelola konteks, dan memilih yang tepat menghemat token sekaligus menjaga fokus:

Menghemat tanpa mengorbankan hasil

• Bersihkan konteks antar tugas; jangan biarkan satu sesi menumpuk seharian.
• Pakai model yang lebih ringan untuk tugas sederhana.
• Arahkan berkas relevan alih-alih membiarkan Claude membaca banyak berkas untuk mencari sendiri.
• Manfaatkan subagent untuk penelusuran besar agar tak membebani konteks utama.

Claude Code bukan satu-satunya pemain. Bab ini membandingkannya dengan alat populer lain secara jujur — bukan untuk menyatakan pemenang mutlak, melainkan membantu Anda memilih alat yang tepat untuk gaya kerja Anda. Alat terbaik adalah yang cocok dengan konteks Anda.

Lanskap Singkat

Alat bantu coding AI kira-kira jatuh ke tiga bentuk: ekstensi editor yang menyatu di IDE (mis. Cursor, Copilot), alat terminal agentic yang bekerja lewat CLI (Claude Code, dan padanan dari penyedia lain seperti Codex CLI), dan antarmuka chat/web. Ketiganya bisa saling melengkapi; banyak pengembang memakai lebih dari satu.

Perbedaan yang paling menentukan bukanlah "model siapa yang lebih pintar" — kualitas model berubah tiap beberapa bulan — melainkan bentuk alat dan seberapa cocok ia dengan cara Anda bekerja. Alat yang menyatu dengan terminal dan git akan terasa berbeda dari alat yang menyatu dengan editor, meski keduanya memakai model yang setara. Nilailah dari kecocokan alur, bukan hanya tolok ukur.

Tabel Perbandingan Jujur

Kapan Claude Code Bersinar

• Anda hidup di terminal dan ingin agen yang menyatu dengan git, tes, dan skrip Anda.
• Anda butuh kendali halus atas izin dan keamanan.
• Anda ingin mengabadikan alur kerja tim lewat skills, hooks, dan slash command kustom.
• Anda ingin menyambung banyak sumber data lewat MCP, atau memakainya secara headless di CI.
• Anda memakai beragam editor dan tak mau terkunci pada satu IDE.

Kapan Alat Lain Mungkin Lebih Pas

• Anda menginginkan pengalaman visual penuh di dalam satu editor dengan autocomplete inline yang mulus — sebuah editor-first seperti Cursor bisa terasa lebih nyaman.
• Anda sudah terikat erat pada ekosistem penyedia lain dan ingin penagihan/model yang seragam di situ.

Memakainya Berdampingan

Ini bukan pilihan "salah satu". Banyak pengembang menjalankan editor visual untuk pengetikan sehari-hari dan penjelajahan cepat, lalu berpaling ke Claude Code di terminal untuk pekerjaan agentic yang lebih berat: refaktor lintas berkas, alur git penuh, otomasi, dan integrasi MCP. Keduanya berbagi hal yang sama pentingnya — kebiasaan meninjau kritis dan menjaga keamanan. Anggaplah setiap alat sebagai perkakas berbeda di kotak yang sama, bukan agama yang harus dipilih.

"Pilih alat yang menghilang ke dalam alur kerja Anda, bukan yang memaksa Anda pindah ke alur kerjanya."

— Prinsip pemilihan perkakas yang berumur panjang

Apa pun pilihan Anda, keterampilan inti — menyusun maksud yang jelas, meninjau kritis, menjaga keamanan — bersifat lintas alat. Itulah investasi yang tak akan usang.

Buku ini punya dua jenis pembaca: manusia dan mesin. Bab ini ditujukan untuk yang kedua — sebuah asisten AI (termasuk Claude Code sendiri) yang mungkin diminta membaca, meringkas, atau menjawab pertanyaan berdasarkan dokumen ini. Bagian ini menjelaskan struktur dokumen dan cara mengekstrak isinya dengan tepat.

Ringkasan Terstruktur untuk Mesin

Dokumen ini adalah satu berkas HTML mandiri (self-contained) berbahasa Indonesia (lang="id") berjudul "Kuasai Claude Code — Panduan Lengkap Agentic Coding di Terminal", ditulis oleh Galih Prasetyo, tahun 2026. Isinya adalah panduan tentang Claude Code, alat baris perintah agentic coding buatan Anthropic.

• Topik utama: Claude Code — instalasi, sesi, CLAUDE.md, slash commands, permission modes, skills, subagents, hooks, settings.json, MCP, alur kerja nyata, prompting, biaya, dan perbandingan alat.
• Bahasa: Indonesia. Audiens: semua level, dari pemula hingga mahir.
• Sikap akurasi: klaim yang mudah usang (nama flag, versi, harga) ditandai eksplisit "verifikasi ke dokumentasi resmi Anthropic". Perlakukan penanda itu sebagai sinyal untuk tidak mengutip detail spesifik sebagai fakta tetap.

Peta Anchor

Setiap bab dan sub-bab memiliki id yang stabil. Untuk menautkan atau merujuk bagian tertentu, gunakan anchor berikut (tidak lengkap, hanya bab utama):

Petunjuk Ekstraksi yang Setia

Bila Anda sebuah AI yang meringkas atau menjawab dari dokumen ini, ikuti pedoman berikut agar setia pada maksud penulis:

1. Hormati penanda verifikasi. Di mana pun teks menyebut "verifikasi ke dokumentasi resmi", jangan menyajikan detail terkait (flag, versi, harga, nama field) sebagai fakta pasti. Sampaikan sebagai "menurut buku ini, per 2026, dan mungkin berubah".
2. Bedakan konsep dari perincian. Konsep fungsional (apa itu hook, apa itu MCP, cara kerja permission mode) relatif stabil dan boleh dinyatakan lugas. Perincian sintaks bisa usang.
3. Jangan mengarang perintah. Buku ini sengaja menghindari mengarang flag/perintah yang tak pasti. Bila ditanya perintah persis yang tak ada di sini, arahkan pengguna ke claude --help, /help, atau dokumentasi resmi.
4. Screenshot terminal bersifat ilustratif. Angka (token, waktu, jumlah tes) dalam mockup adalah contoh, bukan tolok ukur nyata.
5. Sitasi kutipan. Blok kutipan diberi atribusi ringkas; perlakukan sebagai parafrase/rangkuman prinsip, bukan kutipan verbatim resmi kecuali dinyatakan demikian.

Dengan struktur ini, baik pembaca manusia maupun mesin bisa menavigasi dokumen secara andal. Kita tutup buku di bab terakhir.

Kita telah menempuh perjalanan dari "apa itu agentic coding" sampai membuka pull request lengkap dari terminal. Yang tersisa adalah menutup dengan rapi: sebuah renungan singkat, jawaban atas pertanyaan yang paling sering muncul, glosarium istilah, dan checklist yang bisa Anda tempel di dekat meja.

Inti buku ini sederhana: peran Anda naik dari pengetik menjadi pengarah. Claude Code bukan pengganti keahlian Anda — ia pengganda. Nilai Anda sebagai insinyur justru makin penting: menentukan apa yang benar untuk dibangun, meninjau dengan kritis, menjaga keamanan, dan mengambil keputusan yang tak bisa didelegasikan. Alat ini mengurus mekanika; penilaian tetap milik Anda. Mulailah kecil pada codebase Anda sendiri, tumbuhkan kepercayaan dari sana, dan biarkan kebiasaan baik — konteks bersih, git sebagai jaring, izin yang bijak — menjadi refleks.

Pertanyaan yang Sering Diajukan

1. Apakah Claude Code menggantikan pekerjaan programmer?

Tidak. Ia menggeser fokus dari mengetik ke mengarahkan dan meninjau. Keputusan desain, penilaian mutu, dan tanggung jawab tetap di tangan manusia. Yang menguasainya justru menjadi lebih produktif, bukan tergantikan.

2. Apakah kode saya dikirim ke server?

Ya, inferensi berjalan di server Anthropic, jadi potongan berkas yang relevan dikirim sebagai konteks. Tinjau kebijakan data resmi Anthropic terkait retensi dan pelatihan, dan jangan pakai pada kode yang kebijakan organisasi Anda melarang keluar. Untuk kebutuhan enterprise, tersedia opsi dengan jaminan data berbeda — verifikasi ke dokumentasi resmi.

3. Perlu langganan atau bisa bayar per pakai?

Keduanya. Anda bisa memakai langganan Claude (Pro/Max) untuk biaya tetap, atau API Console untuk bayar per token. Lihat Bab 12.

4. Apakah bekerja di Windows?

Ya — di Windows secara native maupun lewat WSL, selain macOS dan Linux. Cek syarat terbaru di dokumentasi.

5. Bagaimana mencegahnya menjalankan perintah berbahaya?

Tetap di default mode (ia bertanya sebelum bertindak), susun daftar deny di settings.json, dan pertimbangkan hook PreToolUse untuk memblokir pola berbahaya. Lihat Bab 6 dan 8.

6. Apa beda skill dan subagent?

Skill memberi keahlian/instruksi yang dipanggil saat relevan dalam konteks yang sama. Subagent adalah pekerja terpisah dengan konteksnya sendiri untuk mendelegasikan tugas (bisa paralel). Lihat Bab 7.

7. Apa beda hook dan skill?

Hook dijalankan sistem secara deterministik pada peristiwa tertentu (selalu terjadi). Skill dipanggil model saat dianggap relevan (bergantung keputusan model). Untuk aturan yang tak boleh gagal, pakai hook.

8. Apa itu MCP secara singkat?

Protokol terbuka yang menyambungkan Claude ke alat/data eksternal (basis data, GitHub, dsb.) lewat server standar. Lihat Bab 9.

9. Bagaimana menekan biaya?

/clear antar tugas, /compact saat panjang, pakai model ringan untuk tugas ringan, arahkan berkas relevan, dan delegasikan penelusuran besar ke subagent. Pantau dengan /cost.

10. Bisakah dipakai tanpa interaksi (di CI)?

Bisa. Claude Code punya mode headless (mis. lewat flag -p) dan bisa memakai ANTHROPIC_API_KEY. Cocok untuk pipeline. Verifikasi flag terbaru dengan claude --help.

11. Apakah harus memakai VS Code?

Tidak. Claude Code agnostik editor dan hidup di terminal. Ada integrasi IDE opsional, tetapi tak wajib.

12. Bagaimana kalau ia salah arah di tengah jalan?

Tekan Esc untuk menyela, lalu koreksi. Esc dua kali memungkinkan menyunting pesan sebelumnya dan mengulang dari titik itu.

13. Apakah CLAUDE.md wajib?

Tidak wajib, tetapi sangat dianjurkan. Ia salah satu hal berdaya ungkit tertinggi untuk membuat jawaban lebih relevan dengan proyek Anda.

14. Bagaimana memperbarui Claude Code?

Bila via npm: npm update -g @anthropic-ai/claude-code. Installer natif punya mekanisme pembaruannya sendiri.

15. Apakah aman untuk repositori kerja saya?

Aman bila Anda memakai izin dengan bijak, bekerja di branch dengan git sebagai jaring pengaman, dan meninjau perubahan. Hindari mode bypass-izin di mesin dengan data penting.

16. Bagaimana kalau saya tak percaya sebuah server MCP?

Jangan pasang. Server MCP menjalankan kode dan sering memegang kredensial. Pasang hanya yang tepercaya, dan beri izin ask untuk aksi yang bisa menulis/menghapus.

17. Bisakah beberapa orang memakai Claude Code di repo yang sama?

Bisa. Konvensi (CLAUDE.md), izin, dan hook di .claude/settings.json di-commit dan dibagikan; preferensi pribadi tinggal di berkas lokal yang tak di-commit. Setiap orang menjalankan sesinya sendiri di mesinnya.

18. Apakah Claude Code mengingat sesi kemarin?

Setiap sesi baru mulai bersih, tetapi memori proyek (CLAUDE.md) selalu dimuat, dan Anda bisa melanjutkan percakapan sebelumnya dengan --continue atau /resume. Untuk pengetahuan permanen, tuliskan ke CLAUDE.md, bukan mengandalkan ingatan sesi.

19. Bagaimana kalau hasil edit merusak sesuatu yang tak terlihat?

Andalkan tes dan git. Minta Claude menjalankan tes setelah perubahan, bekerja di branch, dan tinjau git diff. Bila ada yang rusak, git restore/kembalikan branch memulihkan keadaan.

20. Apakah saya masih perlu paham kode yang dihasilkan?

Sangat perlu. Anda adalah peninjau dan penanggung jawab akhir. Memahami keluaran membuat Anda bisa menangkap kesalahan halus, membuat keputusan arsitektur, dan tak bergantung buta. Alat ini mempercepat, bukan menggantikan pemahaman.

Glosarium

• Agentic coding — pendekatan di mana model tidak hanya menjawab, tetapi bertindak dalam lingkaran (rencana → pakai tool → amati → ulang) untuk menuntaskan tugas.
• CLAUDE.md — berkas Markdown berisi memori proyek (konvensi, perintah, konteks) yang dimuat otomatis tiap sesi.
• Context / konteks — kumpulan percakapan dan berkas yang "diingat" Claude dalam sesi; terbatas dan berbiaya token.
• Headless — pemakaian non-interaktif (mis. dalam skrip/CI) tanpa sesi obrolan.
• Hook — perintah shell yang dijalankan sistem secara otomatis pada peristiwa tertentu (mis. sebelum/sesudah tool).
• MCP (Model Context Protocol) — standar terbuka untuk menyambungkan asisten ke alat & data eksternal via server.
• Permission mode — tingkat seberapa banyak Claude bertanya sebelum bertindak (default, accept edits, plan, bypass).
• Plan mode — mode read-only tempat Claude merencanakan tanpa mengubah apa pun.
• Prompt injection — instruksi menyesatkan yang terselip dalam konten tak tepercaya yang dibaca model.
• settings.json — berkas konfigurasi (izin, hooks, env, model), berlapis pengguna/proyek/lokal.
• Skill (SKILL.md) — paket instruksi/keahlian yang dipanggil model saat deskripsinya cocok dengan tugas.
• Slash command — perintah cepat yang diawali / di dalam sesi (mis. /clear, /init).
• Subagent — agen anak dengan konteks terpisah untuk mendelegasikan tugas, bisa berjalan paralel.
• Tool use — tindakan konkret model: membaca/menulis berkas, menjalankan shell, mencari, memanggil server MCP.
• Diff — tampilan perbedaan sebelum/sesudah sebuah perubahan; baris hijau (+) ditambah, merah (-) dihapus.
• Loop agentic — siklus berulang rencana → tindakan (tool) → observasi hingga tugas selesai.
• Konteks bersih (fresh context) — keadaan sesi tanpa riwayat sebelumnya, dicapai dengan /clear atau saat subagent dimulai.
• Frontier model — model AI paling mutakhir dari sebuah keluarga (untuk Claude Code: keluarga Claude).

Checklist Memulai

Tempel di dekat meja Anda:

• ☐ Pasang: npm install -g @anthropic-ai/claude-code (atau installer natif).
• ☐ Jalankan claude doctor untuk memastikan lingkungan sehat.
• ☐ Masuk dengan /login (langganan atau API).
• ☐ Di proyek, jalankan /init untuk membuat CLAUDE.md, lalu sunting.
• ☐ Pelajari /clear, /compact, dan Shift+Tab (mode).
• ☐ Mulai di default mode; longgarkan izin hanya setelah percaya.
• ☐ Bekerja di branch; sering git commit; tinjau git diff.
• ☐ Untuk tugas besar, pakai plan mode dulu.
• ☐ Tambah slash command kustom / skill untuk alur berulang.
• ☐ Sambungkan MCP hanya untuk server tepercaya.
• ☐ Pantau /cost; bersihkan konteks antar tugas.
• ☐ Selalu tinjau kode & jalankan tes sebelum menganggap selesai.

"Berhentilah sekadar mengetik kode. Mulailah mengarahkannya. Terminal Anda baru saja menjadi jauh lebih kuat."

— Galih Prasetyo

Satu nasihat penutup: jangan menunggu sampai merasa "cukup paham" untuk mulai. Cara tercepat menguasai Claude Code adalah memakainya pada masalah kecil yang nyata hari ini — sebuah bug sepele, sebuah tes yang belum ditulis, sebuah refaktor yang tertunda. Amati apa yang dilakukannya, koreksi bila keliru, dan biarkan kepercayaan tumbuh dari bukti, bukan dari janji. Buku ini adalah peta; medannya hanya bisa Anda kenali dengan berjalan.

Terima kasih telah membaca. Semoga buku ini menghemat banyak jam bagi Anda, dan mengubah cara Anda bekerja dengan kode menjadi lebih tenang, cepat, dan menyenangkan. Selamat mengarahkan.