### Jawaban Singkat: Cara Membuat Claude Menggunakan Lebih Sedikit Token
Untuk memangkas konsumsi token Claude Code hingga 75%, terapkan empat optimasi inti: buat berkas
.claudeignoreyang ketat guna menyingkirkan artifak build dan lockfile, manfaatkan diskon pembacaan prompt caching 90% dari Anthropic dengan mengunci instruksi statis, isolasi sub-tugas menggunakan sub-agen Scout untuk mencegah Context Rot, dan prioritaskan modelclaude-3-7-sonnetatau model ringanclaude-3-5-haikuuntuk penelusuran kode rutin sebelum beralih ke Opus.
1. Pendahuluan: Kebocoran Token Tersembunyi pada Agen Terminal
Agen pemrograman terminal otonom seperti Claude Code dari Anthropic telah merevolusi alur kerja pengembangan perangkat lunak. Berbeda dari pelengkap kode standar di IDE, Claude Code beroperasi dalam siklus eksekusi mandiri: memeriksa struktur direktori, membaca ribuan baris berkas kode, mengeksekusi perintah shell, menganalisis catatan compiler, dan menerapkan patch kode yang presisi secara langsung.
Namun, otonomi ini menuntut biaya API yang sangat besar. Tanpa konfigurasi yang matang, perintah sederhana seperti "Refaktor middleware autentikasi agar mendukung rotasi token JWT" dapat menghabiskan 1,5 juta hingga 3,5 juta token hanya dalam satu sesi kerja. Pembengkakan konsumsi token ini dipicu oleh empat faktor utama:
- Akumulasi dan Penurunan Kualitas Konteks (Context Rot): Setiap luaran perintah bash, hasil pencarian grep, pesan kesalahan compiler, dan salinan utuh berkas tetap menumpuk di jendela konteks aktif agen.
- Pembacaan Ulang Tanpa Cache: Mengubah percakapan di giliran awal secara tidak sengaja akan membatalkan batas waktu 5 menit fitur prompt caching efemeral dari Anthropic.
- Pemindaian Artifak Berlebih: Selama pencarian regex global, Claude Code membaca direktori kompilasi (
dist/,target/,.next/), berkas pengunci pustaka berukuran raksasa (package-lock.json,pnpm-lock.yaml), serta salinan basis data secara berulang. - Spesifikasi Model Terlalu Tinggi: Menggunakan model penalaran termahal (
claude-3-opusatau Sonnet dengan moda berpikir maksimal) hanya untuk tugas sederhana seperti memeriksa berkas atau membaca pohon direktori.
Melalui penerapan batasan arsitektur sistematis — disiplin penggunaan .claudeignore, pemanfaatan prompt caching, isolasi konteks sub-agen, dan penyetelan CLI — tim rekayasa perangkat lunak terbukti mampu menghemat 70% hingga 80% pengeluaran token harian Claude Code sekaligus meningkatkan angka keberhasilan tugas.
2. Analisis Kuantitatif: Tarif Token dan Arsitektur Caching
Untuk memahami di mana pemborosan token terjadi, pelajari struktur tarif resmi Anthropic API dan tingkatan caching (standar acuan 2026):
| Varian Model Claude | Input Standar ($/1M) | Tulis Cache ($/1M) | Baca Cache ($/1M) | Output ($/1M) | SWE-bench Verified | Peran Optimal di Terminal |
|---|---|---|---|---|---|---|
| Claude 3.5 / 3.7 Haiku | $0.80 | $1.00 | $0.08 | $4.00 | 41.2% | Pencarian simbol, filter regex, pembuatan pesan commit |
| Claude 3.7 Sonnet (Standard) | $3.00 | $3.75 | $0.30 | $15.00 | 70.3% | Refaktor inti, modifikasi multi-berkas, perbaikan pengujian |
| Claude 3.7 Sonnet (Extended Thinking) | $3.00 (in) | $3.75 (write) | $0.30 | $15.00 (pikir+out) | 72.8% | Bug arsitektur rumit, masalah race condition konkurensi |
| Claude 3 Opus / Opus 4.6 | $15.00 | $18.75 | $1.50 | $75.00 | 74.1% | Audit keamanan kritis, perancangan ulang sistem menyeluruh |
Pemodelan Matematika Penghematan 75% Biaya dan Token
Simulasi sesi 15 langkah untuk merefaktor endpoint REST API pada repositori TypeScript dengan 150.000 baris kode:
[Sesi Mentah Tanpa Optimasi]
Langkah 1: Muat peta repositori + package-lock.json + skema (180.000 token)
Langkah 2-5: Luaran grep mentah, log build, pembacaan berkas utuh (akumulasi 240.000 token/langkah)
Tingkat Cache Miss: 45% (cache sering gugur akibat perubahan header dinamis)
Total Input Token Diproses: 3.250.000 token
Biaya Riil (Sonnet): ~$9.75
[Sesi Teroptimasi: .claudeignore + Prompt Cache + Sub-Agen]
Langkah 1: Ringkasan ringkas struktur AST (18.000 token) -> Tersimpan di cache pada Langkah 1
Langkah 2-5: Patch diferensial bertahap, sub-agen Scout mengembalikan ringkasan padat (22.000 token/langkah)
Tingkat Cache Hit: 92% (pembacaan dengan diskon tarif $0.30/1M)
Total Input Token Diproses: 410.000 token (penurunan token fisik sebesar 87.3%)
Biaya Riil (Sonnet): ~$0.82 (penghematan pengeluaran nyata sebesar 91.5%)3. Pilar 1: Penguasaan .claudeignore untuk Memangkas Konteks Tak Berguna
Langkah dengan imbal hasil investasi tertinggi di repositori mana pun adalah menyusun berkas .claudeignore yang ketat untuk kebutuhan produksi.
Secara bawaan, Claude Code mematuhi aturan .gitignore. Namun berkas .gitignore standar umumnya meloloskan banyak berkas berukuran raksasa yang mencemari jendela konteks LLM. Berkas pengunci dependensi, materi dokumentasi, folder kompilasi build, serta bundle yang diminifikasi tidak boleh dibiarkan masuk ke konteks kerja agen.
Templat .claudeignore Siap Pakai
Simpan berkas ini pada direktori utama (root) proyek Anda:
# ==============================================================================
# .claudeignore - Matriks Pengecualian Token Produksi
# Mencegah Claude Code membaca berkas berukuran raksasa saat glob dan grep
# ==============================================================================
# Berkas Pengunci Paket (JSON/YAML masif tanpa nilai analisis AST)
package-lock.json
pnpm-lock.yaml
yarn.lock
bun.lockb
composer.lock
Gemfile.lock
Cargo.lock
poetry.lock
# Artifak Hasil Build dan Bundling
dist/
build/
out/
.next/
.nuxt/
.astro/
.svelte-kit/
storybook-static/
target/
*.min.js
*.min.css
*.map
# Laporan Cakupan Pengujian, Log, dan Profiling
coverage/
.nyc_output/
*.lcov
*.log
npm-debug.log*
yarn-debug.log*
pnpm-debug.log*
*.heapsnapshot
*.cpuprofile
# Media, Gambar, dan Berkas Biner
public/assets/
public/images/
*.png
*.jpg
*.jpeg
*.gif
*.svg
*.webp
*.avif
*.ico
*.pdf
*.zip
*.tar.gz
*.wasm
# Dokumentasi Internal dan Spesifikasi API Luar
docs/
*.mdx
specs/swagger/
*.postman_collection.json
# Variabel Lingkungan Lokal dan Kunci Pengaman
.env*
!.env.example
*.pem
*.key
*.cert
# Migrasi Basis Data dan SQL Dump
*.sql
*.dump
prisma/migrations/Dampak Nyata Berkas .claudeignore
Saat Claude Code melakukan pemindaian rekursif, berkas package-lock.json yang tidak dikecualikan (umumnya memiliki 25.000 hingga 80.000 baris kode) dapat langsung menyedot lebih dari 120.000 token hanya dalam satu kali baca. Dengan mengecualikan berkas pengunci dan direktori build, ukuran awal konteks berkurang dari ~180k token menjadi kurang dari 15k token.
4. Pilar 2: Arsitektur Prompt Caching dan Pemanfaatan Diskon 90%
Fitur prompt caching dari Anthropic menyimpan token input di sisi server selama 5 menit (diperpanjang setiap kali terjadi cache hit). Pembacaan token yang tersimpan di cache hanya dikenakan biaya 10% dari tarif input reguler ($0.30/1M berbanding $3.00/1M pada Sonnet).
+-------------------------------------------------------------------------+
| Siklus Hidup Prompt Caching Anthropic |
+-------------------------------------------------------------------------+
|
v
+-------------------------------------------------------------------------+
| [System Prompt dan Definisi Tool] (Awalan Statis - Selalu Tercache) |
+-------------------------------------------------------------------------+
|
v
+-------------------------------------------------------------------------+
| [Peta Arsitektur Proyek dan Panduan Kode] (Titik Pemeriksaan Cache) |
+-------------------------------------------------------------------------+
|
v (Titik Patah Cache!)
+-------------------------------------------------------------------------+
| [Instruksi Pengguna Dinamis dan Riwayat Tool] (Ekor Tidak Tercache) |
+-------------------------------------------------------------------------+Tiga Kaidah Mempertahankan Cache Prompt
- Jangan Menyisipkan Penanda Waktu Dinamis pada Konteks Sistem: Hindari menambahkan tanggal dinamis atau ID sesi pada
CLAUDE.md. Perubahan pada satu karakter awal akan membatalkan seluruh token cache di belakangnya. - Rangkai Perintah dalam Rentang 5 Menit: Batas kedaluwarsa (TTL) cache adalah 300 detik. Apabila Anda menunda perintah selama 6 menit saat membaca kode, giliran berikutnya akan dikenakan biaya penulisan cache penuh ($3.75/1M).
- Susun Instruksi dari yang Paling Tetap ke yang Paling Berubah: Mesin Claude Code menempatkan instruksi tetap di bagian awal payload API. Pastikan pedoman pada
CLAUDE.mdselalu bersifat konsisten dan deterministik.
5. Pilar 3: Pemanfaatan Sub-Agen dan Pemisahan Sub-Tugas
Jebakan terbesar dalam penggunaan agen terminal adalah jebakan sesi monolitik (Monolithic Session Trap). Pengembang sering kali meminta Claude mereproduksi bug, menulis pengujian unit, merefaktor modul, menjalankan uji integrasi, dan membuat dokumentasi dalam satu sesi dialog yang tak terputus.
Pada giliran ke-12, jendela konteks telah dipenuhi ratusan baris log kegagalan uji coba, catatan compiler, dan kode usang. Setiap perintah baru berikutnya akan mengirim ulang seluruh timbunan data tersebut ke API.
Arsitektur Dua Lapis: Agen Pengintai (Scout) dan Eksekutor (Worker)
Pisahkan fase eksplorasi dan pembacaan dari fase modifikasi kode aktif:
[Permintaan Tugas Pengguna]
|
v
+---------------------------------------------+
| Lapisan 1: Sub-Agen Scout (Khusus Baca) |
| - Berjalan di claude-3-5-haiku |
| - Menggunakan Glob, Grep, baca baris target|
| - Memadatkan 500.000 token jadi laporan 2KB|
+---------------------------------------------+
|
v (Penyerahan Konteks Padat)
+---------------------------------------------+
| Lapisan 2: Agen Eksekutor Inti |
| - Berjalan di claude-3-7-sonnet |
| - Hanya menerima JALUR TEPAT & simbol AST |
| - Menerapkan patch diferensial per baris |
+---------------------------------------------+Praktik Isolasi Tugas di Claude Code
Bagi pekerjaan besar menjadi rangkaian instruksi terminal yang terpisah:
# Pola Buruk: Sesi tunggal yang membuat konteks membengkak
claude "Cari semua endpoint yang memakai auth usang, ubah ke OAuth2, perbaiki tes dan tulis dokumennya"
# Pola Tepat: Eksplorasi terpisah -> Eksekusi terarah
# Tahap 1: Eksplorasi hemat token
claude --model claude-3-5-haiku -p "Tuliskan hanya daftar jalur berkas dan nomor baris yang memakai auth middleware lama dalam format JSON." > auth-audit.json
# Tahap 2: Eksekusi presisi dalam konteks bersih
claude --model claude-3-7-sonnet "Refaktor endpoint yang terdaftar di auth-audit.json ke OAuth2. Jangan sentuh berkas lain."6. Pilar 4: Pemilihan Model — Varian Claude Mana yang Lebih Hemat Token?
Setiap model dalam keluarga Claude mengonsumsi jumlah token yang berbeda untuk menyelesaikan tugas yang sama:
- Anggaran Berpikir (Thinking Budget): Model dengan Extended Thinking menghasilkan ribuan token penalaran internal yang ditagih setara tarif token output ($15.00/1M pada Sonnet).
- Penjelasan Bertele-tele: Beberapa model menghasilkan pengantar kata yang panjang sebelum menjalankan fungsi alat, memicu pemborosan token luaran.
- Efisiensi Pencarian: Model yang cerdas menemukan letak masalah dengan 1-2 panggilan grep terarah, sedangkan model di bawahnya cenderung membaca seluruh isi berkas.
Perbandingan Konsumsi Token Menurut Ragam Tugas
| Ragam Tugas | Claude 3.5 Haiku | Claude 3.7 Sonnet (Standar) | Claude 3.7 Sonnet (8k Thinking) | Claude 3 Opus |
|---|---|---|---|---|
| Mencari simbol di repositori | 12k token / $0.01 | 14k token / $0.04 | 24k token / $0.18 | 18k token / $0.27 |
| Perbaikan bug fungsi tunggal | 28k token / $0.03 | 22k token / $0.07 | 35k token / $0.24 | 30k token / $0.45 |
| Refaktor 5 berkas terkait | Tingkat gagal tinggi | 140k token / $0.48 | 190k token / $1.25 | 220k token / $3.30 |
| Masalah race condition rumit | Tidak terpecahkan | 320k token (gagal) | 240k token (sukses) / $1.60 | 280k token / $4.20 |
Panduan Penugasan Model
- Andalan Sehari-hari: Gunakan
claude-3-7-sonnetmoda normal untuk 80% kebutuhan pemrograman sehari-hari. - Penelusuran dan Otomasi Ringan: Pakai
claude-3-5-haikuuntuk pencarian berkas, perumusan regex, skrip shell, dan pemilahan log. - Moda Penalaran Khusus: Aktifkan Extended Thinking (
thinking: { budget_tokens: 4000 }) hanya pada permasalahan algoritma berat atau kegagalan kompilasi berulang.
7. Pengaturan Lanjutan dan Optimasi .claude/config.json
Anda dapat menyetel perilaku Claude Code melalui ~/.claude.json untuk pengaturan global atau .claude/config.json untuk proyek spesifik.
Konfigurasi Efisiensi Tinggi .claude/config.json
{
"$schema": "https://json.schemastore.org/claude-code-config.json",
"model": "claude-3-7-sonnet",
"maxThinkingTokens": 2048,
"autoCompactContext": true,
"contextCompactionThreshold": 0.65,
"allowedTools": [
"Edit",
"Bash",
"Glob",
"Grep",
"Read"
],
"toolLimits": {
"bashOutputMaxLines": 150,
"readFileMaxLines": 300
},
"enableTelemetry": false
}Penjelasan Parameter Kunci
maxThinkingTokens: 2048: Menetapkan batas atas token berpikir agar tugas sederhana tidak membuang 8k hingga 16k token ($0.12 - $0.24) per langkah.autoCompactContext: true: Menjalankan ringkasan riwayat percakapan otomatis saat kapasitas jendela konteks mencapai 65% (contextCompactionThreshold: 0.65).bashOutputMaxLines: 150: Mencegah eksekusi tes atau instalasi dependensi menumpahkan 5.000 baris log stdout ke dalam jendela memori model.
8. Pola Taktis Perumusan Prompt di Terminal
Gaya Anda menyusun perintah berpengaruh langsung terhadap 40% pemakaian token sesi:
Pola 1: Membatasi Pembacaan Berdasarkan Nomor Baris
Alih-alih membiarkan Claude membaca seluruh berkas, tentukan rentang barisnya:
# Pola Buruk: Membaca 1.800 baris (sekitar 14.000 token)
"Baca src/auth/session.ts dan cari tahu mengapa verifikasi token gagal"
# Pola Tepat: Membaca hanya 60 baris (sekitar 450 token)
"Periksa baris 120-180 pada src/auth/session.ts tempat fungsi verifyJwt() dideklarasikan"Pola 2: Meringkas dan Menyaring Luaran Terminal
Saat meminta pengujian atau kompilasi kode, wajibkan format yang ringkas:
# Pola Buruk: Membanjiri konteks dengan ribuan baris log uji coba yang sukses
"Jalankan npm test dan perbaiki error-nya"
# Pola Tepat: Meringkas luaran
"Jalankan npm test -- --reporter=dot atau filter hanya baris error dengan grep. Jangan tampilkan log tes yang lolos."Pola 3: Pembersihan dan Peringkasan Konteks Rutin (/compact dan /clear)
Manfaatkan perintah bawaan Claude Code secara disiplin:
/compact: Meringkas riwayat percakapan aktif menjadi intisari teknis yang padat secara instan./clear: Membersihkan seluruh memori konteks sebelum memulai fitur baru tanpa perlu membuka ulang terminal.
9. Matriks Komparasi Strategi Efisiensi Token
| Strategi Optimasi | Estimasi Penghematan Token | Kompleksitas Penerapan | Risiko terhadap Kode | Cara Kerja Utama |
|---|---|---|---|---|
Ketat Mengatur .claudeignore |
40% – 60% | Rendah (5 menit) | Nol | Memblokir lockfile, media, dan folder kompilasi |
Meringkas Konteks (/compact) |
30% – 50% | Instan (perintah CLI) | Rendah | Membuang log usang dan rekaman kode lama |
| Eksplorasi via Sub-Agen | 35% – 55% | Menengah | Sangat rendah | Memisahkan pembacaan masif dari perbaikan presisi |
| Membatasi Batas Token Berpikir | 20% – 35% | Rendah (ubah config) | Rendah-Sedang | Mencegah loop penalaran berlebih pada tugas rutin |
| Patch Perubahan Baris Presisi | 15% – 25% | Rendah (kebiasaan) | Rendah | Mengganti penulisan ulang berkas dengan diff parsial |
| Penataan Prompt Cache | 10% – 20% (Biaya) | Menengah | Nol | Mengunci awalan statis demi diskon pembacaan 90% |
10. Kesimpulan dan Checklist 5 Langkah Praktis
Memangkas konsumsi token Claude Code hingga 75% sama sekali tidak mengurangi mutu kode yang dihasilkan. Sebaliknya, jendela konteks yang bersih dan terarah justru mencegah dispersi perhatian dan halusinasi, sehingga menghasilkan kode yang jauh lebih stabil.
Checklist Tindakan 5 Langkah:
- [ ] Pasang
.claudeignore: Salin templat produksi ke direktori root proyek untuk menyingkirkan lockfile dan folder build. - [ ] Optimalkan
config.json: Batasi token berpikir pada angka2048dan aktifkanautoCompactContextpada nilai0.65. - [ ] Sesuaikan Model dengan Tugas: Tugaskan
claude-3-7-sonnetuntuk menulis kode,claude-3-5-haikuuntuk menelusuri berkas, dan simpan moda penalaran untuk masalah krusial. - [ ] Batasi Luaran Terminal: Tambahkan parameter ringkas saat menjalankan pengujian (
--reporter=minserta filter grep) agar stdout tetap di bawah 100 baris. - [ ] Segarkan Konteks Berkala: Ketik
/compactatau/cleardi antara pergantian pekerjaan untuk membasmi Context Rot.
Dengan membiasakan langkah-langkah rekayasa ini di terminal harian Anda, potensi penuh kecerdasan buatan otonom dapat Anda nikmati tanpa terbebani tagihan API bulanan yang membengkak.