Anda Membangun Setengah Jaring Pengaman dan Menganggapnya Sudah Selesai

Mari jujur tentang seperti apa sebenarnya pipeline kode AI kebanyakan orang saat ini.

Anda generate code dengan Cursor atau Claude Code. Anda menjalankan tsc --noEmit karena TypeScript strict mode menangkap mismatch tipe. Anda menjalankan ESLint karena tidak ada yang ingin berdebat tentang titik koma di pull request. Mungkin Anda menjalankan dependency-cruiser karena circular imports memalukan. Tes Anda lolos. Anda rilis.

Dan Anda pikir itu adalah tumpukan deterministik.

Bukan. Itu adalah tumpukan tipe-dan-gaya. Anda telah mencegah state tidak valid dan menerapkan import boundaries, yang memang benar-benar berguna. Tetapi Anda tidak melakukan apa pun soal fakta bahwa LLM baru saja generate fungsi 180 baris dengan cyclomatic complexity yang akan membuat seorang ahli teori graf menangis. Anda tidak menangkap bahwa tiga module berbeda menyalin helper yang sama dengan nama variabel yang sedikit berbeda. Anda tidak menyadari bahwa penanganan error-nya hanyalah satu catch (e) { console.log(e) } yang duduk di bagian bawah promise chain seperti penjaga yang malas.

Kode-nya compile. Arsitekturnya bersih. Kode-nya tetap secara objektif mengerikan.

Itulah celahnya. Dan itu penting karena kode yang di-generate AI punya bakat khusus untuk memproduksi sampah persis seperti ini: valid secara struktural, compliant secara arsitektur, dan diam-diam membusuk dari dalam.

Lapisan yang Hilang Itu Sebenarnya Apa

Pikirkan perbedaan antara gedung yang lulus inspeksi insinyur struktural dan gedung yang nyaman untuk ditinggali. Inspeksi struktural memeriksa apakah gedungnya roboh. Inspeksi itu tidak memeriksa apakah shower mengalir ke wastafel dapur. Keduanya penting. Itu adalah pekerjaan yang berbeda.

Tumpukan deterministik yang sudah Anda miliki adalah insinyur struktural. Ia memeriksa:

  • Types: Bisakah nilai ini ada dalam bentuk ini?
  • Linting: Apakah sintaks mengikuti kebersihan dasar?
  • Architecture rules: Apakah import menghormati boundaries?
  • Tests: Apakah happy path berjalan tanpa crash?

Apa yang tidak diperiksanya:

  • Kompleksitas: Apakah fungsi ini melakukan begitu banyak branch sehingga tidak ada manusia yang bisa menalarinya dengan benar?
  • Duplikasi: Apakah LLM generate logika yang sama di empat tempat dengan variasi minor?
  • Penamaan: Apakah data adalah nama variabel yang bermakna, atau apakah itu setara dengan mengangkat bahu dalam pemrograman?
  • Penanganan error: Apakah error benar-benar ditangani, atau hanya ditangkap dan diabaikan?
  • Struktur: Apakah organisasi file masuk akal, atau apakah itu tempat pembuangan?
  • Komentar: Apakah bagian yang rumit dijelaskan, atau apakah pengembang berikutnya akan membutuhkan sesi pemanggilan roh?
  • Ukuran: Apakah file ini 400 baris karena memang perlu, atau karena tidak ada yang menyuruh model untuk berhenti?

Ini bukan preferensi estetika. Kompleksitas berkorelasi dengan kepadatan cacat. Duplikasi menjamin bahwa perubahan di masa depan akan inkonsisten. Nama buruk meningkatkan beban kognitif untuk setiap modifikasi berikutnya. Penanganan error yang buruk berarti kegagalan produksi tanpa jejak diagnostik.

Penelitian di sini tidak ambigu. Analisis lintas dimensi kami sendiri menemukan bahwa arsitektur keandalan berlapis hanya berfungsi ketika setiap lapisan menangkap cacat yang terlewatkan oleh lapisan sebelumnya. Jika Layer 1 Anda adalah type checking dan Layer 2 Anda adalah tests, tetapi tidak ada yang memeriksa apakah kode-nya adalah bencana maintainability, maka Anda punya lubang di tumpukan Anda. Dan kode yang di-generate AI suka jatuh melalui lubang itu karena model sangat pandai mem-generate implementasi yang terlihat masuk akal yang kebetulan menjadi mimpi buruk untuk dipelihara.

Masuklah Alat dengan Nama Kasar Itu

Ada alat bernama fuck-u-code — ya, benar, itu perintahnya — dan ia melakukan persis satu hal yang tidak dilakukan oleh alat lain di pipeline Anda. Ia menjalankan analisis kualitas kode deterministik berbasis AST di empat belas bahasa dan memberi tahu Anda persis seberapa buruk kode Anda, menggunakan metrik yang benar-benar berkorelasi dengan masalah nyata.

