Masuk ke tim baru lalu disuapi codebase warisan berukuran 200.000 baris kode adalah mimpi buruk bagi hampir setiap software engineer. Kamu duduk di depan monitor, melakukan tracing fungsi satu per satu secara manual, dan berlayar tanpa peta di tengah kerumunan direktori yang asing. Di titik inilah hadir **Understand Anything: Plugin Claude Code yang Mengubah Codebase Jadi Knowledge Graph Interaktif**. Proyek open-source garapan Egonex (diinisiasi oleh Lum1104) ini tidak berambisi menggantikan posisi developer, melainkan memandu kamu agar tidak lagi membaca kode secara buta lewat visualisasi struktur yang jelas.

Filosofi mendasar dari tool ini sangat sederhana: AI seharusnya membantu manusia, bukan menggantikannya. Pembuatnya tidak sekadar menyajikan grafik rumit yang bikin pusing, melainkan sebuah peta interaktif yang secara tenang mengajarkan bagaimana setiap potongan kode saling terhubung.

## Dari Reading Blind ke Visualisasi Utuh: Solusi Realistis Developer

Ketika pertama kali menjalankan proyek skala besar, ekosistem *software development* sering kali memaksa kita menghabiskan waktu berhari-hari hanya untuk memahami *side effect* dari satu baris perubahan. Tool ini mengubah paradigma tersebut. Dengan memetakan setiap file, fungsi, kelas, dan dependensi menjadi simpul (node) yang bisa diklik, dibedah, dan dicari, proses pembacaan logika sistem berubah menjadi pengalaman eksplorasi visual.

Bukan cuma grafik teknis antar-file, sistem ini menyediakan tampilan ranah bisnis (*domain view*). Alur bisnis real diekstrak dan disajikan dalam grafik horizontal yang rapi, mulai dari *domain*, *flow*, hingga *step* eksekusi. Kamu juga bisa melakukan analisis dokumen wiki pola Karpathy menggunakan perintah khusus untuk mengekstrak entitas dan klaim implisit menjadi peta ide yang saling terhubung.

Fitur lain yang tak kalah pragmatis adalah **Guided Tours**, yaitu panduan arsitektur otomatis yang diurutkan berdasarkan dependensi. Developer pemula bisa mempelajari sistem sesuai urutan logis tanpa perlu menebak-nebak harus mulai dari direktori mana. Selain itu, ada **Diff Impact Analysis** untuk melihat efek domino dari perubahan kode sebelum kamu melakukan commit, serta **Persona-Adaptive UI** yang menyesuaikan tingkat kedalaman informasi untuk junior dev, PM, maupun power user.

## Rahasia Dapur: Kombinasi Cerdas Tree-sitter dan Multi-Agent LLM

Di balik kemampuannya membedah struktur raksasa, ada arsitektur hibrida yang sangat matang. Tool ini menggabungkan determinisme *static analysis* dengan kecerdasan kontekstual LLM.

Tree-sitter bertugas di garda depan secara deterministik. Alat ini memproses *source code* menjadi *concrete syntax tree* untuk mengekstrak fakta struktural murni seperti *import*, *export*, definisi fungsi, kelas, hingga hierarki pewarisan. Karena sifatnya deterministik, input yang sama akan selalu menghasilkan output edge graph yang persis sama. Tree-sitter juga memegang peranan kunci dalam mendeteksi perubahan file berbasis *fingerprint* untuk pembaruan incremental.

Di sisi lain, LLM bekerja menangani aspek semantik yang tidak bisa dipahami oleh parser statis. LLM membaca hasil analisis Tree-sitter untuk menghasilkan ringkasan berlayar bahasa awam, melabeli *architectural layer* (API, Service, Data, UI, Utility), memetakan domain bisnis, hingga menjelaskan 12 pola bahasa pemograman (seperti *generics*, *closures*, atau *decorators*) langsung di dalam konteks kodenya.

```
+-------------------------------------------------------+
|                 Source Code Base                      |
+---------------------------+---------------------------+
                            |
            +---------------+---------------+
            |                               |
            v                               v
  [ Tree-sitter Parser ]           [ LLM Semantic Engine ]
  - Static AST Extraction          - Contextual Summaries
  - Deterministic Edges            - Layer & Domain Mapping
  - Incremental Fingerprints       - Guided Tour Generation
            |                               |
            +---------------+---------------+
                            |
                            v
              +---------------------------+
              | Interactive Knowledge     |
              | Graph Dashboard           |
              +---------------------------+
```

## 7 Agent Spesialis di Balik Layar

Untuk mengeksekusi pipeline analisis tanpa kendala, sistem ini mengorkestrasi hingga tujuh agent terspesialisasi yang bekerja secara paralel:

* **project-scanner**: Memindai direktori, mendeteksi bahasa pemograman, dan mengenali framework yang digunakan.
* **file-analyzer**: Mengekstrak fungsi, kelas, dan dependensi untuk membentuk node awal graph. Agen ini sanggup berjalan hingga 5 pekerja bersamaan.
* **architecture-analyzer**: Mengelompokkan komponen ke dalam layer arsitektur sistem.
* **tour-builder**: Menyusun alur pembelajaran kognitif berurutan untuk anggota tim baru.
* **graph-reviewer**: Memvalidasi kelengkapan node dan integritas referensi antar-edge.
* **domain-analyzer**: Mengisolasi proses bisnis menjadi langkah-langkah logika yang jelas.
* **article-analyzer**: Bertugas khusus mengekstrak entitas dan hubungan implisit dari wiki dokumen.

## Fleksibilitas Lintas Platform dan Penghematan Token

Walaupun lahir sebagai plugin native untuk Claude Code, fleksibilitas integrasinya patut diacungi jempol. Tool ini mendukung berbagai platform AI coding terkemuka melalui script instalasi otomatis maupun *auto-discovery*.

Menariknya, issue penggunaan token LLM yang membengkak diantisipasi dengan cermat. Proses pemindaian awal memang memakan token cukup besar karena memproses seluruh direktori. Namun, eksekusi berikutnya bersifat *incremental*, artinya hanya file yang mengalami perubahan saja yang dianalisis ulang. Jika privasi atau budget API menjadi kendala utama, kamu tinggal mengarahkan platform ke model lokal seperti Ollama.

### Tabel Kompatibilitas Platform AI

| Platform AI | Status Dukungan | Metode Instalasi |
| :--- | :--- | :--- |
| Claude Code | Native ✅ | Plugin Marketplace |
| Cursor | Supported ✅ | Auto-discovery via `.cursor-plugin` |
| VS Code + GitHub Copilot | Supported ✅ | Auto-discovery via `.copilot-plugin` |
| Copilot CLI | Supported ✅ | `copilot plugin install` |
| Codex | Supported ✅ | `install.sh codex` (Menggunakan prefix `$`) |
| Gemini CLI | Supported ✅ | `install.sh gemini` |
| Kiro CLI / IDE | Supported ✅ | `install.sh kiro` |
| OpenCode / OpenClaw / Antigravity | Supported ✅ | `install.sh <platform>` |
| Vibe CLI / Hermes / Cline / KIMI / Trae | Supported ✅ | `install.sh <platform>` |

## Cara Penggunaan dan Perintah Utama

Pengoperasiannya didesain langsung dari terminal lingkungan kerja kamu. Berikut adalah beberapa Perintah yang umum digunakan dalam alur kerja sehari-hari:

