S/

Kecerdasan Buatan / 23 min read

AI-Generated Code: Independent Verification Against Immutable Specifications

Satria Aji Putra
Satria Aji Putra Author
AI-Generated Code: Independent Verification Against Immutable Specifications
Note

Artikel ini dibuat dengan bantuan AI dalam penyusunan dan penulisan. Gagasan dan arsitektur yang dibahas merupakan usulan, bukan standar formal atau jaminan bahwa seluruh implementasinya telah terbukti benar.

Dari AI yang Mengklaim Kodenya Benar Menuju Sistem yang Menuntut Bukti Kebenaran

Saat ini, AI coding agent sudah bisa membaca codebase, menulis kode, membuat pengujian, hingga memperbaiki kesalahan secara mandiri. Namun, ada satu pertanyaan yang menurut saya penting: bagaimana kita tahu bahwa hasilnya benar-benar memenuhi kebutuhan, bukan sekadar lolos pengujian yang dibuat oleh agent itu sendiri?

Pada artikel kali ini, saya ingin membahas sebuah usulan pendekatan yang memisahkan implementasi dari otoritas verifikasi. Kita akan melihat peran spesifikasi yang dilindungi, formal verification, conformance testing, hingga trusted gate, sekaligus batasan dari masing-masing pendekatan tersebut.

Daftar Isi

1. Pendahuluan: Ketika AI Menjadi Developer Sekaligus Pengujinya Sendiri

Sebagai contoh, bayangkan kita memberikan tugas kepada sebuah AI coding agent untuk mengimplementasikan fitur Safe File Editing.

Persyaratannya terlihat sederhana:

  • Agent harus mengedit hanya bagian file yang diminta.
  • Jika teks yang dicari ambigu, operasi harus ditolak.
  • Jika validasi gagal, file tidak boleh berubah.
  • Perubahan tidak boleh merusak encoding atau newline.
  • Operasi bersamaan tidak boleh menyebabkan lost update yang tidak terdeteksi.

AI kemudian membaca codebase, merancang solusi, menulis implementasi dan unit test, menjalankan pengujian, lalu memperbaiki kesalahan yang ditemukan.

Setelah beberapa iterasi, agent melaporkan:

Quote

Implementation complete. All tests passed. No issues found.

Nah, apakah kita bisa langsung menyimpulkan bahwa implementasinya benar? Belum tentu.

Mungkin seluruh unit test memang berhasil dan implementasinya terlihat masuk akal. Namun, ada beberapa hal yang masih perlu kita pertanyakan.

Bagaimana jika AI tidak menguji kondisi ketika dua proses mengedit file yang sama secara bersamaan? Bagaimana jika test hanya memeriksa isi teks, tetapi tidak memeriksa integritas byte? Bagaimana jika agent mengubah expected output agar sesuai dengan implementasi yang sebenarnya keliru?

Lebih jauh lagi, bagaimana jika AI menginterpretasikan persyaratan secara berbeda dari maksud kita?

Masalahnya bukan semata-mata AI menghasilkan kode yang salah. Permasalahan yang lebih mendasar adalah sistem yang sama menghasilkan implementasi, menentukan kecukupan pengujian, dan menyatakan bahwa hasilnya benar.

Bahkan ketika proses tersebut menggunakan beberapa subagent untuk melakukan code review, kita masih perlu mempertanyakan apakah seluruh pemeriksaan benar-benar mencakup kontrak yang dimaksud.

Dari situ muncul pertanyaan: bagaimana jika AI tetap bebas membuat implementasi, tetapi tidak menentukan sendiri apakah implementasi tersebut memenuhi spesifikasi?

Dalam artikel ini, saya menyebut usulan tersebut AI-Generated Implementation, Independently Verified Against an Immutable Specification. Intinya, kita memisahkan pihak yang membuat implementasi, spesifikasi perilaku yang disepakati, dan pihak yang berwenang memverifikasi hasilnya.

Tujuannya bukan menciptakan AI yang tidak pernah salah. Tujuannya adalah membangun lingkungan rekayasa perangkat lunak tempat kesalahan yang tercakup oleh kontrak dapat dideteksi dan ditolak melalui mekanisme yang tidak bergantung pada keyakinan AI.

2. Mengapa Pendekatan AI Coding Saat Ini Belum Cukup?

AI coding agents semakin mampu melakukan pekerjaan pengembangan software secara otonom.

Agent dapat memahami struktur repository, mengubah banyak file, menjalankan command-line tools, menggunakan browser, menulis test, dan mendelegasikan pekerjaan kepada agent lain.

Kemampuan ini tentu membantu produktivitas. Akan tetapi, semakin banyak pekerjaan yang diserahkan kepada agent, semakin penting pula cara kita memeriksa hasilnya.

2.1. Instruksi Natural Language Tidak Sama dengan Kontrak yang Dapat Ditegakkan

Misalnya kita memberikan instruksi:

Quote

Implementasikan file editing yang aman, tanpa race condition, dan pastikan semua error ditangani dengan benar.

Instruksi ini menyampaikan tujuan, tetapi belum mendefinisikan perilaku yang dapat diverifikasi secara objektif.

Apa definisi aman? Apakah semua perubahan harus atomik? Apa yang dimaksud race condition dalam konteks operasi ini? Apa yang harus terjadi ketika proses crash setelah perubahan file berhasil dilakukan, tetapi sebelum respons dikirimkan?

