Ketika Andrej Karpathy melontarkan istilah vibe coding—sebuah gaya pemrograman di mana developer cukup mengetikkan intensi dalam bahasa alami, mendengarkan musik, dan membiarkan AI menulis ribuan baris kode—dunia rekayasa perangkat lunak terbelah menjadi dua kubu. Kubu pertama merayakannya sebagai puncak otomatisasi. Kubu kedua, yang setiap hari bergulat dengan codebase warisan (legacy system) puluhan ribu baris, hanya tersenyum getir.

Bagi siapa pun yang pernah mencoba vibe coding di luar aplikasi mainan to-do list, ada dinding tebal yang menghadang tepat di baris ke-10.000: Amnesia Kontekstual.

Anda meminta agen terminal seperti Claude Code, Aider, atau Cursor CLI untuk merombak lapisan otentikasi JWT ke session-based auth. Di lima menit pertama, segalanya tampak ajaib. Namun pada iterasi ketujuh, agen tersebut mendadak "lupa" bahwa proyek Anda menggunakan arsitektur event-driven, menghapus middleware rate limiting yang susah payah dibangun kemarin, dan mengganti query builder Prisma dengan raw SQL rentan injeksi.

Vibe coding tingkat dasar mengandalkan keberuntungan dan jendela konteks (context window) murni. Vibe coding lanjutan—yang dipraktikkan oleh engineer yang benar-benar merilis produk ke production—adalah disiplin rekayasa sistem memori, context injection, dan orkestrasi state.

1. Ilusi Jendela Konteks: Mengapa Model Cerdas Tetap Mengacau

Ada miskonsepsi umum bahwa jendela konteks 1 juta hingga 2 juta token menyelesaikan semua masalah. Logikanya tampak sederhana: jika kita bisa memasukkan seluruh repositori ke dalam satu prompt, agen AI seharusnya paham segalanya, bukan?

Kenyataannya tidak demikian.

python
[Prompt Panjang: 200k Token Repositori]
┌────────────────────────────────────────────────────────┐
│  Awal Prompt: Instruksi Sistem & Arsitektur(Diingat)   │  <-- High Attention
├────────────────────────────────────────────────────────┤
│                                                        │
│  Tengah: 45 File Controller, Model, Helper             │  <-- "Lost in the Middle"
│  (Perhatian LLM melemah, degradasi logika logika)      │      (Zona Halusinasi)
│                                                        │
├────────────────────────────────────────────────────────┤
│  Akhir Prompt: Instruksi Refactoring Terbaru(Diingat) │  <-- High Attention
└────────────────────────────────────────────────────────┘

Riset seputar fenomena “Lost in the Middle” membuktikan bahwa mekanisme self-attention pada transformer mengalami degradasi akurasi ketika informasi krusial terkubur di tengah tumpukan teks yang masif.

Ketika Anda membanjiri terminal assistant dengan seluruh isi folder /src, Anda memicu tiga masalah fatal:

  1. Attention Dilution: Perhatian model terdistraksi oleh file utilitas sepele, sehingga mengabaikan batas arsitektur (architectural boundaries).

  2. Context Drift: Jawaban pada iterasi ke-10 mulai bertentangan dengan keputusan struktural yang disepakati pada iterasi ke-2.

  3. Token Burnout: Biaya komputasi dan latensi melonjak tajam karena setiap ketukan Enter mengirim ulang ratusan ribu token yang tidak relevan.

Jendela konteks itu ibarat RAM pada komputer, bukan SSD. Jika Anda tidak merancang mekanisme penyimpanan status (state persistence) yang terstruktur di luar memori kerja model, agen AI Anda akan selalu menderita demensia parsial saat melakukan refactoring skala besar.

2. Taksonomi Memori: Tiga Tingkat Retensi AI Terminal

Untuk membangun asisten terminal yang tangguh, kita harus memisahkan memori AI menjadi tiga lapisan yang saling melengkapi.

python
┌──────────────────────────────────────────────────────────────┐
│ 1. PROCEDURAL MEMORY(.skill / rules)                        │
│    "Bagaimana cara kita bekerja di repo ini?"                 │
├──────────────────────────────────────────────────────────────┤
│ 2. EPISODIC & ARCHITECTURAL MEMORY(ADR / Memory State)      │
│    "Keputusan apa yang sudah diambil & mengapa?"             │
├──────────────────────────────────────────────────────────────┤
│ 3. WORKING MEMORY(Active Context / AST Diff)                │
│    "File mana yang sedang diedit detik ini?"                 │
└──────────────────────────────────────────────────────────────┘

Berikut adalah perbandingan karakteristik masing-masing lapisan memori:

