Disiplin Vibe Coding: Pola TDD Bersama Autonomous Coding Agent Tanpa Halusinasi Arsitektur

Kita semua pernah merasakan euforia yang memabukkan itu. Anda membuka editor modern yang dipersenjatai agen otonom—entah itu Cursor, Claude Code, Aider, atau Roo Code—lalu mengetikkan instruksi santai dalam bahasa manusia: "Buatkan sistem autentikasi multi-tenant lengkap dengan rate limiter dan webhook handler."

Dua menit kemudian, terminal berkedip liar, puluhan berkas tercipta, dependensi terpasang otomatis, dan aplikasi langsung menyala di localhost:3000. Andrej Karpathy menamai fenomena ini vibe coding: sebuah kondisi ketika developer tidak lagi bergulat dengan tanda titik koma atau detail sintaksis, melainkan sekadar "menikmati alur", membiarkan model bahasa besar (LLM) mengambil alih kemudi penulisan kode secara penuh.

Namun, mari kita bicarakan apa yang terjadi pada jam ketiga.

Ketika basis kode melampaui angka dua ribu baris, sihir tersebut perlahan berubah menjadi mimpi buruk. Agen mulai "lupa" struktur data yang ia buat sendiri setengah jam lalu. Model mengarang metode privat yang tidak pernah eksis, menciptakan ketergantungan melingkar (circular dependencies), dan ketika Anda memintanya memperbaiki sebuah bug kecil di modul pembayaran, ia justru merusak modul inventaris tanpa peringatan.

Vibe coding tanpa disiplin rekayasa perangkat lunak bukanlah produktivitas—itu adalah penumpukan utang teknis (technical debt) dengan kecepatan kilat.

Agar kita bisa memanfaatkan kecepatan luar biasa dari agen otonom tanpa harus mewarisi basis kode rapuh yang siap meledak kapan saja, kita membutuhkan fondasi yang telah teruji selama puluhan tahun: Test-Driven Development (TDD) yang dipadukan dengan spesifikasi antarmuka yang kaku.

Anatomi Halusinasi Arsitektur pada Agen Otonom

Mengapa agen cerdas berbasis LLM yang mampu memecahkan soal algoritma rumit sering kali gagal mempertahankan integritas arsitektur proyek skala menengah?

Jawabannya terletak pada sifat stokastik dari model probabilitas dan batasan jendela konteks (context window). Ketika sebuah agen membaca instruksi umum, ia mencoba memprediksi potongan kode berikutnya berdasarkan pola pelatihan global, bukan berdasarkan kesadaran spasial atas keseluruhan sistem Anda.

┌──────────────────────────────┐
                    │      Prompt Longgar          │
                    │ ("Buat modul billing & sync")│
                    └──────────────┬───────────────┘
                                   │
                                   ▼
┌──────────────────────────────────────────────────────────────────┐
│                   Halusinasi Arsitektur:                         │
│  • Mengarang fungsi SDK yang tidak kompatibel                    │
│  • Mengubah tipe data payload tanpa sinkronisasi database        │
│  • Memecah modul menjadi lapisan abstraksi yang tidak perlu     │
│  • Melanggar pola arsitektur utama(e.g. Clean Architecture)     │
└──────────────────────────────────┬───────────────────────────────┘
                                   │
                                   ▼
                    ┌──────────────────────────────┐
                    │   Spaghetti Code Otomatis    │
                    │   (Beban kognitif berlipat)  │
                    └──────────────────────────────┘

Tanpa batasan yang presisi, agen cenderung melakukan tiga dosa besar:

1. Pelebaran Abstraksi Berlebih (Over-Engineering Drift): Agen sering menambahkan lapisan wrapper, factory, atau middleware yang tidak diminta hanya karena pola tersebut sering muncul dalam data latihannya.


2. Pergeseran Kontrak (Contract Drift): Model mengubah struktur respons JSON atau tipe parameter fungsi di satu berkas tanpa memperbarui berkas lain yang mengonsumsinya.