Inilah yang diperiksanya:

  • Kompleksitas: Skor cyclomatic dan cognitive complexity. Jika fungsi punya tujuh belas branch, ia menandainya.
  • Ukuran: Jumlah baris file dan fungsi. LLM yang generate fungsi 250 baris tidak lolos hanya karena tipenya benar.
  • Komentar: Kepadatan dan kualitas komentar. Bukan karena komentar itu mulia, tetapi karena logika kompleks tanpa penjelasan adalah perangkap pemeliharaan.
  • Penanganan error: Apakah error ditangkap, di-throw ulang, di-log, atau ditelan diam-diam.
  • Penamaan: Kualitas nama variabel dan fungsi. data, temp, handler, dan process tidak lolos.
  • Duplikasi: Blok kode yang berulang di berbagai file. Trik favorit LLM: copy-paste dengan find-and-replace.
  • Struktur: Organisasi file dan kohesi module.

Ia mengeluarkan skor keseluruhan dari 0 sampai 100. Lebih tinggi lebih baik. Ia juga mengeluarkan indeks shit-gas per file — lebih tinggi lebih buruk — sehingga Anda tahu persis file mana yang perlu perhatian pertama. Analisis berjalan sepenuhnya offline melalui parsing AST tree-sitter. Kode Anda tidak pernah meninggalkan mesin Anda. Butuh waktu kurang dari satu detik di kebanyakan proyek.

Dan inilah bagian yang seharusnya membuat Anda marah karena belum menggunakannya: biayanya nol dolar.

Alat Ini Mewujudkan Filosofinya

Yang membuat fuck-u-code menarik bukan hanya apa yang diperiksanya. Tetapi bagaimana arsitektur internalnya, karena alat itu sendiri adalah mikrokosmos sempurna dari pipeline yang seharusnya ia masuki.

Alat ini punya dua perintah:

fuck-u-code analyze .          # Deterministic AST analysis. Offline. Fast. Free.
fuck-u-code ai-review . -m gpt-4o   # AI review of the worst-scoring files. API call. Costs tokens.

Perhatikan urutannya. Perhatikan default-nya. Analisis deterministik berjalan pertama, selalu, karena tidak memerlukan API key, tidak memakan biaya, dan tidak bervariasi antar run. AI review adalah langkah kedua opsional yang hanya melihat file-file terburuk N teratas.

Ini adalah arsitektur persis yang seharusnya dimiliki pipeline Anda.

Anda tidak mengirim setiap pull request ke Greptile atau Claude Code untuk review semantik penuh. Itu memakan biaya, memakan waktu, dan — seperti yang telah kita buktikan di posting sebelumnya — menghasilkan output probabilistik yang mungkin atau mungkin tidak menandai masalah yang sama pada run berurutan. Anda menjalankan gerbang deterministik terlebih dahulu. Anda menyaring bencana struktural secara gratis, dalam milidetik, dengan hasil yang identik setiap kali. Kemudian, dan hanya kemudian, Anda mengirim yang lolos ke AI review mahal untuk analisis semantik, arsitektural, dan perilaku yang tidak bisa dilakukan oleh alat deterministik.

fuck-u-code secara harfiah mengimplementasikan ini secara internal. Perintah analyze adalah filter kualitas Layer 1 Anda. Perintah ai-review adalah penyelaman mendalam semantik Layer 2 Anda. Alat ini adalah demonstrasi dari prinsip yang ia aktifkan.

Argumen Ekonominya Hampir Menyinggung

Mari bicara soal uang sejenak, karena di sinilah kondisi industri saat ini menjadi benar-benar menjengkelkan.

Platform AI code review mengenakan biaya per pull request atau per baris kode yang di-review. Biayanya tidak besar — mungkin satu atau dua dolar per PR — tetapi bukan nol, dan skalanya mengikuti kecepatan tim Anda. Jika Anda generate kode dengan AI, kecepatan Anda lebih tinggi dari dulu, yang berarti biaya review Anda juga lebih tinggi dari dulu.

Sementara itu, fuck-u-code akan menganalisis seluruh codebase Anda, di empat belas bahasa, dalam waktu kurang dari satu detik, dan mengenakan biaya tepat nol. Ia akan menandai 20% file yang benar-benar bermasalah. Ia akan menghasilkan laporan JSON atau Markdown yang bisa dikonsumsi CI Anda. Ia akan membuat build gagal jika skor rata-rata turun di bawah ambang batas yang Anda atur.

Jika Anda menjalankan AI review di setiap PR tanpa gerbang kualitas deterministik terlebih dahulu, Anda membayar token API untuk menemukan bahwa fungsi terlalu kompleks. Itu seperti menyewa insinyur struktural untuk memberi tahu Anda rumah Anda kotor. Insinyurnya memang berkualifikasi untuk pekerjaan itu, tetapi Anda membuang-buang waktu dan uang mereka.

Pipeline yang rasional secara ekonomis adalah:

  1. AI generate kode
  2. Type check, lint, dan aturan arsitektur (tumpukan yang sudah ada)
  3. fuck-u-code analyze (gerbang kualitas yang hilang — $0, <1s)
  4. AI review (Greptile, dll. — tetapi hanya pada file yang lolos langkah 3, atau hanya ketika langkah 3 menandai pola menarik)