ParameterWorking Memory (L1)Episodic Memory (L2)Procedural Memory (L3)
Bentuk FisikPesan chat aktif, diff Git saat iniFile State (.ai/memory.json, ADR)File .skill, .cursorrules, AGENT.md
Masa HidupHilang saat sesi terminal di-resetBertahan antar-sesi refactoringPermanen di dalam repositori Git
Fokus UtamaPerubahan sintaks lokalLogika domain, dependensi modulKonvensi kode, tool chain, SOP uji coba
Beban TokenSangat dinamis (1k - 100k token)Ringkas (2k - 5k token)Statis & deterministik (500 - 2k token)
Toleransi ErorRendah (bisa memicu bug instan)Sedang (menyebabkan inkonsistensi)Kritis (menentukan arah arsitektur)

3. Anatomi File SKILL: Menjadikan Prosedur Bersifat Deterministik

Mayoritas developer membiarkan AI menebak cara menjalankan test, cara mengisolasi environment, atau format commit. Inilah celah awal terjadinya regresi kode.

Kita perlu menyusun file SKILL—sebuah dokumen deklaratif yang memberi tahu AI agen bukan hanya apa yang harus dilakukan, melainkan batasan mutlak apa yang dilarang disentuh.

Berikut struktur ideal folder arsitektur AI di dalam repositori:

python
my-large-project/
├── .ai/
│   ├── skills/
│   │   ├── refactor-clean-arch.md
│   │   ├── database-migration.md
│   │   └── security-audit.md
│   ├── state/
│   │   ├── active-plan.md
│   │   └── architectural-decisions.json
│   └── context-manifest.yaml
├── AGENTS.md
└── src/

Contoh File SKILL: refactor-clean-arch.md

Simpan file ini di .ai/skills/refactor-clean-arch.md. Format ini menggunakan kombinasi Markdown dan batasan logis yang ketat:

markdown
---
name: Clean Architecture Refactor Protocol
trigger: "saat melakukan refactor domain entity, use case, atau repository"
enforcement: STRICT
---

# PROTOKOL REFACTORING DOMAIN

Setiap kali Anda diminta merombak kode di folder `src/core/` atau `src/modules/`, patuhi aturan invariant berikut:

## 1. Invariant Boundaries (Hukum Tak Boleh Dilanggar)
- `Domain Entities` TIDAK BOLEH mengimpor modul dari `Infrastructure` (Prisma, TypeORM, Axios, Redis).
- Semua operasi eksternal WAJIB melalui *Interface Ports* di folder `ports/`.
- DILARANG menghapus fungsi publik tanpa menandainya dengan `@deprecated` terlebih dahulu.

## 2. Pre-Execution Checklist
Sebelum menulis atau mengedit baris kode:
1. Baca status aktif di `.ai/state/active-plan.md`.
2. Jalankan `npm run test:unit` untuk memastikan baseline hijau.
3. Deklarasikan file mana saja yang akan terdampak ke terminal sebelum melakukan edit.

## 3. Verification Step
Setelah mengubah kode:
1. Jalankan unit test spesifik: `npm run test:unit -- {path-to-test}`.
2. Jika test gagal, ROLLBACK perubahan dan periksa kembali definisi tipe, jangan teruskan menambah file baru.

Dengan menyematkan file SKILL ini ke dalam sistem injeksi agen terminal, AI tidak lagi bertindak sebagai intern yang serampangan menebak arsitektur, melainkan sebagai senior engineer yang mematuhi SOP tim.

4. Context Injection Pipeline: Mempertahankan State Antar-Sesi

Masalah terbesar saat refactoring proyek besar adalah hilangnya benang merah ketika Anda harus me-restart sesi terminal karena token limit sudah penuh.

Solusinya adalah menerapkan Persistent Memory Loop berbasis dua file sederhana:

  1. architectural-decisions.json (State permanen)

  2. active-plan.md (State transisi)

python
[User Request: "Ganti auth ke Supabase"]
                    │
                    ▼
┌────────────────────────────────────────┐
│ Context Injector Hook                  │
│ Membaca:                               │
│  - AGENTS.md                           │
│  - .ai/state/architectural-decisions   │
│  - .ai/state/active-plan.md            │
└───────────────────┬────────────────────┘
                    │ (Prompt Diperkaya)
                    ▼
┌────────────────────────────────────────┐
│ AI Terminal Assistant                  │
│ (Claude Code / Aider / Custom CLI)     │
└───────────────────┬────────────────────┘
                    │
                    ▼
┌────────────────────────────────────────┐
│ Eksekusi Kode & Update State Otomatis │
│ Menulis kembali progres ke             │
│ .ai/state/active-plan.md               │
└────────────────────────────────────────┘