Dua engineer yang kompeten dapat menghasilkan implementasi berbeda dari instruksi yang sama.

AI juga menghadapi ambiguitas serupa.

Karena itu, kepatuhan terhadap prompt tidak dapat menggantikan kepatuhan terhadap kontrak yang eksplisit.

Prompt dapat mengarahkan perilaku agent, sedangkan kontrak yang dapat dieksekusi atau dibuktikan memberikan dasar untuk memeriksa hasilnya.

2.2. Self-Review Memiliki Batas

Agent dapat melakukan self-review, dan subagent terpisah dapat menemukan kesalahan yang terlewat.

Namun, menambahkan reviewer tidak otomatis menghasilkan verifikasi independen dalam arti keamanan.

Jika implementer dan reviewer menggunakan asumsi yang sama, menerima spesifikasi yang salah, atau dapat mengubah kriteria pengujian yang sama, keduanya mungkin menyetujui implementasi yang tidak sesuai dengan kebutuhan awal.

Di sini kita perlu membedakan dua hal:

  • Independent reasoning: pemeriksaan dilakukan oleh proses atau agent yang berpikir secara terpisah.
  • Independent enforcement: keputusan kelulusan dikendalikan oleh mekanisme yang otoritasnya berada di luar kendali implementer.

Keduanya bermanfaat, tetapi tidak setara.

Sebuah subagent dapat menjadi reviewer independen secara proses. Namun, jika subagent tersebut dan coding agent sama-sama dapat mengubah seluruh test suite dan kebijakan kelulusan, hasil review belum memiliki batas kepercayaan yang kuat.

2.3. Passing Tests Tidak Berarti Semua Requirements Terpenuhi

Unit test mengevaluasi perilaku terhadap input atau skenario tertentu.

Jika sebuah fungsi berhasil melewati 500 unit test, kita mengetahui bahwa fungsi tersebut memenuhi ekspektasi pada pengujian yang dijalankan.

Kita belum membuktikan bahwa fungsi tersebut benar untuk seluruh kemungkinan input, urutan eksekusi, dan kondisi lingkungan.

Property-based testing, fuzzing, dan model-based testing dapat memperluas pemeriksaan secara signifikan. Namun, cakupan setiap teknik tetap harus dijelaskan.

Bukan berarti testing tidak berguna, ya. Pengujian tetap sangat penting. Yang perlu dihindari adalah menganggap hasil tests passed otomatis setara dengan implementasi yang telah terbukti benar untuk seluruh kondisi.

3. Gagasan Utama: Memisahkan Implementasi dari Otoritas Kebenaran

Agar lebih mudah dibayangkan, usulan ini bertumpu pada tiga komponen utama:

3.1. Authoritative Specification

Spesifikasi merupakan sumber kebenaran yang mendefinisikan perilaku yang diharapkan dari sistem.

Spesifikasi tersebut tidak harus seluruhnya ditulis menggunakan bahasa formal. Sebagian requirement dapat disajikan dalam natural language yang terstruktur, sementara requirement kritis diterjemahkan menjadi formal laws, invariants, dan executable contracts.

Hal terpenting adalah setiap persyaratan memiliki makna yang jelas, kriteria penerimaan yang dapat diperiksa, dan mekanisme verifikasi yang sesuai.

3.2. AI Implementation Agent

AI bertanggung jawab menghasilkan implementasi berdasarkan spesifikasi.

Agent bebas memilih algoritma, struktur internal, dan pendekatan implementasi selama hasilnya memenuhi kontrak dan batasan yang berlaku.

AI juga dapat menghasilkan formal proofs, unit tests, integration tests, dan artefak lain yang diperlukan untuk verifikasi.

Namun, agent tidak berwenang menurunkan standar kelulusan hanya karena implementasinya sulit memenuhi requirement.

3.3. Independent Verification Authority

Komponen ketiga adalah mekanisme yang memeriksa hasil implementasi berdasarkan spesifikasi yang telah disetujui.

Pemeriksaan tersebut dapat melibatkan:

  • Formal proof checking.
  • Conformance testing.
  • Model checking.
  • Unit, integration, dan regression testing.
  • Static analysis serta security checks.
  • Pemeriksaan integritas spesifikasi dan artefak.

Keputusan akhirnya dibuat berdasarkan hasil pemeriksaan yang dapat direproduksi, bukan berdasarkan klaim AI.

Dengan demikian, AI bertindak sebagai implementation producer, sedangkan verifier bertindak sebagai acceptance authority dalam batas kewenangan yang telah ditetapkan.

4. Apa Arti Immutable Specification?

Kata immutable dalam konsep ini perlu dipahami secara tepat.

Immutable tidak berarti spesifikasi tidak boleh berubah selamanya.

Software berkembang. Requirement dapat diperbaiki, diperluas, atau diganti. Bahkan sebuah spesifikasi formal dapat ditemukan mengandung kesalahan.

Yang dimaksud adalah:

Spesifikasi yang telah disetujui tidak boleh dimodifikasi secara sepihak selama implementasi dan verifikasi terhadap versi tersebut berlangsung.

Sebagai contoh, setiap versi memiliki proses persetujuan dan menjadi acuan verifikasinya masing-masing:

