LLM Bisa Pre-inspeksi Kode Anda. Ia Tidak Bisa Menjalankan Rapat.

Jawaban Singkatnya Tidak, tapi Jawaban Panjangnya Menghemat Waktu Anda

Inspeksi Fagan penuh membutuhkan seorang moderator, seorang reader, dua hingga empat inspector, dan author. Tim menghabiskan dua jam untuk meninjau sekitar 250 baris kode dengan kecepatan 125 baris per jam. Itu setara delapan hingga dua belas jam-orang untuk perubahan kecil.

Sebuah LLM dapat membaca 250 baris dalam waktu kurang dari satu detik. Ia dapat menjalankan checklist, menandai pola mencurigakan, dan menghasilkan log defect sebelum manusia membuka file.

Bukan berarti ia dapat menggantikan tim. Artinya, tim tidak boleh memulai rapat sebelum LLM menyelesaikan tugasnya.

Apa yang Sebenarnya Dapat Dilakukan LLM dalam Inspeksi Fagan

Inspeksi Fagan memiliki empat peran berbeda. Setiap peran memiliki tugas yang dipetakan secara berbeda terhadap apa yang dapat dan tidak dapat dilakukan LLM.

Moderator merencanakan inspeksi, menegakkan kriteria masuk, dan menjaga rapat tetap pada jalurnya. Sebuah LLM dapat menghasilkan checklist, memverifikasi bahwa tes lulus sebelum inspeksi, dan memperkirakan waktu berdasarkan jumlah baris. Ia tidak dapat mengetahui apakah ruangan penuh engineer tengah melenceng ke perdebatan desain. Peran moderator bersifat sosial, dan LLM tidak sosial.

Reader memparafrasekan kode dengan lantang selama rapat untuk memaksa kelompok memproses logika pada kecepatan pemahaman, bukan kecepatan membaca cepat. Sebuah LLM dapat merangkum kode, tetapi tidak dapat memperlambat ruangan penuh manusia. Nilai nyata reader adalah penegakan sosial. LLM tidak punya pengaruh.

Inspector menemukan defect dengan memeriksa kode terhadap checklist dan pengetahuan domain. Di sinilah LLM paling berguna. Ia dapat memeriksa null dereference, kebocoran resource, jalur error yang tidak ditangani, dan kesalahan off-by-one lebih cepat daripada manusia mana pun. Ia tidak lelah. Ia tidak melewati fungsi utilitas membosankan karena terlihat aman.

Author menjawab pertanyaan dan memperbaiki defect. LLM tidak dapat menggantikan author karena ia tidak menulis kode dan tidak dapat memverifikasi maksud.

Jadi jawaban realistisnya bukan penggantian. Itu adalah substitusi peran. LLM dapat berperan sebagai pre-inspector yang tak kenal lelah yang menangani bagian mekanis dari peran inspector sebelum manusia memasuki ruangan.

Di Mana LLM Benar-benar Membantu: Fase Persiapan

Fase terpenting dari inspeksi Fagan adalah persiapan. Setiap inspector meninjau materi sendirian sebelum rapat. Studi menunjukkan bahwa persiapan menemukan sekitar separuh defect yang ditemukan dalam proses penuh. Jika LLM dapat memperkuat fase tersebut, rapat manusia menjadi lebih singkat dan lebih tajam.

Berikut pendekatan praktisnya. Berikan LLM kode, checklist yang disesuaikan dengan bahasa Anda, dan prompt yang memaksa output terstruktur. Gunakan output LLM sebagai titik awal untuk inspector manusia, bukan sebagai pengganti.

Prompt lebih penting daripada model. Permintaan kabur seperti “tinjau kode ini” akan memberikan klise umum. Prompt terstruktur dengan checklist dan format output akan memberikan defect yang dapat ditindaklanjuti.

Di bawah ini adalah skrip Python yang menjalankan pre-inspeksi berbasis LLM menggunakan API yang kompatibel dengan OpenAI. Ia membaca file sumber, menerapkan checklist bergaya Fagan, dan menghasilkan log defect terstruktur.