```bash
# 1. Menginstal plugin di Claude Code
/plugin marketplace add Egonex-AI/Understand-Anything
/plugin install understand-anything

# 2. Menganalisis seluruh codebase (hasil disimpan di .ua/knowledge-graph.json)
/understand

# Menentukan bahasa spesifik untuk ringkasan UI dan node (misal: Bahasa Mandarin)
/understand --language zh

# 3. Membuka dashboard interaktif di browser
/understand-dashboard

# 4. Berinteraksi dan menganalisis sistem
/understand-chat How does the payment flow work?
/understand-diff
/understand-explain src/auth/login.ts
/understand-onboard
/understand-domain
```

Khusus bagi pengguna CLI berbasis Codex, panggilan instruksi menggunakan simbol dolar seperti `$understand` alih-alih garis miring.

## Berbagi Knowledge Graph Tanpa Ketergantungan API Key

Salah satu fitur paling praktis untuk kolaborasi tim adalah mekanisme pembagian file data. Output dari analisis ini disimpan sebagai file JSON murni di dalam folder `.ua/`. Kamu hanya perlu menyertakan folder tersebut ke dalam repositori Git tim (kecuali direktori `intermediate/` dan `diff-overlay.json`).

Rekan satu tim yang ingin membaca arsitektur proyek tidak perlu lagi menjalankan pipeline AI atau memiliki API Key. Cukup gunakan utilitas bawaan Node.js untuk membuka dashboard viewer secara lokal:

```bash
npx https://github.com/Egonex-AI/Understand-Anything/releases/latest/download/understand-anything-viewer.tgz /path/to/analyzed/project
```

Perintah di atas akan menjalankan server lokal berbasis Node.js (minimal versi 18) dan memberikan URL unik ber-token. Semua data disajikan secara *read-only* langsung dari disk lokal, tanpa ada data yang terkirim ke luar maupun panggilan API tambahan. Untuk proyek besar dengan ukuran file graph melebihi 10 MB, penyimpanan dapat dikombinasikan dengan Git LFS agar repositori tetap ringan.

Langkah Egonex merilis pembaruan ini membuktikan bahwa masa depan AI coding bukan sekadar menghasilkan potongan kode otomatis secara liar, melainkan memberikan pemahaman konteks mendalam agar developer tetap memegang kendali penuh atas arsitektur perangkat lunak yang mereka bangun.

## Referensi
- https://github.com/Egonex-AI/Understand-Anything

Bedah lengkap Understand Anything, plugin open-source yang mengubah raksasa codebase dan dokumen wiki menjadi knowledge graph interaktif secara otomatis.

Terjebak Legasi 200 Ribu Baris Kode? Tool Ini Bikin Kamu Paham Codebase Cuma dalam Hitungan Menit

Reggi

Setiap kali AI coding agent menjalankan perintah terminal, context window Anda sebenarnya sedang "dirampok". Perintah sederhana seperti melihat status repositori atau membaca berkas log menyetor ratusan baris teks sampah. Ada header dekoratif, spasi perataan, metadata komit, hingga jalur direktori yang diulang terus-menerus. Output ini dirancang untuk dibaca mata manusia, bukan untuk dicerna oleh model bahasa besar. Ketika tagihan API Anthropic mulai membengkak akibat CLI noise yang memenuhi context window, perdebatan teknis tentang efisiensi seperti **rtk vs headroom vs woze code** (WOZCODE) menjadi topik krusial bagi para engineer yang ingin menyelamatkan kantong mereka.

Pada sebuah codebase produksi berbasis TypeScript dan Next.js, pemantauan terhadap 26.779 perintah CLI dan 2.246 permintaan API selama sebulan membuktikan satu hal: miliaran token melayang gratis hanya untuk memproses output terminal yang tidak mempengaruhi keputusan AI berikutnya. Untuk mengatasi masalah ini, komunitas mengembangkan dua pendekatan berbeda. Pendekatan pertama adalah arsitektur dua lapis menggunakan **RTK** dan **Headroom**, sedangkan pendekatan kedua adalah mengganti *tool* bawaan menggunakan plugin **WOZCODE**.

---

## Lapisan 1: Menyaring Noise Perintah via RTK

**RTK** (Rust Token Killer) adalah *binary* berbasis Rust yang bertindak sebagai pemotong sampah di tingkat terminal. Sistem ini bekerja sebagai kait **PreToolUse** pada Claude Code. Saat agent memanggil perintah Bash, kait ini mencegat dan mengubah perintah secara transparan sebelum dieksekusi.

```bash
# Alur pencegatan perintah oleh RTK
# 1. Agent memanggil: git status
# 2. PreToolUse hook aktif
# 3. Hook mengubah perintah menjadi: rtk git status
# 4. RTK mengeksekusi git status dan menyaring output
# 5. Output terkompresi masuk ke context window (hingga 80% lebih kecil)
```

Ada empat strategi utama yang diterapkan oleh RTK untuk menghemat token antara 60% hingga 90% per perintah:
1. **Smart Filtering**: Membuang teks *boilerplate* yang tidak relevan.
2. **Grouping**: Menggabungkan entitas atau baris yang serupa.
3. **Truncation**: Memotong output panjang namun tetap mempertahankan konteks paling krusial (misalnya hanya menyisakan bagian log *build* yang *error*).
4. **Deduplication**: Menghapus baris berulang yang tidak menambah informasi baru.

Dengan *overhead* eksekusi di bawah 10ms per perintah, agent AI bahkan tidak menyadari keberadaan RTK. Agent tetap melihat antarmuka *tool* yang sama dan menerima output dengan konteks semantik yang identik.

---

## Lapisan 2: Kompresi Sesi dan Caching via Headroom

Jika RTK bekerja di tingkat terminal sebelum output masuk ke context window, **Headroom** bekerja di tingkat jaringan. Headroom adalah *proxy* lokal yang berjalan di `localhost:8787`, berada tepat di antara agent coding dan provider API Anthropic.

```
┌──────────┐     ┌─────────────┐     ┌─────────┐     ┌──────────────┐     ┌──────────────┐
│  Agent   │────▶│  RTK hook   │────▶│  Bash   │────▶│   Headroom   │────▶│  Anthropic   │
│          │     │  (rewrite)  │     │ (runs)  │     │   (compress) │     │  API         │
└──────────┘     └─────────────┘     └─────────┘     └──────────────┘     └──────────────┘
Layer:           PreToolUse           Shell            API proxy            Provider
Savings:         60-90%                               16-59%
```

Headroom membaca jenis konten secara cerdas (*content-aware*). Array JSON dikompresi sebesar 83-90%, output *shell* sebesar 85%, dan log *build* hingga 94%. Menariknya, berkas *source code* dan hasil pencarian *grep* sengaja dibiarkan utuh tanpa kompresi *lossy* agar kemampuan nalar (*reasoning*) model terhadap kode tidak rusak.

Keunggulan terbesar Headroom terletak pada kestabilan **Prefix Cache**. Fitur *prefix caching* dari Anthropic memberikan diskon token input sebesar 90% jika bagian awal *prompt* cocok dengan permintaan sebelumnya. Headroom mengompresi hasil *tool* tanpa mengubah *system prompt* atau riwayat percakapan awal. Hasilnya, *prefix* tetap stabil dan mencatatkan *hit rate* cache hingga 96%.

---

## Pendekatan Alternatif: WOZCODE Plugin

Berbeda dengan kombinasi RTK dan Headroom yang bermain di level hook dan proxy jaringan, **WOZCODE** memilih jalur integrasi langsung sebagai plugin Claude Code. WOZCODE mengganti *tool* berkas bawaan Claude Code dengan versi yang sudah dioptimasi sejak awal.