flowchart TD
    V1["Specification v1"] --> A1["Disetujui dan dibekukan"]
    A1 --> I1["Implementation A"]
    I1 --> T1["Verification A terhadap v1"]
    A1 --> P2["Usulan perubahan v2"]
    P2 --> R2["Independent review"]
    R2 --> A2["Specification v2 disetujui"]
    A2 --> B2["Baseline verifikasi baru"]

Jika ternyata requirement v1 salah, kita tetap bisa memperbaikinya melalui revisi yang disetujui. Yang tidak boleh dilakukan adalah mengubah v1 secara diam-diam agar implementasi terlihat lulus.

Di tingkat teknis, integritas spesifikasi dapat dijaga menggunakan version control, cryptographic hashes, protected branches, access controls, dan penyimpanan artefak yang dikelola oleh trusted verification environment.

Hash tidak dengan sendirinya menjamin otoritas spesifikasi. Hash hanya membuktikan kesesuaian terhadap nilai referensi tertentu. Nilai referensi dan mekanisme persetujuannya juga harus berasal dari sumber tepercaya.

Dengan demikian, immutable specification sesungguhnya berarti approved, versioned, and protected specification snapshot.

5. Specification Engineering: Bagian yang Paling Menentukan

Sebelum membahas verifier, ada satu hal penting yang perlu kita ingat:

Verifier yang sangat kuat tetap tidak dapat menjamin terpenuhinya requirement yang tidak pernah dinyatakan dalam spesifikasi.

Jika spesifikasi keliru, implementasi dapat memenuhi seluruh kontrak yang tertulis sekaligus tetap gagal memenuhi kebutuhan pengguna.

Karena itu, specification engineering bukan sekadar tahap pendahuluan. Ia adalah bagian fundamental dari mekanisme correctness.

5.1. Mengubah Requirement Menjadi Kontrak

Kembali pada contoh Safe File Editing.

Requirement awal:

Quote

Jika operasi edit gagal, file harus tetap identik dengan kondisi sebelumnya.

Sekilas requirement ini terlihat jelas. Namun, kondisi yang disebut gagal ternyata bisa berbeda-beda.

Misalnya:

  • Validasi gagal sebelum proses commit.
  • Proses penyimpanan gagal sebelum commit.
  • Proses crash ketika operasi commit berlangsung.
  • File telah berhasil diganti, tetapi respons ke caller gagal dikirimkan.

Kondisi-kondisi tersebut tidak selalu memiliki semantik yang sama.

Untuk kasus kegagalan validasi sebelum commit, kita dapat mendefinisikan kontrak:

text
Given:
    F0 = file bytes before operation

When:
    operation returns VALIDATION_FAILED

Then:
    F1 = F0
    no persistent modification was committed

Secara matematis:

ValidationFailed ⇒ FileAfter = FileBefore

Pernyataan tersebut jauh lebih spesifik daripada sekadar error must not modify the file.

Kita juga perlu mendefinisikan model observasi untuk crash, termasuk apakah hasil operasi dapat menjadi INDETERMINATE, bagaimana recovery dilakukan, dan apa yang dianggap sebagai commit yang sah.

Dengan spesifikasi seperti ini, AI tidak memiliki keleluasaan untuk memilih sendiri interpretasi kegagalan setelah kode selesai ditulis.

5.2. Requirements Harus Memiliki Identitas dan Evidence

Setiap requirement penting sebaiknya memiliki identifier yang stabil.

Contoh:

RequirementKontrakMetode verifikasi
REQ-001Target edit harus unikConformance test
REQ-002Validasi gagal tidak mengubah byte fileProperty-based test
REQ-003Perubahan hanya terjadi pada targetFormal proof pada transformasi
REQ-004Konflik concurrent write harus terdeteksiModel checking dan concurrency tests
REQ-005Format newline dipertahankan sesuai kontrakByte-level conformance test

Tabel ini bisa menjadi dasar Requirement–Evidence Traceability, yaitu hubungan antara setiap requirement dan bukti pemeriksaannya.

Jadi, kita tidak hanya mengetahui berapa banyak test yang berhasil, tetapi juga requirement apa yang diuji atau dibuktikan oleh setiap pemeriksaan.

Jika REQ-004 tidak memiliki evidence, hasil keseluruhan tidak boleh dinyatakan memenuhi seluruh kontrak hanya karena semua test lain berhasil.

Namun, tautan requirement ke test juga tidak membuktikan bahwa test tersebut memadai. Kecukupan oracle, test design, dan hubungan proof dengan implementasi tetap perlu dievaluasi.

6. Formal Verification: Dari Ekspektasi Menjadi Properti yang Dapat Dibuktikan

Formal verification menawarkan pendekatan yang berbeda dari pengujian berbasis sampel. Alih-alih hanya menjalankan kode dengan beberapa input, kita mencoba membuktikan properti tertentu berdasarkan model matematis, semantik program, dan asumsi yang dinyatakan.

Contohnya adalah membuktikan bahwa sebuah fungsi transformasi byte selalu mempertahankan prefix dan suffix yang berada di luar area penggantian.

Untuk fungsi murni yang menerima input byte array dan menghasilkan output byte array, properti semacam ini relatif lebih mudah dinyatakan dibandingkan properti menyeluruh sebuah sistem filesystem.

Hal ini menunjukkan bahwa formal verification sebaiknya digunakan pada bagian sistem yang memiliki kontrak jelas dan dapat dimodelkan secara tepat.

6.1. Bend dan Law-Driven Development

Salah satu pendekatan menarik adalah Bend 2, yang memperkenalkan alur kerja Law-Driven Development.