#!/usr/bin/env python3
"""
LLM pre-inspection for Fagan-style review.
Produces structured defect log from a checklist.
"""

import argparse
import os
from pathlib import Path


def build_prompt(code: str, filepath: str, language: str) -> str:
    checklist = {
        "python": [
            "Missing null/None checks before dereferencing",
            "Unclosed file handles or missing context managers",
            "Bare except clauses that swallow exceptions",
            "Mutable default arguments in function signatures",
            "Race conditions in shared mutable state",
            "Missing input validation on public functions",
        ],
        "typescript": [
            "Non-null assertions (e.g., !) without justification",
            "Missing await on async calls",
            "Any types that should be narrowed",
            "Unhandled promise rejections",
            "Missing input validation on public functions",
        ],
        "rust": [
            "Unwrap or expect without comment explaining invariants",
            "Missing error propagation where Result is returned",
            "Unsafe blocks without safety comments",
            "Clone on large data structures in hot paths",
            "Missing input validation on public functions",
        ],
    }

    items = checklist.get(language, checklist["python"])
    checklist_text = "\n".join(f"  - {item}" for item in items)

    return (
        "You are a Fagan inspection assistant. Review the following code "
        "against the checklist. For each defect found, output a JSON object "
        "with keys: line, category, severity (minor/major/critical), description. "
        "If no defect is found for a checklist item, omit it. "
        "Be specific about line numbers and exact variable names. "
        "Do not suggest fixes. Fagan inspections only log defects, they do not solve them.\n\n"
        f"File: {filepath}\n"
        f"Language: {language}\n\n"
        "Checklist:\n"
        f"{checklist_text}\n\n"
        "Code:\n```\n"
        f"{code}\n"
        "```\n\n"
        "Output strict JSON array of defects only. No markdown, no preamble."
    )


def inspect_file(filepath: str, api_key: str, base_url: str) -> list:
    """Run LLM pre-inspection and return parsed defect list."""
    from openai import OpenAI

    path = Path(filepath)
    code = path.read_text()

    # Infer language from extension
    ext_map = {
        ".py": "python",
        ".ts": "typescript",
        ".tsx": "typescript",
        ".rs": "rust",
    }
    language = ext_map.get(path.suffix, "python")

    client = OpenAI(api_key=api_key, base_url=base_url)
    response = client.chat.completions.create(
        model=os.environ.get("INSPECTION_MODEL", "gpt-4.1-mini"),
        messages=[
            {"role": "system", "content": "You are a precise code inspection tool."},
            {"role": "user", "content": build_prompt(code, filepath, language)},
        ],
        temperature=0.2,
        max_tokens=2048,
    )

    raw = response.choices[0].message.content.strip()

    # Some models wrap JSON in markdown fences. Strip them.
    if raw.startswith("```json"):
        raw = raw[7:]
    if raw.startswith("```"):
        raw = raw[3:]
    if raw.endswith("```"):
        raw = raw[:-3]
    raw = raw.strip()

    import json
    try:
        defects = json.loads(raw)
        if not isinstance(defects, list):
            return []
        return defects
    except json.JSONDecodeError:
        print("Warning: LLM returned non-JSON output:")
        print(raw[:500])
        return []


def main():
    parser = argparse.ArgumentParser(description="LLM pre-inspection for Fagan review")
    parser.add_argument("files", nargs="+", help="Source files to pre-inspect")
    parser.add_argument("--api-key", default=os.environ.get("OPENAI_API_KEY"))
    parser.add_argument(
        "--base-url",
        default=os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
    )
    args = parser.parse_args()

    if not args.api_key:
        raise SystemExit("Error: set OPENAI_API_KEY or pass --api-key")

    all_defects = []
    for f in args.files:
        defects = inspect_file(f, args.api_key, args.base_url)
        all_defects.extend({"file": f, **d} for d in defects)

    if not all_defects:
        print("No defects flagged by LLM pre-inspection.")
        return

    print(f"LLM pre-inspection found {len(all_defects)} defect(s):\n")
    for d in all_defects:
        print(
            f"[{d['severity'].upper()}] {d['file']}:{d.get('line', '?')} "
            f"({d['category']}) {d['description']}"
        )