Format active-plan.md untuk Refactoring Kompleks

File ini berfungsi sebagai checkpoint dinamis yang diperbarui oleh AI pada setiap langkah penyelesaian tugas:

markdown
# ACTIVE REFACTORING STATE

## Goal: Migrasi Modul Billing dari Stripe v2 ke Stripe v3 + Webhook Idempotency

### Phase Status:
- [x] Phase 1: Buat interface adapter `IBillingService`
- [x] Phase 2: Implementasi `StripeV3Adapter` baru di `/infra`
- [/] Phase 3: Update `BillingUseCase` untuk menangani Idempotency Keys(IN PROGRESS)
- [ ] Phase 4: Integrasi Webhook Handler & Unit Test
- [ ] Phase 5: Hapus legacy SDK & bersihkan dependensi

### Architectural Invariants Disepakati:
- Idempotency key disimpan di Redis dengan TTL 24 jam.
- Tidak ada transaksi database yang menggantung(*blocking transaction*) selama panggilan API pihak ketiga.

### Current Blockers / Notes:
- Menunggu penyesuaian skema payload webhook `invoice.payment_succeeded`.

Ketika sesi AI terminal Anda mengalami crash atau Anda memutuskan melanjutkan pekerjaan esok hari, Anda cukup menjalankan perintah singkat:

bash
aider --message "Lanjutkan pekerjaan berdasarkan .ai/state/active-plan.md"

Agen langsung membaca posisi terakhir, memahami batas-batas logika yang sudah dibangun, dan melanjutkan penulisan kode tanpa membuang token untuk menganalisis ulang repositori dari nol.

5. Panduan Praktis: Menata State Refactoring Langkah demi Langkah

Mari kita terapkan teori ini ke dalam skenario nyata: Anda memimpin perombakan lapisan database query dari monolitik raw query ke repository pattern pada 30 endpoint API.

python
+---------------------------------------------------------------+
|                      WORKFLOW PROTOKOL                        |
|                                                               |
|  [Fase 1] Mapping Repo Map -> Inisialisasi AST Index          |
|      |                                                        |
|      v                                                        |
|  [Fase 2] Freezing Rules -> Kunci file SKILL & ADR            |
|      |                                                        |
|      v                                                        |
|  [Fase 3] Eksekusi Bertahap(Chunking 3-5 File per Sesi)      |
|      |                                                        |
|      v                                                        |
|  [Fase 4] Commit & Sync State -> Update .ai/state/active-plan |
+---------------------------------------------------------------+

Langkah 1: Buat Index Konteks Tanpa Mengirim Seluruh Kode

Alih-alih menyuruh agen terminal membaca seluruh file .ts atau .py, buatlah type declaration skeleton atau file map tree. Sebagian besar tool modern seperti Aider secara otomatis membangun Repo Map berbasis ctags/tree-sitter.

Pastikan file konfigurasi agen Anda (misalnya .aider.conf.yml atau CLAUDE.md) mengecualikan folder biner dan build artifact:

yaml
# .aider.conf.yml
read:
  - .ai/skills/refactor-clean-arch.md
  - .ai/state/active-plan.md
ignore:
  - dist/
  - build/
  - node_modules/
  - coverage/
  - "*.lock"
auto-commits: false

Langkah 2: Kunci Keputusan Arsitektur Terlebih Dahulu

Sebelum baris kode pertama disentuh, perintahkan AI untuk bertindak sebagai Software Architect dan menuliskan rencana detail ke dalam state:

> Prompt Injeksi:
> "Bertindaklah sebagai Lead Architect. Baca seluruh definisi antarmuka di src/core/ports/. Rancang rencana refactoring bertahap untuk modul User Management. Jangan tulis implementasi kode sekarang. Tuliskan breakdown tugas dan daftar dependensi ke .ai/state/active-plan.md."

Langkah 3: Eksekusi Berbasis Chunking Terisolasi

Batasi cakupan perombakan maksimal 3 sampai 5 file dalam satu siklus iterasi (turn).
bash
# Contoh eksekusi pada Aider / Claude Code CLI
$ aider src/core/domain/user.entity.ts src/core/ports/user.repository.ts

Instruksikan agen:
> "Implementasikan Phase 3 dari .ai/state/active-plan.md. Hanya modifikasi file yang telah dibuka. Setelah selesai, jalankan npm test dan update checklist di active-plan.md."

Dengan cara ini, memori kerja model selalu terfokus 100% pada masalah lokal, sementara koordinasi global dijaga oleh file state fisik di dalam disk.