Dalam pendekatan tersebut, aturan program dapat dinyatakan menggunakan LAWS.bend, sedangkan pembuktiannya disediakan melalui PROOF.bend.

Bend menyediakan pemeriksaan proof, termasuk mode --verdict yang melakukan pemeriksaan tambahan menggunakan kernel yang diformalisasi dalam Lean.

Contoh perintahnya:

bash
bend PROOF.bend --verdict

Jika pembuktian tidak memenuhi ketentuan checker, pemeriksaan dapat menolak artefak tersebut.

Pendekatan ini menarik untuk AI coding karena AI tidak cukup hanya menulis fungsi. Ia juga dapat diwajibkan menyediakan bukti yang dapat diperiksa secara mekanis.

Note

Bend bukan solusi universal untuk seluruh jenis verifikasi. Proof pada Bend tidak otomatis membuktikan implementasi dalam bahasa lain; jaminannya tetap mengikuti cakupan semantik, asumsi, dan trusted computing base yang relevan.

6.2. Alternatif dan Pelengkap

Dafny merupakan alternatif untuk pengembangan berbasis kontrak dan verifikasi statis. Dafny mendukung specification constructs seperti preconditions, postconditions, frame specifications, serta verifikasi menggunakan SMT-based tooling.

Sementara itu, TLA+ lebih cocok untuk memodelkan state transitions, concurrency, dan distributed protocols.

Pemilihan alat seharusnya mengikuti sifat requirement.

Sebagai contoh, transformasi data murni dapat diverifikasi menggunakan proof-oriented programming, sedangkan protokol koordinasi dua proses yang mengakses resource bersama mungkin lebih mudah dianalisis menggunakan model checker.

Tidak ada keharusan menggunakan seluruh alat tersebut pada setiap fitur.

7. The Missing Bridge: Bukti Model Bukan Otomatis Bukti Implementasi

Menurut saya, ini adalah tantangan teknis terpenting dalam pendekatan ini.

Misalnya sebuah perusahaan mengembangkan production library menggunakan Rust, sementara spesifikasi formal dan reference model ditulis menggunakan Bend.

Kemudian AI berhasil membuat seluruh proof Bend lulus.

Apakah library Rust tersebut otomatis terbukti benar?

Tidak.

Bukti formal atas reference model hanya membuktikan properti yang berlaku pada model tersebut, sesuai dengan asumsi dan semantik verifier.

Sementara itu, library Rust merupakan implementasi terpisah.

Hubungan keduanya harus diperiksa.

Secara sederhana, hubungan yang perlu kita periksa kurang lebih seperti ini:

flowchart TD
    S["Approved Specification"] --> L["Formal Laws"]
    L --> M["Bend Reference Model"]
    M --> P["Formal Proof"]
    P --> V["Verified Model"]
    S --> I["Rust Implementation"]
    V -. "Kesesuaian perlu diperiksa" .-> I
    I --> C["Conformance Verification"]
    V --> C

Ada beberapa pendekatan untuk membangun hubungan tersebut:

  1. Direct verification: jika tool dan bahasa mendukungnya, properti dibuktikan terhadap implementasi yang benar-benar akan dijalankan.
  2. Refinement verification: dibuktikan bahwa perilaku implementasi konkret merupakan penyempurnaan yang sah dari spesifikasi abstrak.
  3. Model-based conformance testing: model digunakan sebagai oracle, kemudian perilaku implementasi dibandingkan dengannya melalui kasus pengujian yang relevan.

Pendekatan ketiga sering lebih mudah diterapkan pada proyek dengan bahasa pemrograman yang beragam.

Namun, model-based testing tidak setara dengan bukti matematis bahwa setiap eksekusi implementasi akan memenuhi model.

Perbedaan tingkat jaminan ini wajib dipertahankan dalam verification report.

8. Verification Runner: Menjadikan Verifikasi sebagai Sistem Penegakan

Agar konsep ini dapat digunakan secara praktis dalam berbagai proyek, kita dapat membuat sebuah Policy-Driven Verification Runner.

Runner merupakan CLI atau komponen eksekusi yang mengoordinasikan pemeriksaan terhadap implementasi.

Contoh antarmuka:

bash
verify run

Runner dapat menjalankan build, unit test, integration test, formal proof checker, conformance suite, dan pemeriksaan keamanan yang diwajibkan.

Namun, runner tidak hanya bertugas mengeksekusi command.

Ia juga harus memastikan bahwa pemeriksaan yang diperlukan oleh kebijakan benar-benar dijalankan dan hasilnya memenuhi kriteria kelulusan.

Sebagai ilustrasi, sebuah policy dapat berbentuk:

yaml
version: 1

checks:
  - id: build
    command: cargo build --locked
    required: true

  - id: tests
    command: cargo test --locked
    required: true

  - id: bend-proof
    command: bend PROOF.bend --verdict
    required: true

  - id: conformance
    command: cargo test --test conformance
    required: true
Note

Format YAML di atas hanya ilustrasi rancangan verification policy, bukan standar atau implementasi CLI tertentu.

Pada implementasi nyata, runner harus menentukan bagaimana mendeteksi pemeriksaan yang gagal, tidak dijalankan, timeout, atau menghasilkan keluaran yang tidak dapat ditafsirkan.