if __name__ == "__main__":
    main()

Instal OpenAI SDK dengan pip install openai, atur API key Anda, dan jalankan python inspect.py src/auth.py. Skrip tersebut menghasilkan log defect terstruktur yang dapat digunakan inspector manusia sebagai checklist awal.

Ini bukan inspeksi. Ini adalah persiapan. Defect masih memerlukan penilaian manusia.

Apa yang LLM Lewatkan: Defect yang Menghabiskan Biaya Nyata

Defect termahal bukanlah kesalahan sintaks. Melainkan asumsi yang salah.

Sebuah LLM akan menemukan pengecekan null yang hilang. Ia tidak akan menyadari bahwa kasus null seharusnya tidak pernah terjadi karena layanan upstream menjamin field tersebut, dan bug sesungguhnya adalah tim Anda mengubah kontrak tiga minggu lalu dan lupa memperbarui kode downstream.

Sebuah LLM akan menandai exception yang tidak ditangani. Ia tidak akan menyadari bahwa exception handler hilang karena author menganggap transaction database akan rollback secara otomatis, dan asumsi tersebut salah untuk tingkat isolasi spesifik yang digunakan tim Anda.

Ini adalah defect pada tingkat niat. Mereka memerlukan pengetahuan domain, konteks historis, dan kemampuan untuk bertanya “apa yang author anggap benar padahal tidak?” Sebuah LLM tidak memiliki akses ke asumsi-asumsi tak terdokumentasi tim Anda. Ia tidak memiliki ingatan akan keputusan arsitektur dari kuartal lalu. Ia tidak dapat melihat dokumen requirement dan menyadari bahwa kode mengimplementasikan requirement yang salah.

Inspeksi Fagan dirancang untuk menangkap defect-defect tepat ini. Inspector manusia membawa model mental dan konteks yang berbeda-beda. Ketika mereka tidak setuju tentang apa yang seharusnya dilakukan kode, celah di antara asumsi mereka adalah tempat bug nyata berada.

Sebuah LLM hanya memiliki satu model mental, dan ia dilatih pada kode publik, bukan pada codebase Anda.

Trade-off Sebenarnya: Cakupan vs. Pemahaman

Pre-inspeksi LLM memberi Anda cakupan. Ia membaca setiap baris, memeriksa setiap fungsi, dan tidak pernah terganggu oleh notifikasi Slack. Ia adalah inspector sempurna yang sempit.

Inspeksi manusia memberi Anda pemahaman. Ia menghubungkan kode dengan spesifikasi, spesifikasi dengan skema database, dan skema dengan aturan bisnis yang berubah dalam rapat sprint planning terakhir. Ini adalah satu-satunya cara untuk menemukan defect yang berada di luar kode.

Trade-offnya bukan manusia versus mesin. Melainkan mendalam versus luas.

Jika Anda menggantikan tim inspeksi dengan LLM, Anda akan menemukan lebih banyak defect tingkat sintaks dan melewatkan lebih banyak defect tingkat niat. Hasil bersihnya tergantung pada jenis bug apa yang membunuh Anda. Jika incident produksi Anda sebagian besar adalah null dereference dan kebocoran resource, LLM akan membantu. Jika incident Anda sebagian besar adalah logika bisnis yang salah dan kasus edge yang terlewat, LLM akan memberikan rasa aman yang palsu.

Cara Menjalankan Inspeksi Hibrida dalam Praktiknya

Berikut adalah alur kerja praktis yang menggunakan LLM untuk apa yang ia kuasai dan mempertahankan tim manusia untuk apa yang hanya manusia bisa lakukan.

Sebelum rapat, jalankan skrip pre-inspeksi LLM pada kode. Berikan setiap inspector manusia output tersebut ditambah kode asli. Wajibkan mereka memverifikasi atau menolak setiap temuan LLM selama persiapan individual mereka. Ini memaksa mereka untuk memeriksa baris-baris yang mungkin mereka lewati.