6. Efisiensi Token & Orkestrasi Model Lewat AiStudio.id API Gateway

Mengoperasikan agen terminal dengan strategi context injection yang rapat dan berlapis menghadirkan tantangan baru: biaya token dan batas kecepatan (rate limits).

Ketika Anda menjalankan sesi refactoring sepanjang hari, sebuah agen terminal tingkat lanjut dapat melakukan ratusan kali panggilan API di balik layar. Agen akan memvalidasi linter, membaca pohon file (tree), hingga memeriksa tipe data (type checking). Jika seluruh proses pemetaan konteks awal dialirkan ke model flagship berkemampuan penalaran tinggi dengan harga token premium, pengeluaran komputasi Anda akan membengkak dalam hitungan jam.

Di sinilah peran AiStudio.id API Gateway menjadi sangat strategis bagi alur kerja developer.

python
┌────────────────────────────────────────────────────────┐
│             AI Terminal Assistant(CLI)                │
└──────────────────────────┬─────────────────────────────┘
                           │ (OpenAI-Compatible Call)
                           ▼
┌────────────────────────────────────────────────────────┐
│             AiStudio.id API Gateway                    │
│   - Unified Endpoint Router                            │
│   - Dynamic Model Switching(Sonnet / DeepSeek / Qwen) │
│   - Smart Cost & Token Rate Management                 │
└──────────────┬──────────────────────────┬──────────────┘
               │                          │
      (High Reasoning Tasks)      (Map & Tool Pre-filtering)
               ▼                          ▼
┌──────────────────────────────┐ ┌───────────────────────┐
│ Claude 3.7 Sonnet /          │ │ DeepSeek-V3 /         │
│ OpenAI o3-mini               │ │ Qwen-2.5-Coder        │
│ (Refactoring Logika Rumit)   │ │ (AST Indexing & Lint) │
└──────────────────────────────┘ └───────────────────────┘

Dengan mengalirkan lalu lintas terminal assistant melalui satu pintu gerbang API yang terpadu:

  1. Routing Model Sesuai Beban Kerja: Anda dapat mengonfigurasi model berbiaya sangat efisien seperti DeepSeek-V3 atau Qwen-2.5-Coder untuk tugas-tugas mekanis (seperti mengekstrak interface, indexing, dan merapikan dokumentasi), lalu beralih secara instan ke model penalaran tingkat tinggi seperti Claude 3.7 Sonnet atau seri Reasoning saat menyusun arsitektur sistem yang rumit.
  2. Satu Kunci untuk Semua Provider: Tanpa perlu repot mengelola belasan kartu kredit korporat atau terjebak limit akun terpisah di masing-masing penyedia AI global, developer cukup menghubungkan base_url asisten terminal ke gateway AiStudio.id.
  3. Resiliensi Koneksi: Saat proses refactoring kritis sedang berjalan di terminal dan penyedia utama mengalami rate limit atau downtime, gateway dapat mengarahkan request ke model ekuivalen tanpa merusak sesi active memory yang sedang berjalan di IDE Anda.

Mengatur memori AI bukan hanya soal menyusun file Markdown, melainkan juga memastikan infrastruktur komputasi di baliknya efisien dan siap diajak maraton menangani jutaan baris kode.

7. Dari Mengetik Sintaks Menuju Orkestrasi Sistem

Pergeseran terbesar dalam rekayasa perangkat lunak modern bukanlah hilangnya peran pemrogram, melainkan transformasi peran itu sendiri.

Developer yang mengandalkan vibe coding mentah tanpa pengelolaan state akan segera frustrasi begitu proyek mereka melampaui fase prototipe. Sebaliknya, mereka yang menguasai teknik context injection, membagi memori secara terstruktur (Procedural, Episodic, Working), dan mengorkestrasi model AI secara presisi akan memproduksi perangkat lunak dengan kecepatan yang tak terbayangkan sebelumnya.

Anda bukan lagi juru ketik yang menyusun loop dan array satu per satu. Anda adalah pengatur sistem kognitif—seorang konduktor orkestra yang memastikan setiap instrumen kecerdasan buatan membaca partitur musik yang sama, berada di tangga nada yang tepat, dan tidak pernah melupakan bait lagu yang telah dimainkan sebelumnya.

Mulai rapikan folder .ai di repositori Anda hari ini, susun file SKILL pertama Anda, dan rasakan bagaimana asisten terminal Anda bertransformasi dari sekadar generator teks menjadi rekan duet arsitektur yang solid.

Catatan Penulis

Sandra
Sandra

> Sandra menulis seputar rekayasa prompt, efisiensi arsitektur AI, dan produk digital di AiStudio.id.