Untuk formal proof, jika diperlukan, runner dapat melakukan pemeriksaan tambahan terhadap keberadaan prohibited assumptions, unsafe constructs, atau ketidaksesuaian cakupan proof dengan requirement yang diklaim.

Runner juga perlu menghindari ketergantungan pada teks output semata, seperti mencari tulisan PASS dari stdout tanpa memeriksa exit status dan integritas proses.

9. Dua Lingkungan Verifikasi: Development dan Trusted Gate

Di sinilah perbedaan antara menjalankan test dan memiliki sistem enforcement menjadi penting.

Bayangkan AI agent mempunyai akses read, write, edit, exec, dan subagent.

Agent dapat menulis kode, memodifikasi test, kemudian menjalankan:

bash
verify run

Hasilnya menunjukkan semua pemeriksaan berhasil.

Tetapi bagaimana jika agent sebelumnya mengubah verification policy agar beberapa test tidak lagi diwajibkan?

Bagaimana jika agent mengganti test yang gagal dengan assertion yang lebih lemah?

Jika seluruh mekanisme pengujian berada dalam workspace yang dapat dimodifikasi agent, hasilnya tetap berguna sebagai feedback selama pengembangan. Namun, hasil tersebut belum menjadi bukti independen yang kuat.

Karena itu, saya mengusulkan dua lingkungan verifikasi berikut.

Local Verification

Local verification digunakan selama AI mengembangkan fitur.

Agent dapat menjalankan runner sebanyak yang diperlukan, memeriksa diagnostics, memperbaiki implementasi, dan mengulang pengujian.

Tujuannya mempercepat feedback loop.

Hasilnya dapat diklasifikasikan sebagai LOCALLY_VALIDATED.

Trusted Verification

Trusted verification dijalankan oleh lingkungan yang memiliki otoritas terpisah dari AI implementation agent.

Lingkungan ini mengambil approved specification, verification policy, dan protected test suite dari sumber tepercaya.

Kemudian, ia memeriksa revisi implementasi yang tepat, menjalankan pemeriksaan yang diwajibkan, dan menghasilkan verification evidence.

Hasil tersebut dapat digunakan sebagai syarat merge atau release.

Yang perlu ditekankan: independensi tidak harus berarti menggunakan organisasi lain atau LLM lain. Independensi berarti implementer tidak memiliki kemampuan untuk memodifikasi kebijakan dan hasil verifikasi final secara sepihak.

Trusted gate juga harus mengisolasi eksekusi kode proyek, karena build scripts dan tests dapat menjalankan instruksi yang tidak dipercaya. Isolasi tersebut perlu mencakup batas akses filesystem, network, credentials, dan resource yang relevan.

10. End-to-End Workflow

Alur lengkapnya dapat digambarkan sebagai berikut:

flowchart TD
    Request["User Feature Request"] --> Spec["Specification Engineering"]
    Spec --> Review["Specification Review"]
    Review --> Approved["Approved Specification: Version + Digest"]
    Approved --> Agent["AI Coding Agent"]
    Agent --> Code["Implementation"]
    Agent --> Proof["Proof Artifacts jika diperlukan"]
    Code --> Local["Local Verification"]
    Proof --> Local
    Local --> LocalResult{"Hasil local verification"}
    LocalResult -- "FAIL" --> Repair["AI Repair"]
    Repair --> Agent
    LocalResult -- "PASS" --> Gate["Trusted Gate"]
    Gate --> GateResult{"Hasil trusted gate"}
    GateResult -- "FAIL" --> Repair
    GateResult -- "PASS" --> Eligible["Eligible untuk Merge / Release"]
    LocalResult -- "INCOMPLETE" --> Blocked["Belum terverifikasi"]
    GateResult -- "INCOMPLETE" --> Blocked

Agar lebih jelas, workflow tersebut dapat dibagi menjadi enam tahap berikut.

Tahap pertama — Specification Engineering. AI membantu menerjemahkan kebutuhan menjadi requirements, contracts, invariants, dan acceptance criteria. Review harus memastikan bahwa spesifikasi mencerminkan maksud pengguna dan tidak menghilangkan perilaku penting.

Tahap kedua — Specification Approval. Spesifikasi disetujui oleh otoritas yang ditentukan proyek, misalnya maintainer atau product owner. Versi tersebut menjadi baseline yang tidak dapat diubah sepihak selama implementasi.

Tahap ketiga — AI Implementation. Coding agent membaca spesifikasi, mengimplementasikan fitur, membuat tests, serta menghasilkan proof artifacts jika diperlukan.

Tahap keempat — Local Verification. Agent menjalankan verification runner, menerima hasil, dan memperbaiki kesalahan. Iterasi berlanjut selama masih ada perbaikan yang masuk akal dan tidak ada blocker yang menghentikan pekerjaan.

Tahap kelima — Trusted Verification. Setelah implementasi siap, trusted environment mengambil revisi kode dan spesifikasi yang ditentukan. Seluruh mandatory checks dijalankan berdasarkan policy yang dilindungi.

Tahap keenam — Acceptance Decision. Jika seluruh requirement wajib mempunyai evidence yang memadai dan seluruh gate lulus, revisi tersebut dinyatakan eligible untuk merge atau release. Jika ada pemeriksaan wajib yang gagal atau tidak dapat diselesaikan, perubahan ditolak atau ditandai belum terverifikasi.