Ini bukan teori. Ini adalah aritmetika. Gerbang deterministik menangkap kelas masalah yang memang dirancang untuk ditangani oleh alat deterministik. AI review menangkap kelas masalah yang memerlukan pemahaman semantik. Setiap alat melakukan apa yang ia kuasai. Tidak ada yang membuang-buang token untuk kebersihan struktural.

Integrasi MCP: Dibangun untuk Alur Kerja, Bukan Tambalan

Ada satu detail lagi yang penting jika Anda serius tentang pengembangan berbantuan AI.

fuck-u-code menyertakan server MCP. Jika Anda menggunakan Claude Code, Cursor, atau alat lain yang mendukung MCP, Anda bisa memanggil fuck-u-code analyze langsung dari agent Anda. Agent tidak perlu tahu tentang AST parsing atau cyclomatic complexity. Ia memanggil alat. Alat mengembalikan laporan terstruktur. Agent bertindak berdasarkannya.

Ini penting karena menutup lingkaran. AI yang sama yang generate kode sekarang bisa menerima feedback deterministik tentang kualitas kode tersebut, dalam format yang bisa ia pahami dan tindak lanjuti. Agent bisa melihat bahwa indeks shit-gas untuk src/auth/login.ts adalah 87 dari 100 dan memutuskan untuk refactor sebelum manusia mana pun melihat PR.

Kami telah menulis sebelumnya tentang bagaimana CI adalah enforcement layer yang membuat specification-driven development menjadi nyata. Integrasi MCP berarti fuck-u-code bukan hanya gerbang CI. Ia adalah oracle kualitas yang bisa diakses agent yang pipeline generasi bisa konsultasikan secara real time.

Seperti Apa Menambahkannya

Anda tidak membutuhkan rencana migrasi. Anda butuh lima menit.

npm install -g eff-u-code
fuck-u-code analyze .              # See your current scores
fuck-u-code config init            # Generate .fuckucoderc.json

Konfigurasi ambang batas Anda. Pilih skor keseluruhan minimum. Pilih indeks shit-gas maksimum untuk setiap file individual. Tambahkan ke pre-commit hooks Anda:

# .husky/pre-commit
fuck-u-code analyze . --format json --output quality-report.json

Atau tambahkan ke CI:

# .github/workflows/quality.yml
- name: Code Quality Gate
  run: |
    npm install -g eff-u-code
    fuck-u-code analyze . --format markdown -o quality.md
    # Parse the JSON and fail if overall score < threshold

Bobotnya bisa dikonfigurasi. Jika tim Anda lebih peduli kompleksitas daripada komentar, sesuaikan bobot metrik di .fuckucoderc.json. Jika Anda ingin mengecualikan file tes, gunakan --exclude. Jika Anda ingin melihat 20 file terburuk alih-alih default 10, gunakan -t 20.

Kemudian, ketika Anda telah menyaring bencana struktural, kirim file menarik ke AI review:

fuck-u-code ai-review . -m gpt-4o -t 5   # Review only the 5 worst files

Itulah pipeline-nya. Generate. Type-check. Gerbang-kualitas. AI-review yang lolos. Rilis.

Kesimpulan Jujur

Saya tidak akan berpura-pura bahwa fuck-u-code akan menyelesaikan setiap masalah di codebase Anda. Ia tidak akan menangkap race condition. Ia tidak akan memberi tahu Anda bahwa logika autentikasi Anda punya timing attack yang halus. Ia tidak akan menggantikan property-based testing atau mutation testing atau verifikasi formal atau lapisan lain apa pun yang telah kita bahas di posting sebelumnya.

Apa yang akan ia lakukan adalah menangkap masalah membosankan, dapat diprediksi, dan mahal yang tidak ada yang tangkap saat ini. Ia akan memberi tahu Anda bahwa API handler yang di-generate AI Anda panjangnya 300 baris dan tidak punya error handling. Ia akan memberi tahu Anda bahwa tiga service berbeda menyalin logika validasi yang sama. Ia akan memberi tahu Anda bahwa setengah variabel Anda bernama data atau result dan Anda seharusnya merasa bersalah.

Ini bukan edge case. Ini adalah output default dari pipeline generate kode cepat yang tidak punya siklus umpan balik kualitas. LLM tidak lelah, tetapi ia juga tidak merasa malu. Ia akan generate kode buruk dengan keyakinan yang sama seperti generate kode baik, dan tumpukan deterministik Anda saat ini akan membiarkannya lolos karena tumpukan Anda tidak dirancang untuk memeriksa kualitas. Tumpukan itu dirancang untuk memeriksa validitas.

Validitas dan kualitas adalah hal yang berbeda. Anda membutuhkan keduanya.

fuck-u-code bukanlah jawaban lengkapnya. Ia adalah jawaban untuk pertanyaan spesifik: “Apa cara termurah, tercepat, dan paling deterministik untuk menghentikan sampah struktural yang di-generate AI agar tidak mencapai code review?”

Jawabannya adalah: parse AST, skor metriknya, gagalkan build, dan suruh model mencoba lagi.

Biayanya nol. Butuh waktu kurang dari satu detik. Dan menutup lubang di tumpukan keselamatan Anda yang mungkin tidak Anda sadari ada.