3. Penyelesaian Semu (Phantom Solutions): Saat menemui galat eksekusi, alih-alih memperbaiki akar masalah, agen kerap membungkus kode bermasalah dengan blok try-catch kosong atau menambahkan mock palsu agar program terlihat "berjalan".

Solusi atas masalah ini bukan dengan menulis prompt bahasa alami yang lebih panjang dan berbunga-bunga. Solusinya adalah memberi agen tersebut fungsi objektif matematis yang tidak bisa diperdebatkan: tes otomatis dan kontrak tipe (type contracts).

Simbiosis Baru: TDD Sebagai Pagar Listrik Agen

Selama dua dekade, Test-Driven Development sering dikritik karena dianggap memperlambat proses prototyping. Menulis tes terlebih dahulu menuntut energi mental yang besar sebelum kita sempat melihat hasil visual di layar.

Namun, di era agen otonom, dinamika ini berbalik 180 derajat.

Agen AI memiliki kelemahan fatal dalam intuisi arsitektur, tetapi memiliki kecepatan eksekusi yang hampir instan. Sebaliknya, manusia unggul dalam perancangan batasan sistem, tetapi lambat dalam mengetik kode implementasi berulang.

Ketika Anda menggabungkan keduanya dalam alur TDD:
Manusia bertindak sebagai Arsitek: Menentukan kontrak interface dan menulis skenario pengujian (ekspektasi input/output, edge cases, dan batas kegagalan).
Agen bertindak sebagai Mesin Implementasi: Menulis kode logika aplikasi hingga seluruh tes lolos (pass).
Automated Test Runner bertindak sebagai Hakim Obyektif: Memberikan umpan balik seketika (instant feedback loop) kepada agen setiap kali ada kegagalan, tanpa intervensi manual manusia.

┌─────────────────────────────────────────────────────────────┐
 │                MANUSIA(Arsitek Sistem)                     │
 │  1. Tentukan Interface / Schema(TypeScript / Pydantic)     │
 │  2. Tulis Test Spesifikasi(Unit & Integration Contract)    │
 └──────────────────────────────┬──────────────────────────────┘
                                │
                                ▼
 ┌─────────────────────────────────────────────────────────────┐
 │               AGEN KODING OTONOM(Implementer)              │
 │  3. Baca Kegagalan Test(Merah)                             │
 │  4. Tulis / Perbaiki Kode Implementasi                      │
 └──────────────────────────────┬──────────────────────────────┘
                                │
                                ▼
 ┌─────────────────────────────────────────────────────────────┐
 │                 TEST RUNNER(Vitest / Pytest)               │
 │               Apakah Semua Test Lolos? (Hijau)              │
 └──────────────┬───────────────────────────────┬──────────────┘
                │ TIDAK                         │ YA
                ▼                               ▼
       [Kirim Error Stack ke Agen]      [Manusia Review & Refactor]

Dalam paradigma ini, tes otomatis bukan lagi sekadar jaminan kualitas di akhir siklus pengembangan (post-facto QA), melainkan bahasa instruksi utama (prompt harness) yang mengarahkan agen langsung ke target fungsional yang dituju.

Mari kita bedah alur kerja nyata dengan studi kasus konkret: membangun modul AI Token Usage Tracker & Dynamic Router yang bertugas mencatat konsumsi token LLM dan mengalihkan traffic ke penyedia cadangan secara otomatis jika terjadi lonjakan latensi atau rate limit.

Langkah awal bukan meminta AI membuat fungsionalitas, melainkan memintanya mengunci interface murni tanpa implementasi logika sama sekali.

// src/contracts/token-router.interface.ts

export type ModelTier = 'fast-inference' | 'deep-reasoning';

export interface UsageRecord {
  requestId: string;
  provider: string;
  model: string;
  promptTokens: number;
  completionTokens: number;
  costUsd: number;
  latencyMs: number;
  timestamp: Date;
}

export interface RouteRequest {
  tier: ModelTier;
  maxLatencyMs?: number;
  promptPayload: {
    messages: Array<{ role: 'system' | 'user' | 'assistant'; content: string }>;
  };
}