Proses approval dan release dapat disesuaikan dengan kebutuhan organisasi. Pada proyek pribadi, maintainer tunggal mungkin menjadi otoritas persetujuan. Pada sistem berisiko tinggi, persetujuan dapat memerlukan review tambahan.

11. Bagaimana Mencegah AI Memanipulasi Proses Verifikasi?

Sistem penegakan tidak boleh hanya melindungi implementasi dari bug. Ia juga harus melindungi mekanisme verifikasinya sendiri.

Contoh ancaman yang perlu dipertimbangkan adalah perubahan spesifikasi tanpa persetujuan, penghapusan test, penonaktifan mandatory checks, penggunaan proof yang tidak mencakup implementasi, manipulasi konfigurasi CI, dan penggantian kode setelah proses verifikasi berhasil.

Untuk mengatasinya, kita memerlukan trust boundary yang nyata.

Implementer boleh mengubah source code dan mengusulkan proof. Namun, approved specification, protected tests, dan verification policy harus dikelola melalui mekanisme dengan hak akses terpisah.

Trusted runner juga harus memeriksa identitas input yang diverifikasi.

Secara konseptual, evidence perlu diikat pada:

  • Versi atau digest spesifikasi.
  • Commit atau digest implementasi.
  • Versi atau digest verification policy.
  • Identitas toolchain dan lingkungan eksekusi.
  • Pemeriksaan yang dijalankan beserta hasilnya.
  • Keputusan akhir verifikasi.

Dengan demikian, hasil PASS untuk commit A tidak boleh digunakan untuk menyetujui commit B yang belum diperiksa.

Jika sumber kode berubah setelah verifikasi, revisi baru harus menjalani pemeriksaan ulang sesuai policy.

Dalam konteks keamanan supply chain, konsep integritas artefak dan provenance ini memiliki hubungan dengan prinsip-prinsip yang dibahas dalam SLSA. Namun, penerapan arsitektur ini tidak otomatis membuat suatu proyek memenuhi level SLSA tertentu.

12. Tingkat Jaminan Harus Dinyatakan Secara Jujur

Salah satu risiko terbesar dari sistem seperti ini adalah menghasilkan rasa aman yang berlebihan.

Misalnya sebuah verification report menampilkan:

text
ALL CHECKS PASSED

Kalimat tersebut dapat menyesatkan apabila tidak dijelaskan pemeriksaan apa yang dilakukan.

Saya menyarankan evidence diklasifikasikan berdasarkan jenis jaminannya.

Status evidenceMakna
TestedPerilaku lulus pengujian yang dijalankan
Model CheckedProperti berlaku dalam model dan ruang pemeriksaan yang ditentukan
Formally ProvenProperti tertentu dibuktikan berdasarkan semantik dan asumsi formal
Refinement VerifiedHubungan kesesuaian antara implementasi dan spesifikasi telah dibuktikan
UnverifiedEvidence yang dibutuhkan belum tersedia atau belum memadai

Kategori tersebut bukan urutan kualitas yang otomatis berlaku untuk semua situasi. Setiap metode memeriksa aspek yang berbeda.

Sebagai contoh, formal proof terhadap algoritma transformasi tidak serta-merta memberikan jaminan tentang behavior filesystem ketika terjadi disk failure.

Demikian pula, fuzzing dapat menemukan bug yang relevan tetapi tidak dimodelkan dalam formal specification.

Sistem yang baik harus menggabungkan evidence sesuai kebutuhan, bukan sekadar mengumpulkan jumlah PASS sebanyak mungkin.

Keputusan akhir juga perlu menggunakan status yang jelas.

PASS berarti seluruh pemeriksaan yang diwajibkan oleh policy berhasil.

FAIL berarti setidaknya satu pemeriksaan wajib menemukan pelanggaran.

INCOMPLETE berarti evidence belum lengkap, misalnya karena timeout, tool tidak tersedia, atau verifikasi belum dijalankan.

Warning

Dalam sistem fail-closed, INCOMPLETE tidak boleh diperlakukan sebagai PASS. Pemeriksaan yang belum selesai bukan berarti berhasil.

13. Apakah Pendekatan Ini Membutuhkan Banyak Agent?

Tidak.

Arsitektur ini tidak mengharuskan penggunaan puluhan subagent, multi-agent voting, ataupun agent yang saling meninjau tanpa batas.

Satu coding agent yang memiliki akses ke tool standar sudah cukup untuk menjalankan implementasi dan local verification.

Subagent dapat digunakan secara kondisional, misalnya untuk specification review atau independent code review ketika kompleksitas pekerjaan membutuhkannya.

Sementara itu, trusted verification runner tidak harus berupa AI.

Justru untuk pemeriksaan yang dapat dieksekusi secara deterministik, CLI, proof checker, test runner, dan protected CI pipeline lebih sesuai dibandingkan meminta LLM menilai apakah hasilnya benar.

Dengan demikian, sistem dapat tetap sederhana:

flowchart LR
    Agent["Coding Agent"] --> Tools["read / write / edit / exec"]
    Agent --> Subagent["Subagent opsional"]
    Agent --> Local["verify run: local verification"]
    Local --> Checks["Build, Tests, Proof, dan Conformance"]
    Code["Revisi implementasi"] --> Gate["External Trusted Gate"]
    Spec["Protected Specification"] --> Gate
    Policy["Protected Verification Policy"] --> Gate
    Gate --> Execution["Independent Execution"]
    Execution --> Decision["Acceptance Decision"]