WOZCODE menyediakan dua agent utama:
* **`woz:code`**: Agent utama untuk aktivitas koding, pengubahan berkas, pencarian, hingga SQL.
* **`woz:explore`**: Agent pembantu khusus eksplorasi codebase berbasis baca-saja (*read-only*) yang berjalan di atas model **Haiku** untuk kecepatan maksimal dan biaya minimal.

Pemasangan WOZCODE dilakukan langsung dari dalam sesi Claude Code:

```bash
/plugin marketplace add WithWoz/wozcode-plugin
/plugin install woz@wozcode-marketplace
```

Setelah diinstal dan diautentikasi via `/woz-login`, WOZCODE bekerja secara otomatis. Plugin ini juga menyediakan pemantauan hemat biaya secara langsung melalui perintah `/woz-savings`, serta mendukung integrasi dengan *environment* seperti Conductor.

---

## Perbandingan Arsitektur: RTK + Headroom vs WOZCODE

Untuk menentukan solusi terbaik bagi *workflow* Anda, mari bedah perbedaan teknis dari kedua pendekatan ini.

| Parameter | Kombinasi RTK + Headroom | WOZCODE Plugin |
| :--- | :--- | :--- |
| **Tingkat Operasi** | PreToolUse Hook & Local API Proxy (`localhost:8787`) | Plugin Marketplace & Tool Replacement |
| **Metode Kompresi** | Saringan regex/AST CLI & Kompresi muatan JSON/Log | Penggantian alat bawaan & Delegasi Haiku |
| **Optimasi Model** | Memaksimalkan Anthropic Prefix Cache (Hit Rate 96%) | Menggunakan agent `woz:explore` berbasis Haiku |
| **Pengoperasian** | Transparan, tanpa perlu login akun pihak ketiga | Memerlukan akun Woz dan autentikasi token |
| **Kompatibilitas Tools** | Memotong output perintah Bash standar (`git`, `read`, dll) | Mengoptimalkan eksekusi berkas & pencarian kode |
| **Monitoring** | TUI Dashboard lokal (`tui.py`) secara *real-time* | Perintah *in-session* (`/woz-savings`) |

---

## Ranjau Teknis dan Jebakan Pengkonfigurasian

Mengimplementasikan optimasi token tidak selalu mulus. Banyak developer terkecoh karena sistem tampak berjalan normal, padahal penghematan tokennya 0% akibat kesalahan konfigurasi tersembunyi.

### 1. PATH Minimal pada Claude Code Hook
Claude Code mengeksekusi hook dengan variabel `PATH` yang sangat minimal (`/usr/bin:/bin:/usr/sbin:/sbin`). Jika RTK diinstal melalui Homebrew, panggilan hook akan gagal secara diam-diam (*silently exit 0*). Pengujian gagal, tidak ada peringatan, dan perintah berjalan tanpa disaring. Solusinya adalah menyuntikkan jalur `PATH` secara manual di bagian atas script wrapper.

### 2. Overwrite otomatis oleh `rtk init -g`
Menjalankan perintah `rtk init -g` akan menimpa berkas script hook dan menghapus perbaikan `PATH` yang sudah dibuat. Selain itu, RTK memeriksa integritas berkasnya menggunakan checksum SHA-256 dan menolak berjalan jika berkas tersebut dimodifikasi. Solusi yang tahan lama adalah membuat *wrapper script* mandiri (misalnya `rtk-wrapper.sh`) yang tidak dikelola langsung oleh perintah internal RTK.

### 3. Masalah `permissionDecision: "allow"`
Secara bawaan, output JSON dari RTK menyertakan properti `"permissionDecision": "allow"`. Jika konfigurasi Claude Code Anda mengaktifkan `skipDangerousModePermissionPrompt` atau `skipAutoPermissionPrompt`, Claude Code akan melompati jalur penanganan izin. Implikasinya fatal: sistem mengabaikan perintah hasil kompresi dan malah mengeksekusi perintah asli yang tidak dikompresi. Berkas *wrapper* wajib membuang kunci `permissionDecision` menggunakan `jq`:

```bash
# Script wrapper rtk-wrapper.sh untuk menangkap dan membersihkan JSON
#!/bin/bash
export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"

# Membuang permissionDecision agar kompresi tidak terlewati
if .hookSpecificOutput then
  .hookSpecificOutput |= del(.permissionDecision, .permissionDecisionReason)
fi
```

### 4. Atribut Extended macOS Sequoia (`com.apple.provenance`)
Pada macOS Sequoia, sistem operasi menambahkan atribut extended `com.apple.provenance` yang menyebabkan kemunculan pesan *Permission denied* saat Claude Code memanggil hook via `/bin/sh`. Karena *exit code* dari crash ini bernilai bukan nol dan bukan 2, Claude Code menganggapnya sebagai *non-blocking error* dan tetap menjalankan perintah awal secara utuh tanpa kompresi.