export interface RouteResponse {
  selectedProvider: string;
  selectedModel: string;
  content: string;
  usage: UsageRecord;
}

export interface ITokenRoutingEngine {
  routeAndExecute(request: RouteRequest): Promise<RouteResponse>;
  getAccumulatedCost(timeframeHours: number): Promise<number>;
}

// src/services/__tests__/token-router.spec.ts
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { TokenRoutingEngine } from '../token-router.service';
import { ITokenRoutingEngine, RouteRequest } from '../../contracts/token-router.interface';

describe('TokenRoutingEngine Specification', () => {
  let engine: ITokenRoutingEngine;

  beforeEach(() => {
    // Inisialisasi service sebelum setiap pengujian
    engine = new TokenRoutingEngine();
  });

  it('harus memilih model deep-reasoning ketika tier requested adalah deep-reasoning', async () => {
    const request: RouteRequest = {
      tier: 'deep-reasoning',
      promptPayload: {
        messages: [{ role: 'user', content: 'Analisis arsitektur sistem ini.' }]
      }
    };

    const response = await engine.routeAndExecute(request);

    expect(response).toBeDefined();
    expect(response.selectedModel).toMatch(/(claude-3-7-sonnet|deepseek-r1)/);
    expect(response.usage.costUsd).toBeGreaterThan(0);
    expect(response.usage.latencyMs).toBeGreaterThan(0);
  });

  it('harus menghitung akumulasi biaya penggunaan secara akurat', async () => {
    const request: RouteRequest = {
      tier: 'fast-inference',
      promptPayload: {
        messages: [{ role: 'user', content: 'Ping' }]
      }
    };

    await engine.routeAndExecute(request);
    await engine.routeAndExecute(request);

    const totalCost = await engine.getAccumulatedCost(1);
    expect(totalCost).toBeGreaterThan(0);
  });
});

$ npx vitest run
FAIL src/services/__tests__/token-router.spec.ts
Error: Cannot find module '../token-router.service'

> "Implementasikan class TokenRoutingEngine di src/services/token-router.service.ts agar memenuhi seluruh kontrak pada src/contracts/token-router.interface.ts. Jalankan perintah npx vitest run secara mandiri. Jangan berhenti sampai semua skenario uji di src/services/__tests__/token-router.spec.ts berstatus passing (Hijau). Dilarang mengubah file test!"

1. Ia membuat berkas implementasi.


2. Ia menjalankan automated test runner.


3. Jika terminal menampilkan galat, ia membaca jejak tumpukan (stack trace), memperbaiki baris kode yang salah, dan mengulangi tes.


4. Ia berhenti hanya ketika seluruh indikator uji bernilai hijau.

// src/services/token-router.service.ts
import { 
  ITokenRoutingEngine, 
  RouteRequest, 
  RouteResponse, 
  UsageRecord 
} from '../contracts/token-router.interface';

export class TokenRoutingEngine implements ITokenRoutingEngine {
  private usageHistory: UsageRecord[] = [];

  async routeAndExecute(request: RouteRequest): Promise<RouteResponse> {
    const startTime = Date.now();
    
    // Logika pemilihan model berbasis tier
    const isDeepReasoning = request.tier === 'deep-reasoning';
    const selectedModel = isDeepReasoning ? 'claude-3-7-sonnet' : 'deepseek-v3';
    const selectedProvider = 'AiStudio-Unified-Gateway';

    // Simulasi respons terstruktur dari gateway
    const mockContent = isDeepReasoning 
      ? 'Hasil analisis mendalam terstruktur.' 
      : 'Respons instan.';
      
    const promptTokens = 120;
    const completionTokens = 350;
    const ratePerThousand = isDeepReasoning ? 0.003 : 0.0002;
    const costUsd = ((promptTokens + completionTokens) / 1000) * ratePerThousand;
    const latencyMs = Date.now() - startTime + 45; // Simulasi overhead jaringan

    const record: UsageRecord = {
      requestId: crypto.randomUUID(),
      provider: selectedProvider,
      model: selectedModel,
      promptTokens,
      completionTokens,
      costUsd,
      latencyMs,
      timestamp: new Date()
    };

    this.usageHistory.push(record);

    return {
      selectedProvider,
      selectedModel,
      content: mockContent,
      usage: record
    };
  }