Agent tidak perlu mengetahui seluruh detail internal verifier.

Cukup tersedia antarmuka yang konsisten untuk menjalankan pemeriksaan dan menerima diagnostics.

Hal ini juga membuat pendekatan tersebut relatif mudah digunakan kembali pada berbagai codebase dan bahasa pemrograman.

14. Apakah Biaya Verifikasinya Sepadan?

Formal verification membutuhkan biaya.

Spesifikasi harus dirancang. Proof dapat membutuhkan effort tambahan. Model checking tidak selalu mudah, khususnya untuk sistem dengan state space yang besar.

Selain itu, requirement yang tidak jelas dapat menyebabkan AI menghabiskan banyak iterasi untuk menyelesaikan persoalan yang sebenarnya belum didefinisikan dengan baik.

Karena itu, saya tidak menyarankan agar semua baris kode diwajibkan memiliki formal proof.

Pendekatan yang lebih realistis adalah menerapkan Risk-Adaptive Verification.

Sebagai gambaran, pilihan pemeriksaannya bisa berbeda sesuai risikonya:

  • UI sederhana: build, type checking, dan integration tests mungkin sudah memadai.
  • Parser, serialization, atau transformasi data: property-based testing dan proof pada fungsi kritis dapat memberikan nilai tambahan.
  • Concurrent file operations atau distributed protocols: model checking dan fault-injection tests bisa lebih relevan.
  • Keamanan, otorisasi, atau data sensitif: cakupan pembuktian dan review mungkin perlu diperluas.

Pilihan tersebut harus didasarkan pada tingkat risiko dan jenis kesalahan yang ingin dicegah.

Tujuan pendekatan ini bukan memaksimalkan jumlah metode verifikasi, melainkan memaksimalkan jaminan yang relevan terhadap biaya engineering yang dikeluarkan.

15. Keterbatasan dan Masalah yang Belum Selesai

Pendekatan ini bukan metode ajaib yang dapat menghilangkan seluruh kesalahan software.

Sebelum mencoba pendekatan ini, ada beberapa keterbatasan yang menurut saya perlu diperhatikan.

Specification Gap

Natural language requirement mungkin tidak lengkap. AI dapat menghasilkan formal specification yang valid secara sintaksis tetapi tidak menggambarkan kebutuhan pengguna secara utuh.

Karena itu, kebutuhan akan specification review tidak hilang meskipun formal verifier tersedia.

Model–Implementation Gap

Model formal dan implementasi production dapat menggunakan bahasa, runtime, dan abstraksi yang berbeda.

Selama hubungan keduanya belum dibuktikan, kita tidak dapat menyimpulkan bahwa pembuktian model berlaku untuk seluruh implementasi.

Trusted Computing Base

Formal verification bergantung pada komponen dan asumsi yang dipercaya, seperti proof checker, compiler, runtime, library eksternal, atau perangkat keras pada tingkat tertentu.

Ukuran dan kompleksitas trusted computing base memengaruhi tingkat keyakinan yang masuk akal terhadap hasil verifikasi.

Verification Coverage

Sistem dapat memiliki banyak test dan proof, tetapi tetap tidak mencakup sebuah requirement penting.

Oleh karena itu, jumlah test bukan metrik tunggal yang memadai. Requirement coverage dan kualitas evidence juga perlu dievaluasi.

Economic Overhead

Proses specification engineering, verification, dan review dapat mengonsumsi waktu komputasi serta token AI yang signifikan.

Untuk perubahan berisiko rendah, prosedur yang terlalu berat justru dapat menurunkan produktivitas tanpa memberikan manfaat yang sepadan.

Governance and Human Responsibility

Siapa yang berhak menyetujui specification changes? Bagaimana jika pengguna sendiri memberikan persyaratan yang saling bertentangan? Bagaimana menilai apakah spesifikasi memenuhi kebutuhan bisnis?

Pertanyaan-pertanyaan tersebut tidak dapat diselesaikan oleh proof checker saja.

Sistem verifikasi harus tetap memiliki mekanisme governance yang jelas.

16. Roadmap Implementasi yang Realistis

Kalau ingin mencoba pendekatan ini di proyek nyata, menurut saya lebih baik kita memulainya secara bertahap daripada langsung menerapkan semua metode sekaligus.

Tahap 1 — Specification-Driven Testing

Mulai dengan requirement IDs, acceptance criteria, dan conformance tests yang dapat ditelusuri kembali ke spesifikasi.

Pada tahap ini, formal proof belum harus diwajibkan.

Tujuannya membuktikan bahwa pemisahan specification–implementation–verification dapat diterapkan dalam workflow pengembangan sehari-hari.

Tahap 2 — Policy-Driven Verification Runner

Bangun CLI sederhana yang membaca verification policy, menjalankan checks, mengumpulkan evidence, dan menghasilkan keputusan secara deterministik.

Pastikan runner membedakan failed checks dengan pemeriksaan yang tidak dapat diselesaikan.

Tahap 3 — Trusted Verification Gate

Pisahkan local validation dari final acceptance.

Gunakan protected specification, immutable revision references, dan isolated execution environment agar coding agent tidak dapat memalsukan kelulusan final.

Tahap 4 — Selective Formal Verification

Tambahkan Bend, Dafny, TLA+, atau alat lain sesuai karakteristik requirement.

Pilih properti kritis yang cukup jelas untuk diformalkan dan memiliki manfaat nyata ketika dibuktikan.