Untuk mengatasi ini, panggil hook di `~/.claude/settings.json` dengan menyertakan kata kunci `bash` di depannya agar *shell* membaca berkas sebagai data alih-alih mengeksekusinya secara langsung:

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "command": "bash /Users/username/.claude/hooks/rtk-wrapper.sh"
      }
    ]
  }
}
```

---

## Keputusan Pragmatis untuk Workflow Anda

Jika Anda menyukai kendali penuh atas infrastruktur lokal, tidak ingin bergantung pada layanan pihak ketiga tambahan, dan ingin memaksimalkan efisiensi dari perintah *shell* dasar, kombinasi **RTK + Headroom** adalah standar emas. Penghematan 1,5 miliar token dalam sebulan pada skala produksi bukti betapa ampuhnya arsitektur dua lapis ini.

Namun, jika Anda menginginkan solusi serba praktis yang langsung bekerja dari dalam Claude Code tanpa perlu mengutak-atik script Bash, *proxy port*, atau *wrapper jq*, **WOZCODE** menawarkan alternatif berbasis plugin yang sangat efisien. 

Apapun pilihan Anda, membiarkan CLI noise memenuhi context window agent AI tanpa kompresi adalah pemborosan yang tidak bisa dibenarkan di era koding berbasis AI saat ini.

## Referensi
- https://andrewpatterson.dev/posts/token-savings-rtk-headroom/
- https://github.com/WithWoz/wozcode-plugin

Analisis komprehensif efisiensi token Claude Code menggunakan RTK, Headroom, dan WOZCODE untuk memangkas sampah CLI dan menekan biaya API.

Menghemat Miliyaran Token Claude Code: Bedah Tuntas RTK, Headroom, dan WOZCODE

Pencarian kerja bisa menjadi proses yang panjang dan melelahkan. Bayangkan jika kamu punya asisten pribadi yang bisa menyaring lowongan, menyesuaikan CV, menulis surat lamaran, bahkan menyiapkan wawancara. Nah, itulah yang ditawarkan oleh proyek *open-source* bernama **AI Job Search**. Ini adalah *framework* aplikasi pencari kerja bertenaga AI yang berjalan di mesin kamu sendiri, dibangun di atas **Claude Code**.

Proyek ini tidak berafiliasi atau disponsori oleh Anthropic. Penciptanya, seorang geofisikawan, membangun *framework* ini pada akhir tahun 2025 setelah posisinya dipotong. Dia menggunakannya sendiri untuk mencari pekerjaan dan berhasil mendapatkan posisi sebagai AI *engineer* pada Juni 2026, setelah 69 lamaran, 20 wawancara pertama, dan satu kontrak yang ditandatangani. Sekarang, alat ini tersedia untuk umum.

## Apa Itu AI Job Search?

**AI Job Search** adalah *framework* alur kerja terstruktur yang mengubah **Claude Code** menjadi asisten lamaran kerja. Alur kerja intinya, seperti pembuatan profil diri, evaluasi kecocokan, dan *pipeline* aplikasi *drafter-reviewer*, dirancang untuk bersifat **agnostik terhadap bahasa dan negara**. Meskipun kemampuan pencarian portal kerjanya saat ini dibangun untuk pasar Denmark, polanya dapat diganti dengan *job board* lokal di mana pun.

Proyek ini tidak memiliki *cryptocurrency*, *token*, atau program sponsor berbayar yang terkait. Dukungan hanya bisa diberikan melalui tautan Ko-fi atau kontribusi di GitHub.

## Bagaimana AI Job Search Bekerja: Alur Kerja Inti

**AI Job Search** dirancang untuk mempermudah seluruh proses lamaran kerja. Berikut adalah alur kerja utamanya:

*   **`/setup`**: Ini adalah langkah pertama untuk membangun profilmu. Kamu bisa mengunggah dokumen (CV PDF, ekspor LinkedIn, ijazah, surat referensi), menempel CV di *chat*, atau mengikuti sesi wawancara. Sistem akan secara otomatis mendeteksi materi yang kamu miliki dan memandu prosesnya.
*   **`/scrape`**: Perintah ini mencari posisi yang cocok dengan profilmu di berbagai portal kerja, menghilangkan duplikasi, dan menyajikan hasilnya yang disortir berdasarkan kecocokan. Jika hasilnya terlalu banyak, kamu bisa menjalankan `/rank` untuk mem-batch semua skor dan mendapatkan daftar pendek.
*   **`/apply <url>` atau `/apply <deskripsi_pekerjaan>`**: Ini adalah inti dari **AI Job Search**. Perintah ini menjalankan seluruh alur kerja: mengevaluasi kecocokan, membuat draf CV dan surat lamaran dalam format **LaTeX** yang disesuaikan, meninjau dengan agen kedua, merevisi, dan menyajikan *output* akhir. Semua klaim yang dibuat dalam CV dan surat lamaran diverifikasi terhadap profilmu, sistem tidak pernah memalsukan keahlian atau pengalaman.
*   **`/interview`**: Perintah ini mempersiapkanmu untuk wawancara terjadwal. Ini membangun paket persiapan spesifik berdasarkan arsip aplikasi (iklan pekerjaan, CV dan surat lamaran yang dibaca pewawancara, umpan balik dari putaran sebelumnya), meneliti perusahaan dan pewawancara, memetakan pertanyaan yang mungkin ke contoh **STAR**-mu, dan menawarkan wawancara simulasi.

## Fitur Unggulan di Balik Layar

Alur kerja **`/apply`** pada **AI Job Search** memiliki beberapa fitur kunci yang membedakannya:

*   **Verifikasi PDF Otomatis**: Kebanyakan *template* LaTeX menghasilkan *output* yang mungkin terlihat bagus di `.tex` tetapi bermasalah di PDF. Perintah `/apply` mengkompilasi dan secara visual memeriksa setiap PDF, menerapkan perbaikan yang ditargetkan untuk memastikan tata letak bersih, seperti CV dua halaman tanpa judul yang yatim piatu dan surat lamaran satu halaman penuh dengan tanda tangan terlihat jelas.
*   **Pemeriksaan ATS Lapisan Teks**: Sistem Applicant Tracking System (ATS) membaca teks yang tertanam dalam PDF. LaTeX terkadang menghasilkan PDF yang teksnya bisa terbaca kacau oleh ATS. **AI Job Search** mengekstrak lapisan teks PDF yang dikompilasi menggunakan `pdftotext` dan memverifikasi detail kontak, urutan baca, dan cakupan kata kunci dari lowongan pekerjaan terhadap apa yang sebenarnya dilihat oleh *parser* ATS. Aturan kejujuran ditegakkan, kata kunci yang tidak didukung oleh profilmu akan diakui sebagai celah, tidak pernah dijejalkan secara paksa.
*   **Pemotongan CV Berbasis Relevansi**: Jika CV melebihi dua halaman, *framework* ini tidak memotong secara mekanis dari bagian "terlama". Setiap baris dievaluasi berdasarkan relevansi dengan lowongan yang dituju, keunikan dalam dokumen, dan apakah surat lamaran bergantung padanya. Baris dengan skor total terendah akan dipotong terlebih dahulu. Ini berarti poin dari peran lama yang relevan dengan kata kunci lowongan bisa bertahan lebih lama daripada poin dari peran baru yang kurang relevan.
*   **Pemisahan Drafter-Reviewer**: Penulis draf membuat dokumen, lalu agen Claude kedua, yang diluncurkan dengan konteks baru, meneliti perusahaan dan mengkritik draf tersebut. Penulis draf kemudian merevisi berdasarkan umpan balik. Ini membantu menangkap kata kunci yang terlewat, kerangka yang lemah, dan bahasa umum yang sering tersisa dalam satu kali revisi.
*   **Penyesuaian Tanpa Fabrikasi**: Semua klaim dalam CV dan surat lamaran diverifikasi terhadap profil aktualmu. Sistem tidak pernah membuat-buat keahlian atau pengalaman.

## Perlengkapan yang Kamu Butuhkan

Untuk menjalankan **AI Job Search**, kamu perlu beberapa *prerequisite* teknis:

*   **Claude Code** (CLI): Alat agen utama yang digunakan.
*   **Python 3.10+**
*   **Bun**: Untuk alat CLI pencarian kerja.
*   Distribusi **LaTeX** dengan `lualatex` dan `xelatex`: Seperti TeX Live, MacTeX, TinyTeX, atau MiKTeX.

Setelah itu, kamu bisa melakukan *quick start* dengan beberapa perintah dasar:
```bash
gh repo fork MadsLorentzen/ai-job-search --clone
cd ai-job-search
```
Lalu instal alat pencarian kerja menggunakan Bun:
```bash
for tool in jobbank-search jobdanmark-search jobindex-search jobnet-search linkedin-search freehire-search; do
  (cd .agents/skills/$tool/cli && bun install)