  async getAccumulatedCost(timeframeHours: number): Promise<number> {
    const cutoff = new Date(Date.now() - timeframeHours * 3600 * 1000);
    return this.usageHistory
      .filter(item => item.timestamp >= cutoff)
      .reduce((sum, item) => sum + item.costUsd, 0);
  }
}

Satu sesi penyelesaian fitur yang melibatkan agen otonom, test runner, dan self-healing loop bisa memicu 20 hingga 50 panggilan API multi-turn dalam hitungan menit. Jika Anda menghubungkan agen Anda langsung ke penyedia model tunggal dengan kredensial kartu kredit personal, Anda akan sering tersandung masalah klasik:

1. Limitasi Laju Panggilan (Rate Limit Spikes): Agen terhenti di tengah jalan karena terkena pembatasan TPM (Tokens Per Minute).


2. Fragmentasi Kredensial & Billing: Mengelola tagihan terpisah untuk Claude (Anthropic), GPT (OpenAI), dan DeepSeek menguras waktu administratif.


3. Ketiadaan Failover Otomatis: Saat server penyedia utama mengalami kendala kapasitas, seluruh siklus kerja tim terhenti total.

┌─────────────────────────────────────────────────────────────────────────┐
│                 Alur Pengujian Agen Otonom(TDD Loop)                   │
│         (Cursor / Claude Code / Roo Code / Local Agent Framework)       │
└────────────────────────────────────┬────────────────────────────────────┘
                                     │ (Ratusan Request Otomatis/Jam)
                                     ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                   AiStudio.id API Gateway Engine                        │
│   • Multi-Model Routing(Claude 3.7, DeepSeek R1/V3, GPT-4o)            │
│   • Failover Cerdas & Auto-Retry Saat Rate Limit Terdeteksi             │
│   • Satu Saldo IDR / Pembayaran Lokal Tanpa Hambatan Valas             │
│   • Latensi Rendah Teroptimasi untuk Developer Indonesia                │
└────────────────────────────────────┬────────────────────────────────────┘
                                     │
           ┌─────────────────────────┼─────────────────────────┐
           ▼                         ▼                         ▼
  [Anthropic Infrastructure]  [DeepSeek Clusters]     [OpenAI High-Speed]

Alih-alih membiarkan agen Anda terkunci pada satu penyedia yang rentan mengalami hambatan latensi, integrasi melalui gerbang API terpadu memungkinkan agen berganti model secara dinamis. Anda dapat mengarahkan tugas reasoning berat saat perancangan arsitektur ke model penalaran tingkat tinggi, lalu mengalihkan proses iterasi penulisan kode berulang ke model yang lebih cepat dan efisien biaya—semuanya lewat satu endpoint kompatibel OpenAI dengan sistem saldo terpadu.

Nilai tertinggi seorang insinyur perangkat lunak kini bergeser menjadi:
Kejelasan Spesifikasi: Kemampuan merumuskan batasan masalah ke dalam definisi tipe dan antarmuka tanpa ambiguitas.
Kerapian Verifikasi: Kemampuan merancang skenario pengujian yang mampu menangkap edge cases ekstrem sebelum kode menyentuh server produksi.
Kurasi Arsitektur: Kemampuan menolak kode yang dihasilkan AI meskipun kode tersebut "berjalan", jika kode tersebut melanggar prinsip skalabilitas jangka panjang.

Vibe coding tanpa disiplin adalah jebakan kecepatan semu. Namun, vibe coding yang dipagari oleh disiplin Test-Driven Development, spesifikasi antarmuka yang presisi, dan didukung infrastruktur API Gateway yang stabil adalah standar baru produktivitas rekayasa perangkat lunak modern.

Biarkan agen AI mengetik ribuan baris implementasi dengan kecepatan kilat. Tugas Anda adalah memastikan arah kompasnya tidak pernah meleset satu derajat pun.

Catatan Penulis

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