Tahap 5 — Automated Evidence and Coverage Analysis

Hubungkan requirements dengan proof artifacts, test results, model-checking outputs, dan commit identity.

Tujuannya menghasilkan laporan yang tidak hanya menyatakan PASS, tetapi juga menunjukkan apa yang telah diperiksa, bagaimana pemeriksaannya dilakukan, dan apa yang masih belum terverifikasi.

Pendekatan bertahap ini memungkinkan kita mengukur efektivitas setiap lapisan sebelum menambah kompleksitas.

17. Pertanyaan Terbuka untuk Komunitas AI Engineering

Sampai di sini, konsep ini masih menyisakan beberapa pertanyaan yang menurut saya menarik untuk didiskusikan bersama.

Pertama, siapa yang seharusnya memiliki otoritas atas specification?

Apakah manusia harus selalu menyetujui setiap perubahan, atau bisakah AI mengusulkan dan memperbarui spesifikasi secara otonom di bawah kebijakan yang dibatasi?

Kedua, bagaimana cara terbaik menghubungkan formal reference model dengan production implementation lintas bahasa?

Apakah model-based conformance testing sudah cukup untuk sebagian besar aplikasi, atau diperlukan pendekatan refinement verification yang lebih luas?

Ketiga, bagaimana kita mengukur specification coverage secara objektif?

Apakah keberadaan test untuk setiap requirement cukup, atau kita memerlukan indikator yang lebih kuat untuk menilai kualitas dan kelengkapan evidence?

Keempat, seberapa besar overhead verifikasi yang masih masuk akal dalam agentic software development?

Bagaimana membangun mekanisme adaptive verification yang dapat memberikan jaminan tambahan tanpa membebani setiap perubahan kecil?

Kelima, mungkinkah verification runner menjadi sebuah komponen generik yang dapat digunakan lintas AI coding agents, bahasa pemrograman, dan codebase?

Jika memungkinkan, komponen seperti itu dapat memisahkan enforcement dari implementasi agent, sehingga berbagai coding agent dapat menggunakan kontrak dan pemeriksaan yang sama.

Pertanyaan-pertanyaan ini layak dibahas bukan hanya dari sisi formal methods, tetapi juga dari sisi software architecture, developer experience, security engineering, dan economics of AI-assisted development.

18. Kesimpulan: Dari Trusting the Agent Menuju Verifying the Artifact

AI coding agents membawa perubahan besar dalam cara kita membangun software. Namun, semakin otonom agent tersebut, semakin penting pula cara kita memeriksa dan mempercayai hasil pekerjaannya.

Kita dapat terus meningkatkan kualitas model, memperbaiki prompts, menambahkan subagents, dan mengembangkan mekanisme self-review. Semua itu berguna.

Namun, kemampuan menghasilkan kode dan kemampuan membuktikan bahwa kode tersebut memenuhi kontrak merupakan dua tanggung jawab yang berbeda.

AI-Generated Implementation, Independently Verified Against an Immutable Specification mengusulkan agar kedua tanggung jawab tersebut dipisahkan secara eksplisit.

AI menghasilkan implementasi. Spesifikasi yang disetujui mendefinisikan perilaku yang harus dipenuhi. Verifier independen memeriksa evidence terhadap spesifikasi tersebut. Trusted gate menentukan apakah hasil implementasi dapat diterima.

Formal verification dapat memperkuat jaminan untuk properti yang dapat dibuktikan. Conformance testing membantu menghubungkan kontrak dengan implementasi nyata. Model checking membantu menganalisis perilaku stateful dan concurrent. Verification policy memastikan pemeriksaan wajib tidak dapat dilewati tanpa otorisasi.

Tidak satu pun dari teknik tersebut memberikan jaminan universal bahwa software tidak memiliki bug. Namun, jika digabungkan dengan tepat, teknik-teknik tersebut dapat membangun proses pengembangan yang lebih terukur, dapat diaudit, dan lebih tahan terhadap kesalahan implementasi AI.

Pada akhirnya, usulan ini bukan tentang membuat AI selalu benar. Tujuannya adalah agar penerimaan implementasi tidak hanya bergantung pada klaim AI yang membuatnya, tetapi pada spesifikasi dan bukti yang bisa diperiksa.

Quote

The agent proposes. The specification defines. The verifier checks. The trusted gate decides.

Dan mungkin, ketika AI semakin banyak menulis software secara otonom, pemisahan tanggung jawab tersebut akan menjadi salah satu prinsip penting dalam rekayasa perangkat lunak generasi berikutnya.


Referensi dan Bacaan Lanjutan

  1. Bend 2 — Official Repository — Konsep Law-Driven Development dan pendekatan proof-based programming.
  2. Bend 2 — Official Guide — Dokumentasi laws, proofs, dan mekanisme verdict.
  3. Dafny — Documentation — Specification constructs dan static program verification.
  4. TLA+ — A High-Level View — Formal modeling dan analisis sistem stateful atau concurrent.
  5. SLSA — Software Supply Chain Security Specification — Source integrity, build provenance, dan verifikasi artefak software.

Catatan: Arsitektur yang diajukan dalam artikel ini merupakan proposal desain yang menggabungkan beberapa pendekatan rekayasa perangkat lunak. Ini bukan nama standar formal yang telah ditetapkan atau klaim bahwa keseluruhan workflow telah dibuktikan secara matematis.

Discovery / Related