Selama rapat, reader tetap memparafrasekan kode dengan lantang. Inspector tetap mengangkat isu. Namun sekarang mereka memulai dengan daftar curata defect mekanis yang sudah ditriage. Waktu rapat bisa dipersingkat dari dua jam menjadi sembilan puluh menit, atau tim dapat meninjau lebih banyak kode dalam jendela waktu yang sama.

Moderator menambahkan satu tanggung jawab baru: melacak akurasi LLM. Catat berapa banyak defect yang ditandai LLM yang nyata, berapa banyak false positive, dan berapa banyak defect eksklusif manusia yang LLM lewatkan. Setelah tiga atau empat inspeksi, Anda akan tahu apakah prompt checklist Anda perlu penyetelan.

Ini adalah proses yang sama yang digunakan NASA ketika bereksperimen dengan inspeksi berbantuan alat pada tahun 1990-an. Pemeriksa otomatis menemukan defect mudah dan membiarkan defect sulit untuk manusia. Manusia berkinerja lebih baik karena mereka tidak kelelahan mental karena menemukan defect yang mudah.

Kesimpulan

Sebuah LLM tidak dapat menggantikan tim inspeksi penuh karena inspeksi bukan sekadar membaca kode. Ia adalah proses sosial terstruktur yang dirancang untuk memunculkan kesenjangan antara apa yang author asumsikan dan apa yang sebenarnya dilakukan kode.

Apa yang dapat dilakukan LLM adalah membuat tim manusia lebih efektif dengan menghilangkan beban mekanis. Ia dapat memainkan peran kelima: pre-inspector tak kenal lelah yang menyiapkan medan pertempuran sebelum manusia tiba.

Jika Anda melewatkan inspeksi karena terlalu mahal, LLM tidak membuatnya gratis. Ia membuatnya lebih singkat. Itu seringkali cukup.

FAQ

Apa itu inspeksi Fagan?

Sebuah proses review terstruktur berfase enam yang ditemukan oleh Michael Fagan di IBM pada tahun 1976. Ia menggunakan peran yang ditentukan (moderator, reader, inspector, author), persiapan individu wajib, dan rapat dengan timeout untuk menemukan defect sebelum pengujian. Ia secara konsisten melaporkan tingkat penghapusan defect 60 hingga 90 persen.

Bisakah LLM menggantikan reviewer kode manusia?

Tidak untuk defect yang paling penting. Sebuah LLM menangkap isu mekanis seperti pengecekan null yang hilang dan kebocoran resource. Ia melewatkan defect tingkat niat seperti asumsi salah tentang kontrak upstream, logika bisnis yang hilang, dan ketidakcocokan antara kode dan requirement.

Bagaimana cara mengintegrasikan LLM ke dalam inspeksi Fagan?

Gunakan LLM selama fase persiapan. Jalankan terhadap checklist, berikan outputnya kepada inspector manusia sebelum rapat, dan wajibkan mereka memverifikasi setiap temuan. Ini mempersingkat rapat dan meningkatkan fokus manusia tanpa menghilangkan penilaian manusia.

Apa yang membuat prompt checklist LLM efektif?

Spesifisitas. Prompt generik menghasilkan output generik. Prompt efektif menyebutkan kategori defect yang tepat, menuntut output JSON terstruktur, melarang proposal solusi, dan meminta nomor baris serta nama variabel yang tepat. Checklist harus cocok dengan bahasa Anda dan defect paling umum yang lolos dari tim Anda.

Cobalah pada Satu File

Pilih file yang menyebabkan incident produksi bulan lalu. Tulis checklist lima jenis defect spesifik yang menjadi perhatian tim Anda. Jalankan skrip di atas dengan checklist tersebut. Berikan outputnya kepada dua engineer yang tidak menulis file tersebut.

Bandingkan temuan LLM dengan temuan manusia. Hitung tumpang tindihnya. Hitung apa yang dilewatkan masing-masing pihak. Celah itu adalah jawaban Anda.