done
```
Dan mulai proses *setup* profilmu di Claude Code:
```bash
claude
# Kemudian di dalam Claude Code:
/setup
```

## Memperdalam Kemampuan Pencarian Kerja

Selain alur kerja inti, **AI Job Search** juga menyediakan berbagai perintah lain untuk memperkaya proses pencarian kerjamu:

| Perintah         | Fungsi                                                                                                                                                                                                |
| :--------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`/outcome`**     | Merekam hasil lamaran (wawancara, tawaran, penolakan), mengarsipkan materi, dan memperbarui *tracker*.                                                                                                 |
| **`/notion-sync`** | Menerbitkan tampilan *pipeline* satu arah dan hanya baca ke basis data Notion.                                                                                                                         |
| **`/gmail-sync`**  | Membaca Gmail untuk sinyal status aplikasi (undangan wawancara, tautan penilaian, tawaran, penolakan) dan mengusulkannya untuk persetujuan.                                                              |
| **`/rank`**        | Memberi skor pada lowongan yang baru di-*scrape* terhadap *framework* kecocokan dan mengembalikan daftar pendek yang terurut.                                                                          |
| **`/expand`**      | Memperkaya profilmu dengan memindai sumber publik yang sudah kamu tautkan (repositori GitHub, situs portofolio) dan mencari silabus untuk kursus atau sertifikasi.                                     |
| **`/upskill`**     | Menganalisis celah antara profilmu dan lowongan kerja yang dilacak, menghasilkan peta panas celah keterampilan yang diprioritaskan dan rencana pembelajaran.                                             |
| **`/html-report`** | Membuat *dashboard* HTML mandiri dari `job_search_tracker.csv` dan arsip aplikasi, termasuk kartu statistik dan bagan.                                                                                |
| **`/add-template`**| Mendaftarkan *template* CV atau surat lamaran LaTeX milikmu sendiri.                                                                                                                                  |
| **`/add-portal`**  | Membuat *skill* pencarian portal kerja untuk *job board* di pasar lokalmu, menyelidiki pola URL pencarian dan struktur hasilnya.                                                                       |
| **`/reset`**       | Menghapus data profil atau folder dokumenmu untuk memulai dari awal.                                                                                                                                  |

## Tips untuk Hasil Terbaik

Kualitas *output* dari **AI Job Search** sangat bergantung pada masukan yang kamu berikan:

*   **Kedalaman Profil Penting**: Faktor terbesar dalam kualitas *output* adalah seberapa detail kamu mengisi profilmu. Profil yang tipis akan menghasilkan lamaran yang umum, sementara profil yang terperinci akan menghasilkan hasil yang benar-benar disesuaikan.
    *   **Deskripsi Peran**: Jangan hanya mencantumkan jabatan. Jelaskan apa yang sebenarnya kamu lakukan di setiap posisi: proyek spesifik, alat yang digunakan, tanggung jawab, dan pencapaian yang terukur.
    *   **Keahlian dalam Konteks**: Daripada hanya mencantumkan "Python" atau "manajemen proyek", jelaskan bagaimana dan di mana kamu menerapkannya. Misalnya, "Membangun *pipeline* ML untuk prediksi *customer churn* di Python menggunakan *scikit-learn*" memberikan sistem lebih banyak informasi daripada sekadar "Python, *machine learning*".
*   **Penemuan Jalur Karier**: *Framework* ini mendukung dua mode pencarian kerja: penargetan eksplisit (kamu tahu peran atau sektor yang kamu inginkan) dan penemuan peluang tersembunyi. Dengan menganalisis riwayat lengkapmu, sistem dapat memunculkan jalur karier yang belum kamu pertimbangkan. Untuk mendapatkan hasil maksimal, investasikan waktu saat `/setup` untuk menjelaskan tidak hanya pengalamanmu, tetapi juga apa yang memberimu energi dan apa yang ingin kamu lakukan lebih banyak lagi.

## Kustomisasi dan Ekosistem

**AI Job Search** dirancang agar dapat disesuaikan. Kamu dapat mengedit langsung file profil utama seperti `CLAUDE.md`, `01-candidate-profile.md`, atau `04-job-evaluation.md` untuk memperbarui detailmu.

Untuk **template LaTeX**, CV menggunakan `moderncv` dan surat lamaran menggunakan `cover.cls` khusus. Kamu bisa mendaftarkan *template* milikmu sendiri menggunakan perintah `/add-template`.

Sementara untuk **alat pencarian kerja**, proyek ini menyediakan `linkedin-search` (menggunakan *endpoint* publik LinkedIn, agnostik negara, tanpa dependensi *runtime*, cocok untuk penggunaan pribadi) dan `freehire-search` (menggunakan API publik aggregator `freehire.dev`, fokus pada *tech job*, agnostik pasar). Jika kamu berada di negara lain, kamu bisa menggunakan perintah `/add-portal` untuk membuat *skill* pencarian *job board* lokalmu sendiri.

Proyek ini juga mendukung **benchmarking gaji** dengan data yang kamu sediakan sendiri, memastikan kamu mendapatkan gambaran yang jelas tentang potensi penghasilan.

**AI Job Search** menawarkan pendekatan yang unik dan kuat untuk otomatisasi pencarian kerja, memungkinkanmu fokus pada wawancara dan negosiasi alih-alih tugas administratif yang berulang.

## Referensi
https://github.com/MadsLorentzen/ai-job-search

Pelajari AI Job Search, sebuah framework sumber terbuka yang memanfaatkan Claude Code untuk otomatisasi penuh proses lamaran kerja, mulai dari pencarian, penyesuaian CV, hingga persiapan wawancara.

AI Job Search: Otomatisasi Penuh Proses Lamaran Kerja dengan Bantuan AI

Industri AI untuk pengembangan kode kembali memanas dengan kehadiran pemain baru. xAI Rilis Grok Build Asisten AI untuk Coding Penantang Claude Code, menandai langkah serius perusahaan milik Elon Musk ini dalam ranah asisten AI yang fokus pada coding. Produk baru ini dirancang untuk bersaing langsung dengan layanan serupa, seperti Claude Code dari Anthropic.

### Grok Build: Asisten Kode dari Terminal untuk Profesional

Grok Build saat ini masih dalam tahap beta awal. Aksesnya terbatas hanya untuk pelanggan paket **SuperGrok Heavy**, yang berlangganan seharga 300 dollar AS per bulan atau sekitar Rp 5 jutaan. Berbeda dengan asisten AI lain yang mungkin memiliki tampilan grafis, Grok Build beroperasi sepenuhnya melalui terminal atau **Command Line Interface (CLI)**. Pendekatan ini menunjukkan fokusnya pada kebutuhan profesional dan tugas coding yang kompleks.

xAI menegaskan bahwa Grok Build dibuat untuk langsung cocok dengan alur kerja developer yang sudah ada. Sistem ini otomatis mengenali struktur proyek, termasuk jenis bahasa pemrograman, susunan folder, dan file-file penting, sehingga agen AI dapat memahami konteks kerja dengan cepat.

### Fitur Unggulan Grok Build

Grok Build hadir dengan beberapa fitur kunci yang bertujuan untuk mempercepat dan mempermudah proses pengembangan:

*   **Mode Perencanaan**: Salah satu daya tarik utamanya adalah mode perencanaan. Fitur ini memungkinkan pengguna untuk melihat dan bahkan mengedit langkah-langkah kerja agen AI sebelum eksekusi dimulai. Setiap perubahan yang dibuat akan ditampilkan sebagai `diff` yang bersih.
*   **Sub-Agen Paralel**: Untuk tugas yang lebih besar dan kompleks, Grok Build dapat membagi pekerjaan ke beberapa **sub-agen** khusus. Sub-agen ini berjalan secara paralel dan beroperasi di ruang terpisah melalui integrasi **worktree** dengan Git. Hal ini memastikan bahwa pekerjaan mereka tidak mengganggu file utama proyek.
*   **Dukungan Ekosistem Developer**: Grok Build dirancang untuk mendukung berbagai alat dan konvensi yang sudah dikenal developer. Ini termasuk dukungan untuk `AGENTS.md`, **plugins**, **hooks**, **skills**, serta **MCP servers** (Model Context Protocol). Dukungan MCP ini memungkinkan AI untuk terhubung ke berbagai sumber data dan alat lain, membuat kerjanya lebih kontekstual dan tidak hanya bergantung pada perintah teks.
*   **Automasi dan Orkestrasi**: Selain itu, Grok Build juga mendukung **ACP** (Agent Context Protocol). Ini mempermudah menjalankan agen di dalam skrip dan otomatisasi. CLI Grok Build juga menyediakan dukungan ACP penuh untuk kamu yang ingin membangun bot atau aplikasi orkestrasi agen sendiri.

### Percobaan Beta dan Pengembangan Berkelanjutan

Sebagai versi beta, Grok Build akan terus dikembangkan berdasarkan masukan dari penggunanya. xAI mempersilakan pengguna untuk mengirimkan laporan bug, permintaan fitur, dan reaksi langsung ke tim hanya dengan mengetik `feedback` di CLI.

Bagi pelanggan SuperGrok Heavy, Grok Build bisa dipasang dengan satu perintah sederhana:

```bash
install grok build
```

Elon Musk sebelumnya mengakui bahwa xAI masih tertinggal di bidang AI untuk coding, dan bahkan menyebut perusahaannya sedang dibangun ulang dari awal setelah sejumlah pendirinya keluar. Dengan target Grok bisa menyamai kemampuan Claude dalam berbagai tugas, peluncuran Grok Build ini adalah langkah signifikan xAI untuk mengejar ketertinggalan dan bersaing di pasar AI yang semakin ketat.

Sekadar catatan, Grok secara umum sempat menjadi sorotan pada tahun 2025 karena dilaporkan bisa menghasilkan gambar tidak pantas tanpa batasan ketat. xAI mengklaim telah memperbaiki aturan untuk mencegah hal tersebut terulang.

## Referensi
*   https://tekno.kompas.com/read/2026/05/19/14020067/xai-rilis-grok-build-asisten-ai-untuk-coding-penantang-claude-code
*   https://x.ai/news/grok-build-cli

xAI meluncurkan Grok Build, asisten AI berbasis CLI yang dirancang untuk developer profesional, menantang Claude Code dengan fitur perencanaan dan sub-agen paralel.

xAI Meluncurkan Grok Build, Asisten AI Coding Serba Guna untuk Developer Profesional

Autocomplete pintar di editor teks sudah bukan barang baru lagi. Sekarang, dunia software engineering sedang diacak-acak oleh agen AI otonom yang klaimnya bisa mengerjakan tugas developer dari hulu ke hilir. Masalahnya, begitu dihantam deadline mepet, bug warisan era purba, dan refactoring arsitektur yang jelimet, banyak dari alat ini yang langsung tumbang atau malah bikin repo makin berantakan.

Untuk membuktikan mana yang benar-benar bisa diandalkan dan mana yang cuma jualan hype, ada pengujian intensif selama sebulan penuh terhadap tiga nama besar: **Claude Code**, **Google Antigravity**, dan **Codex**. Seluruh alur kerja dipindahkan secara nyata, mulai dari mengotak-atik skrip lawas sampai meracik website portofolio dari nol. 

Hasilnya cukup mengejutkan. Ketiganya punya DNA dan filosofi yang sangat berbeda saat dipaksa bekerja di bawah tekanan.

---

## Claude Code: Sosok Senior Dev di Dalam Terminal

Menjalankan Claude Code terasa seperti punya tech lead pribadi yang duduk di sebelah meja kerja. Pendekatannya murni *agentic*. Claude Code tidak cuma menunggu dipancing dengan prompt sebaris dua baris, tetapi langsung aktif menjelajahi direktori, memahami silsilah file, membaca konteks proyek secara utuh, lalu mengeksekusi command di sistem operasi.

Daya tarik utamanya ada pada proses penalarannya (*thinking process*). Saat melacak bug rumit atau membedah logic yang bercabang, Anda bisa memantau langsung bagaimana cara ia berpikir sebelum menyentuh file. Transparansi ini sangat krusial. Kecepatan pencarian fungsinya di dalam codebase raksasa juga sangat impresif, terutama saat harus melakukan refactoring multi-file yang saling terkait erat.

Alat ini sangat dominan untuk urusan *vibe coding* atau eksplorasi kreatif dari nol. Dalam skenario uji coba membuat website portofolio modern dengan tumpukan teknologi spesifik, struktur menu unik, dan sentuhan visual gradien, Claude Code langsung mengeksekusi seluruh fondasi aplikasi dengan tepat hanya dalam satu kali tembakan prompt. 

```bash
# Workflow khas Claude Code: eksplorasi mendalam berbasis CLI
claude "Refactor modul autentikasi dan sinkronkan dengan database schema terbaru"
```

Tentu saja ada harga mahal yang harus dibayar. Konsumsi token Claude Code sangat rakus karena ia selalu membaca banyak konteks demi menjaga akurasi logika. Kuota Anda bisa lenyap dalam sekejap jika tidak dipantau ketat. Bagi developer yang terbiasa dengan UI visual, antarmuka berbasis terminal ini bakal menuntut adaptasi. 

Pada proyek multi-bulan berskala masif, beberapa developer mendapati Claude Code mulai memotong (*truncating*) baris kode. Untuk menyiasati limitasi ini, banyak engineer mengakalinya dengan membuka beberapa sesi paralel via `tmux`, memasang ekstensi VS Code resmi, mengawinkannya dengan editor berbasis Rust seperti Zed, atau bahkan merakit sistem memori kustom berbasis PostgreSQL dan `pgvector`.

---

## Google Antigravity: Pusat Kendali Cloud-Native yang Ambisius

Google melepas Antigravity pada akhir 2025 bukan sekadar sebagai ekstensi pemanis, melainkan sebuah lingkungan pengembangan mandiri yang merupakan hasil modifikasi mendalam (*fork*) dari VS Code. Filosofinya jelas: menyatukan ekosistem Google secara native ke dalam ruang kerja developer tanpa friksi.

Senjata paling mematikan dari Antigravity adalah antarmuka **Mission Control**. Fitur ini mengubah cara kerja tradisional. Alih-alih duduk manis menunggu satu AI mengetik jawaban, Anda bisa mempekerjakan beberapa agen otonom sekaligus secara paralel. Satu agen bertugas membedah API backend, agen kedua meracik unit test, sementara agen ketiga berselancar di internet membaca dokumentasi library terbaru.

```text
[Mission Control Overview]
├── Agent 1: Refactoring Legacy Database & Schema Migration
├── Agent 2: Writing Automated Unit Tests
└── Agent 3: Live Verification via Built-in Headless Browser
```

Antigravity juga dibekali browser internal yang sangat fungsional. Browser ini bisa memutar instance aplikasi, mengeklik elemen antarmuka, hingga merekam video otomatis untuk membuktikan bahwa fitur yang dibuat memang berjalan mulus. Dalam skenario migrasi database legacy serta perakitan dashboard pelanggan, alur kerja hybrid ini terasa sangat membantu: Anda bisa menyempurnakan logic krusial secara manual sambil membiarkan agen latar belakang menyelesaikan tugas-tugas repetitif. Dukungan ekosistemnya pun luas berkat akses ke registry Open VSX.

Namun, realita di lapangan tidak selalu seindah iklannya. Isu stabilitas dan penurunan performa masih kerap muncul di tengah sesi kerja berat. Masalah kuota token di Google Antigravity juga terbilang membingungkan, batas penggunaan mingguannya tidak transparan dan sering mendadak habis meski sudah berlangganan tier Pro. Di sisi akurasi, ada kalanya Antigravity (khususnya saat memakai model Gemini) menghasilkan kode yang meleset, butuh banyak revisi, atau bahkan menghapus blok kode fungsional yang sudah ada. Keharusan dependensi Node.js juga mendatangkan kekhawatiran terkait celah keamanan rantai pasokan software (*supply chain*).

---

## OpenAI Codex: Mesin Pabrik untuk Batch Processing

Jika Claude Code adalah rekan diskusi teknis dan Antigravity adalah kokpit komando, maka Codex edisi 2026 adalah mesin pabrik otomatis yang dirancang untuk kerja kasar volume tinggi. 

Codex bekerja di lingkungan *sandboxed* cloud yang terisolasi dari mesin lokal. Anda cukup mendelegasikan serangkaian task, membiarkannya memproses kode di latar belakang, dan Anda baru akan dihubungi saat *Pull Request* (PR) sudah matang dan siap ditinjau.

Fitur andalannya, **Parallel Worktrees**, membawa otomatisasi ke level berikutnya. Codex sanggup membelah diri untuk mengerjakan beberapa branch Git yang berbeda secara bersamaan:

* Memperbarui seluruh fungsi API yang sudah *deprecated* di seluruh repo.
* Menulis puluhan unit test untuk berkas-berkas yang baru saja dirombak.
* Menyinkronkan styling komponen agar patuh pada design system baru.

Gaya penulisan kode yang dihasilkan Codex sangat konsisten dengan codebase yang sudah ada. Daya ingatnya terhadap preferensi penulisan tergolong tajam untuk pekerjaan berskala panjang. 

Kelemahannya, Codex kurang peka terhadap prompt bernuansa estetika atau perancangan kreatif yang butuh penalaran visual mendalam. Codex bertindak layaknya *probabilistic builder* yang terkadang mengambil jalan pintas, malas menyelesaikan detail rumit, atau menyisipkan *placeholder* palsu yang harus Anda bersihkan manual.

---

## Head-to-Head: Claude Code vs Google Antigravity vs Codex

Berikut adalah ringkasan perbandingan arsitektur, keunggulan, dan kelemahan dari ketiga raksasa dev AI ini:

| Parameter Evaluasi | Claude Code | Google Antigravity | OpenAI Codex |
| :--- | :--- | :--- | :--- |
| **Arsitektur Utama** | Agen CLI otonom (*terminal-native*) | Dedicated IDE (Fork VS Code) | Mesin Otomasi Cloud (*Sandboxed*) |
| **Integrasi Workspace** | Terminal, Ekstensi VS Code, Zed App | Lingkungan VS Code, Ekosistem Google, Open VSX | Git Sandbox, Notifikasi Pull Request |
| **Fitur Kunci** | *Transparent reasoning*, Refactor multi-file | Mission Control (Multi-agen), Built-in Browser | Parallel Worktrees, Batch Processing |
| **Kelebihan Nyata** | Pemahaman konteks sangat dalam, eksekusi prompt kreatif presisi | Transisi mulus manual-AI, orkestrasi multi-agen visual | Sangat efisien untuk volume besar, memori gaya kode rapi |
| **Bottleneck & Minus** | Boros token, kurva belajar CLI, risiko *code truncation* | Masalah stabilitas, kuota membingungkan, dependensi Node.js | Lemah di penalaran desain, rawan menghasilkan kode *placeholder* |
| **Use Case Paling Pas** | Proyek baru dari nol, refactor rumit, eksplorasi arsitektur | Migrasi database, integrasi cloud, dashboard kompleks | Pemeliharaan repo besar, update dependensi massal |

---

## Menentukan Pilihan: Realita di Lapangan

Menilai siapa yang terbaik tidak bisa disamaratakan. Semua kembali pada jenis masalah yang sedang Anda hadapi di terminal setiap hari.

Google Antigravity menawarkan integrasi IDE yang memikat bagi developer yang ingin tetap memegang kendali manual tanpa kehilangan kekuatan otomasi multi-agen. Kendati demikian, klaim superioritas IDE ini sering diperdebatkan di komunitas, mengingat Claude Code dan Codex juga bisa diintegrasikan langsung ke VS Code melalui ekstensinya masing-masing.

Claude Code tetap menjadi standar emas jika Anda membutuhkan penalaran logika tingkat tinggi dan implementasi desain kreatif dalam sekali percobaan. Sementara itu, Codex adalah pilihan paling rasional bagi tim korporat yang harus merawat repositori raksasa multi-bulan dengan ribuan baris tugas repetitif.

Banyak developer kawakan kini justru memilih jalur hibrida: meracik arsitektur dan prompt detail menggunakan ketajaman nalar Claude, lalu mengeksekusi alur kerja paralelnya lewat Antigravity atau Codex. Fleksibilitas tooling semacam ini jauh lebih penting daripada terjebak fanatisme pada satu platform.

Ulasan mendalam uji coba sebulan penuh memakai Claude Code, Google Antigravity, dan Codex untuk refactoring hingga migrasi database. Temukan mana yang paling efisien untuk proyek nyata.

Uji Tempur 30 Hari AI Dev: Claude Code, Google Antigravity, atau Codex yang Layak Masuk Workflow?

Siapa di antara kita yang tidak penasaran dengan cara kerja **teknologi terbaru berdasarkan referensi**, terutama saat kita berinteraksi dengan asisten coding AI yang semakin **cerdas**? Bagaimana mereka bisa memahami permintaan kita, membagi tugas, dan bahkan memanggil *tool* dengan aman? Sebuah proyek riset independen baru-baru ini mencoba menguak rahasia di balik layar asisten coding agentik modern seperti Claude Code.

Riset ini bukan sekadar menebak-nebak. Para peneliti menganalisis perilaku sistem yang dapat diamati secara publik, melihat *output* yang dihasilkan, berdiskusi di komunitas, dan mengumpulkan informasi publik. Hasilnya adalah rekonstruksi dan pendekatan analitis terhadap arsitektur prompt, pola koordinasi agen, serta mekanisme keamanan yang digunakan. Penting untuk diingat, ini adalah interpretasi, bukan salinan langsung dari implementasi aslinya. Implementasi sebenarnya bisa saja berbeda jauh.

Tujuan utama dari proyek ini adalah membantu para insinyur AI, peneliti, dan *developer* memahami pola arsitektur ini. Dengan begitu, kita bisa menerapkannya dalam proyek-proyek AI agentik kita sendiri. Mari kita selami lebih dalam!

## Otak Dinamis: Bagaimana System Prompt Disusun?

Salah satu temuan menarik adalah cara sistem menyusun *system prompt* secara dinamis saat *runtime*. Ini bukan *prompt* statis yang sama setiap saat, melainkan sebuah *pipeline* modular yang menyesuaikan diri dengan sesi dan kebutuhan.

Lihat tabel di bawah untuk memahami bagian-bagiannya:

| Bagian Prompt | Deskripsi | Contoh Konten |
| :------------ | :-------- | :------------ |
| **Stabil (Antar Sesi)** | Instruksi inti yang konsisten di setiap sesi. | Identitas, keamanan, konfigurasi izin, aturan gaya coding, penanganan *error*, preferensi *tool*, nada & gaya *output*. |
| **Dinamis (Per Sesi)** | Konteks yang berubah-ubah sesuai dengan sesi saat ini. | Daftar agen & *skill* yang tersedia, konteks lingkungan (OS, direktori, status Git), preferensi bahasa, instruksi server MCP aktif, aturan manajemen *context window*. |

Komponen stabil membentuk identitas dasar dan batas keamanan, sementara komponen dinamis memberikan fleksibilitas untuk beradaptasi dengan tugas dan lingkungan pengguna yang spesifik.

## Pasukan Khusus: Koordinasi Antar Sub-Agen

Asisten coding AI modern tidak bekerja sendiri. Mereka adalah tim agen-agen khusus yang berkoordinasi. Setiap agen memiliki spesialisasi tertentu, dan mereka berkomunikasi untuk mencapai tujuan.

Berikut adalah beberapa contoh agen dan pola koordinasi yang didokumentasikan:

*   **Coordinator System Prompt:** Mengatur orkestrasi multi-*worker* dengan alur kerja bertahap.
*   **Teammate Prompt Addendum:** Mendefinisikan protokol komunikasi antar-agen, memastikan mereka berbicara dalam bahasa yang sama.
*   **Verification Agent:** Berperan sebagai agen pengujian *adversarial* untuk memvalidasi implementasi kode.
*   **Explore Agent:** Berfungsi untuk eksplorasi *codebase* dalam mode hanya-baca.
*   **Agent Creation Architect:** Bertanggung jawab membuat konfigurasi agen baru berdasarkan kebutuhan spesifik.

Pola-pola ini menunjukkan betapa kompleksnya sistem koordinasi di balik layar untuk memastikan tugas dapat diselesaikan secara efisien.

## Keamanan Berlapis: Klasifikasi dan Persetujuan Otomatis

Bagaimana asisten AI bisa tahu kapan aman untuk menjalankan sebuah *tool* atau perintah? Sistem auto-persetujuan tampaknya menggunakan pendekatan multi-tahap yang cermat:

1.  **Classifier Dasar:** Ini adalah tahap awal yang menentukan apakah sebuah operasi aman atau tidak aman.
2.  **Override Konfigurasi Pengguna:** Pengguna dapat menimpa aturan dasar dengan preferensi mereka sendiri.
3.  **Validasi Cepat:** Sebuah pemeriksaan cepat dilakukan pada tahap awal untuk keputusan yang jelas.
4.  **Penalaran Tambahan:** Untuk kasus yang ambigu, sistem melakukan penalaran lebih lanjut untuk membuat keputusan yang tepat.

Ada juga **Permission Explainer** yang menganalisis risiko sebelum persetujuan *tool*, dan **Auto Mode Classifier** yang merupakan *classifier* keamanan multi-tahap untuk eksekusi otomatis. Semua ini dirancang untuk memastikan bahwa tindakan yang diambil oleh AI tetap dalam batas keamanan yang diizinkan.

## Ingatan Super: Manajemen Konteks dan Memori

Mengelola jendela konteks (jumlah informasi yang dapat diproses AI sekaligus) dan memori adalah tantangan besar. Sistem ini menggunakan strategi kompresi konteks yang cerdas.

*   **Compact Service:** Bertanggung jawab meringkas percakapan panjang agar tetap relevan dalam *context window*.
*   **Away Summary:** Memberikan ringkasan singkat ketika pengguna kembali, membantu AI mengingat konteks terakhir.
*   **Proactive Mode:** Memungkinkan operasi otonom dengan pengaturan *pacing* yang terkontrol.
*   **Memory Instruction:** Mendefinisikan hierarki pemuatan memori dan aturan *override*.

Prioritas pemuatan memori juga diatur dengan cermat, seperti berikut:

1.  Konfigurasi *enterprise* atau terkelola.
2.  Preferensi global pengguna.
3.  Instruksi level proyek.
4.  Direktori aturan proyek.
5.  *Override* lokal yang bersifat pribadi.

Sistem juga mendukung inklusi file secara transitif dan injeksi kondisional berdasarkan filter jalur, memberikan fleksibilitas dalam mengelola informasi.

## Pola Desain Kunci yang Terungkap

Riset ini mengungkap berbagai pola penting yang membentuk arsitektur asisten coding AI. Berikut adalah rangkuman kategori pola yang didokumentasikan:

| Kategori Pola | Contoh Kunci |
| :------------ | :------------ |
| **Penyusunan Prompt Inti** | Main System Prompt, Simple Mode, Default Agent Prompt |
| **Koordinasi Agen** | Coordinator System Prompt, Teammate Prompt Addendum, Verification Agent, Explore Agent |
| **Keamanan & Perizinan** | Permission Explainer, Auto Mode Classifier, Cyber Risk Instruction |
| **Manajemen Konteks** | Compact Service, Away Summary, Proactive Mode, Memory Instruction |
| **Manajemen Memori & Skill** | Session Search, Memory Selection, Remember Skill, Simplify Skill, Skillify Skill |
| **Konfigurasi & Otomasi** | Agent Creation Architect, Status Line Setup Agent, Update Config Skill, Chrome Browser Automation |

Pola-pola ini memberikan gambaran komprehensif tentang bagaimana sistem yang kompleks ini dirancang untuk berfungsi.

## Siapa yang Bisa Ambil Manfaat?

Riset independen ini sangat bermanfaat bagi beberapa kelompok:

*   **Insinyur AI** yang sedang membangun *tool* agentik mereka sendiri.
*   **Prompt Engineer** yang ingin memahami arsitektur *prompt* kelas produksi.
*   **Peneliti Keamanan** yang meneliti pengelolaan izin pada AI otonom.
*   **Pelajar dan Pengajar** yang mempelajari desain sistem multi-agen.

Proyek ini membuka wawasan baru tentang bagaimana asisten AI yang kuat dirancang dan diimplementasikan. Meskipun ini adalah rekonstruksi dan bukan implementasi asli, pola desain yang diungkapkan memberikan peta jalan berharga bagi siapa saja yang tertarik pada masa depan AI agentik.

## Referensi
https://github.com/Leonxlnx/agentic-ai-prompt-research

Sebuah penelitian independen mengungkap bagaimana asisten coding AI modern seperti Claude Code mengatur koordinasi agen, mengelola konteks, dan memastikan keamanan lewat sistem prompt dinamis.

Membongkar Arsitektur Claude Code: Cara Asisten Coding AI Mengatur Otak Agennya

Solusi praktis integrasi webmail custom ke dalam dashboard Gmail. Kelola, baca, dan kirim email domain pribadi langsung dari satu tempat tanpa ribet gonta-ganti tab.

Mengapa Kamu Masih Buka Dua Tab Terpisah? Panduan Setup Custom Webmail Langsung di Dashboard Gmail

Pelajari efisiensi merakit mesin tetas telur listrik AC otomatis dengan modal murah untuk mendongkrak hasil ternak unggas tanpa repot bolak-balik telur manual.

Otomasi Ternak Unggas: Kenapa Rakit Sendiri Mesin Penetas Telur AC Jauh Lebih Worth It Dibanding Cara Konvensional?

Pelajari bagaimana mesin tetas telur berbasis arus listrik DC bekerja menjaga suhu dan kelembapan ideal untuk mendongkrak keberhasilan penetasan telur unggas.

Mesin Tetas Telur Arus DC: Solusi Hardware Murah Buat Tingkatin Angka Penetasan Unggas

Kupas tuntas seluk-beluk mobil aki anak dengan kontrol ganda dan fitur multimedia. Pahami batas spesifikasi hardware sebelum eksekusi build sendiri.

EV Versi Mini: Membedah Mobil Listrik Aki Lengkap dengan Remote Control dan Fitur Multimedia

Pelajari cara merakit smart power strip berbasis NodeMCU dan Blynk untuk kontrol daya nirkabel serta integrasi IoT yang aman dan efisien.

Mengapa Beli Mahal Kalau Bisa Bikin Sendiri? Rancang Smart Power Strip Berbasis NodeMCU dan Blynk

Solusi tuntas mengatasi bug sistem dan software bermasalah di MacBook dengan panduan install ulang macOS lewat Internet Recovery secara aman.

#claude-code

Getting Lastest Post..

Populer Bulan Ini