Insights AI
Meningkatkan Skala Agen Kode Otonom: Bagaimana Siklus Verifikasi dan Batasan Ketat CI Memungkinkan Pengiriman Perangkat Lunak Berkecepatan Tinggi
Podcast · Dengarkan (20 mnt)
Daftar isi
- Hambatan Kepercayaan: Mengapa Penskalaan Agen Kode Merupakan Masalah Manajemen Rekayasa
- 1. Merumuskan Masalah Inti
- 2. Menetapkan Analogi Manajemen
- Verifikasi Terprogram dan Pemetaan Fitur: Menutup Siklus Agen
- 1. Menjelaskan Mekanisme Verifikasi Langkah demi Langkah
- 2. Menguraikan Arsitektur Peta Fitur
- 3. Menguraikan Evaluasi dan Pemeliharaan Keterampilan Agen
- Batasan Arsitektur yang Ketat: Beralih dari Instruksi Lunak ke Penegakan Integrasi Berkelanjutan
- 1. Membandingkan Aturan Lunak dengan Batasan Deterministik yang Ketat
- 2. Menganalisis Studi Kasus Arsitektur "Dune"
- Otomatisasi Agen Komputasi Awan dan Implikasi Produk di Seluruh Industri
- 1. Reproduksi Bug Otonom dan Alur Kerja Awan
- 2. Demokratisasi Pengembangan di Berbagai Peran Nonteknik
- Keterbatasan Arsitektur dan Pertanyaan Rekayasa yang Belum Terjawab
- 1. Mendokumentasikan Keterbatasan Utama dan Kasus Batas
- Angka utama
- Apa yang dapat mengubah gambaran ini
- Sumber yang dikutip
Organisasi rekayasa perangkat lunak modern sedang menjalankan pergeseran paradigma mendasar, beralih dari pemrograman berpasangan dengan Kecerdasan Buatan yang dikelola secara mikro menuju armada agen otonom yang mampu mengintegrasikan ratusan hingga ribuan permintaan penggabungan kode per bulan. Sebagaimana dikemukakan Lauren Tan, seorang insinyur di SpaceXAI, penskalaan pembuatan kode oleh kecerdasan buatan pada dasarnya merupakan masalah manajemen rekayasa, bukan sekadar latihan pemberian instruksi. Ketika tim rekayasa mengandalkan pengawasan manual, pemeriksaan kode baris demi baris, dan pedoman instruksi yang lunak, pengembang manusia menjadi hambatan sinkron yang membatasi penskalaan agen. Peralihan menuju eksekusi dengan otonomi tinggi mengharuskan penggantian pengawasan manusia dengan siklus verifikasi terprogram, pemetaan fitur terstruktur, dan batasan Integrasi Berkelanjutan yang deterministik. Dengan mengodekan invarian arsitektur langsung ke dalam alat analisis statis dan perangkat verifikasi saat eksekusi, tim rekayasa dapat mendelegasikan eksekusi kepada agen komputasi awan paralel sambil secara sistematis mencegah degradasi basis kode.
Hambatan Kepercayaan: Mengapa Penskalaan Agen Kode Merupakan Masalah Manajemen Rekayasa#
1. Merumuskan Masalah Inti#
Sumber hambatan utama dalam pengiriman perangkat lunak berbantuan kecerdasan buatan adalah tidak adanya kepercayaan pengembang terhadap keluaran agen. Agen perangkat lunak sering menghalusinasikan abstraksi, keliru mendiagnosis akar penyebab, dan dengan yakin mengusulkan perbaikan yang tidak valid. Seperti diamati Lauren Tan dalam wawancara di kanal YouTube Vision Sabbat, agen sering kali "dengan yakin menyatakan bahwa mereka telah menemukan bukti penentu untuk keseratus kalinya," sementara masalah yang mendasarinya sama sekali belum terselesaikan.
Ketika tim rekayasa mencoba menskalakan penggunaan agen melalui pemrograman berpasangan tradisional dengan keterlibatan manusia dalam siklus, alur kerja dengan cepat mencapai batas mutlak. Jika seorang insinyur harus memeriksa setiap baris kode yang dihasilkan, menguji hasil kompilasi lokal secara manual, dan memverifikasi perbedaan kode, pengembang manusia menjadi satu-satunya titik yang mengharuskan proses berjalan berurutan. Hambatan sinkron ini membatasi penskalaan hingga satu atau dua agen lokal, sehingga mencegah paralelisasi yang sesungguhnya di seluruh alur kerja rekayasa.
2. Menetapkan Analogi Manajemen#
Untuk menganalisis dinamika operasional ini, Lauren Tan menarik perbandingan langsung antara pengelolaan agen kode kecerdasan buatan dan pengelolaan insinyur perangkat lunak manusia. Dalam manajemen rekayasa tradisional, manajer yang tidak memercayai bawahan langsungnya pada akhirnya akan melakukan manajemen mikro—mengawasi pengembang dari dekat, terus-menerus mengaudit permintaan penggabungan kode, dan memeriksa setiap baris kode untuk mencegah gangguan pada lingkungan produksi.
HIGH | [ Fleet Autonomy ]
| Auto-merging PRs &
| Cloud Parallelization
TRUST | /
| /
| /
| [ Micromanagement ]
LOW | Manual Prompting & 1-in-Loop
+---------------------------------------------------
LOW HIGH
VELOCITY
Penskalaan otonomi agen mengharuskan pendakian pada apa yang Tan definisikan sebagai "kurva kepercayaan." Pada tahap awal adopsi agen, pengembang bekerja secara sinkron di dalam siklus eksekusi, memberikan instruksi secara manual kepada masing-masing agen dan memeriksa setiap perbedaan kode. Menaiki kurva kepercayaan memerlukan sistem rekayasa yang menyediakan verifikasi keluaran agen secara objektif dan otomatis. Terbangunnya kepercayaan tinggi menggeser paradigma organisasi dari manajemen mikro sinkron menuju delegasi asinkron, sehingga memungkinkan armada agen komputasi awan otonom untuk secara mandiri membangun, menguji, dan menggabungkan kode.
Verifikasi Terprogram dan Pemetaan Fitur: Menutup Siklus Agen#
1. Menjelaskan Mekanisme Verifikasi Langkah demi Langkah#
Dalam arsitektur rekayasa berbasis agen, verifikasi terprogram didefinisikan sebagai penyediaan alat eksekusi eksplisit kepada agen agar dapat berinteraksi langsung dengan lingkungan eksekusi aplikasi sasaran. Alih-alih meminta Model Bahasa Besar menebak apakah kodenya berfungsi dengan benar, siklus verifikasi terprogram memungkinkan agen menjalankan kompilasi, memeriksa lingkungan eksekusi, merekam jejak kinerja Unit Pemrosesan Pusat, menganalisis rekaman keadaan memori heap, dan mengoperasikan simulator perangkat seluler atau peramban. Untuk aplikasi web dan desktop, agen menggunakan keterampilan yang dibangun di atas protokol seperti Chrome DevTools Protocol untuk mengendalikan Antarmuka Pengguna secara terprogram.
Lauren Tan menggambarkan mekanisme ini dengan analogi kuliner: mengandalkan agen tanpa verifikasi terprogram setara dengan manajer restoran yang membaca resep di atas kertas untuk menebak apakah hidangan terasa enak, sedangkan verifikasi terprogram membekali kepala koki dengan stasiun kerja dapur untuk terus mencicipi, mengukur, dan menyesuaikan makanan selama persiapan. Pemberian alat eksekusi kepada agen menutup siklus umpan balik secara otomatis. Meskipun verifikasi tidak menjamin keanggunan arsitektur, verifikasi secara deterministik memvalidasi ketepatan perilaku sebelum peninjauan kode oleh manusia dilakukan.
2. Menguraikan Arsitektur Peta Fitur#
Komponen penting verifikasi terprogram yang diperkenalkan dalam pengaya sumber terbuka PStack (Potato Stack) milik Tan—alat keterampilan pengembang yang namanya merupakan permainan kata dari GStack milik Gary Tan—adalah "peta fitur." Peta fitur mengatasi tantangan navigasi basis kode yang dihadapi agen ketika mencoba menyelesaikan kutu atau mengimplementasikan fitur dalam sistem kompleks.
+-----------------------------------------------------------------------+
| FEATURE MAP |
+-----------------------------------------------------------------------+
| User Context / Vague Report: "Left sidebar is laggy on click" |
+-----------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------+
| DOM Attributes & Selectors : [data-testid="sidebar-toggle"] |
| Keyboard Shortcuts : Cmd+B / Ctrl+B |
| Code Base Location : src/components/sidebar/Sidebar.tsx |
| CDP Execution Action : cdp.click('#sidebar-toggle') |
+-----------------------------------------------------------------------+
Ketika pengguna mengirimkan laporan kutu berkualitas rendah dan ambigu—seperti tangkapan layar Slack yang hanya diberi anotasi "???"—agen tanpa konteks struktural kesulitan menemukan komponen yang terdampak. Peta fitur secara eksplisit menjembatani kesenjangan ini dengan memetakan elemen antarmuka pengguna langsung ke jalur berkas basis kode, atribut Model Objek Dokumen, pengenal pengujian, pintasan papan ketik, dan selektor eksekusi Chrome DevTools Protocol.
Melalui keterampilan seperti create_verification_skill dan maintain_verification_skill di dalam PStack, agen menganalisis basis kode secara sistematis untuk menyusun registri fitur terstruktur. Pemrosesan laporan kutu yang ambigu memungkinkan agen mencocokkannya dengan peta fitur, menavigasi langsung ke elemen antarmuka pengguna sasaran, menjalankan alur interaksi melalui Chrome DevTools Protocol, merekam metrik kinerja, dan memverifikasi penyelesaian cacat.
3. Menguraikan Evaluasi dan Pemeliharaan Keterampilan Agen#
Untuk memelihara alat dan keterampilan agen dari waktu ke waktu, tim pengembangan harus menerapkan kerangka evaluasi otomatis, yang berfungsi sebagai pengujian unit untuk keterampilan agen kecerdasan buatan. Panduan evaluasi mengikuti pola eksekusi empat tahap:
- Pembuatan Rubrik: Agen koordinator menetapkan rubrik evaluasi eksplisit yang mendefinisikan perilaku alat yang diharapkan dan kriteria penilaian kuantitatif.
- Eksekusi dalam Lingkungan Terisolasi: Subagen menjalankan tugas di direktori sementara terisolasi yang diberi nama acak dan disamarkan. Penyamarannya wajib dilakukan karena Model Bahasa Besar dapat mendeteksi ketika berada di dalam perangkat evaluasi dan mengubah perilaku eksekusinya, sehingga menimbulkan bias evaluasi yang serius.
- Evaluasi Matriks Multimodel: Untuk menghilangkan bias penilaian model tunggal, agen penilai yang berjalan pada matriks beragam model fondasi mengevaluasi kinerja subagen berdasarkan rubrik koordinator.
- Siklus Optimasi Pendakian Bukit: Siklus optimasi otomatis (seperti menjalankan
/loopdi Cursor) terus menyempurnakan instruksi keterampilan dan parameter alat hingga skor evaluasi sasaran (misalnya, 10 dari 10) tercapai di seluruh matriks model.
Tan menekankan bahwa pemeliharaan keterampilan agen memerlukan pengamatan manusia yang berkelanjutan dan kepekaan rekayasa. Pengembang harus bertindak sebagai pengarah aktif dari belakang, memeriksa catatan pemanggilan alat dan blok pemikiran agen selama pengembangan keterampilan untuk mengidentifikasi pola kegagalan yang halus dan memformalkan instruksi korektif menjadi keterampilan yang tersimpan secara persisten.
Batasan Arsitektur yang Ketat: Beralih dari Instruksi Lunak ke Penegakan Integrasi Berkelanjutan#
1. Membandingkan Aturan Lunak dengan Batasan Deterministik yang Ketat#
Mengandalkan secara eksklusif batasan instruksi lunak—seperti panduan gaya markdown, aturan instruksi, atau berkas instruksi AGENTS.md—pada akhirnya menyebabkan degradasi basis kode. Ketika agen tanpa batasan mengambil jalur dengan hambatan paling kecil untuk menyelesaikan tugas lokal, mereka menghasilkan "arsitektur organik" yang ditandai oleh abstraksi tidak valid, logika terduplikasi, dan akumulasi utang teknis.
Untuk mempertahankan integritas struktural jangka panjang, arsitektur perangkat lunak harus menerapkan paradigma desain inti Lauren Tan: karena agen secara alami mengambil jalan pintas struktural, arsitektur basis kode harus dirancang sedemikian rupa sehingga jalur terpendek secara struktural merupakan jalur terbaik dan benar. Tim rekayasa harus menegakkan paradigma ini melalui kerangka batasan berjenjang yang mengalihkan ketergantungan dari pedoman lunak ke pemeriksaan Integrasi Berkelanjutan yang ketat.
| Lapisan | Tingkat Penegakan | Mekanisme / Peralatan | Karakteristik |
|---|---|---|---|
| 1. Arsitektur & Enkapsulasi Basis Kode | Ketat (Deterministik) | Penempatan fitur di lokasi yang sama, batas direktori yang ketat, aturan impor khusus | Mencegah antipola arsitektur secara struktural dengan menjadikan jalur terpendek sebagai jalur yang benar |
| 2. Analisis Statis & Diagnostik Kompilator | Ketat (Deterministik) | Kompilator ketat (misalnya, pemeriksa peminjaman Rust), pemeriksa kode khusus, pemeriksaan Integrasi Berkelanjutan | Menggagalkan kompilasi secara deterministik saat terjadi pelanggaran invarian sebelum peninjauan manusia |
| 3. Peninjauan Kode Otomatis | Lunak / Semideterministik | Peninjau kode kecerdasan buatan (misalnya, Bugbot), analisis permintaan penggabungan kode otomatis | Menangkap cacat kontekstual selama validasi permintaan penggabungan kode |
| 4. Keterampilan Agen & Panduan Gaya | Lunak (Nondeterministik) | Aturan markdown, instruksi untuk model, panduan gaya | Mudah diabaikan atau diterapkan secara tidak konsisten oleh model |
Meskipun pedoman lunak pada Lapisan 3 dan 4 memberikan konteks yang bermanfaat, analisis statis yang ketat dan enkapsulasi arsitektur pada Lapisan 1 dan 2 wajib diterapkan untuk menjamin bahwa agen otonom tidak dapat menggabungkan kode yang tidak valid.
2. Menganalisis Studi Kasus Arsitektur "Dune"#
Implementasi praktis batasan deterministik ditunjukkan dalam refaktorisasi aplikasi desktop Grokbot. Grokbot dibangun menggunakan "Dune," kerangka kerja internal khusus yang digambarkan sebagai Next.js untuk aplikasi Electron, yang secara eksplisit dirancang untuk pengiriman perangkat lunak berbasis agen.
Untuk melindungi kinerja aplikasi saat eksekusi dan menghilangkan pola kegagalan agen yang berulang, arsitektur Dune menegakkan aturan deterministik yang ketat dalam alur Integrasi Berkelanjutan:
- Larangan Kait React: Kait
useEffectmilik React sepenuhnya dilarang di seluruh basis kode untuk mencegah kutu sinkronisasi status dan perenderan ulang yang tidak disengaja. Kompilasi Integrasi Berkelanjutan langsung gagal jikauseEffectterdeteksi. - Larangan Komentar dalam Kode: Komentar kode aplikasi dilarang keras. Tan mengamati bahwa agen sering menghasilkan komentar historis atau salah menafsirkan komentar peninjauan permintaan penggabungan kode yang bersifat sementara—seperti mengubah satu catatan peninjauan seperti
"Lauren said never to do this"menjadi komentar kode statis—yang menghalusinasikan batasan global permanen dan mencemari jendela konteks model. Pelarangan komentar kode memaksa kode yang mendokumentasikan dirinya sendiri dan mencegah degradasi konteks. - Penegakan Isolasi Batas Proses: Aplikasi Electron memerlukan pemisahan ketat antara proses node utama dan utas antarmuka pengguna perender. Untuk melindungi anggaran eksekusi 16-milidetik per bingkai yang diperlukan guna mempertahankan kinerja mulus 60 Bingkai Per Detik, operasi komputasi berat dan tugas Masukan/Keluaran dilarang pada utas perender. Dune menegakkan hal ini dengan mengisolasi logika ke dalam direktori
electron_maindanelectron_renderer, menggunakan pemeriksaan graf dependensi otomatis dalam Integrasi Berkelanjutan untuk memblokir impor lintas direktori.
Otomatisasi Agen Komputasi Awan dan Implikasi Produk di Seluruh Industri#
1. Reproduksi Bug Otonom dan Alur Kerja Awan#
Pembentukan alat verifikasi lokal dan pagar pengaman CI yang ketat memungkinkan penyampaian perangkat lunak beralih dari pemberian instruksi lokal ke armada agen otonom yang dihosting di awan. Pergeseran ini dicontohkan oleh agen otomatisasi awan internal seperti "Benny" di Cursor.
[ User Feedback ] (Slack / Support Channels)
|
v
[ Benny Cloud Agent ] (Spawns Isolated Cursor Cloud Environment)
|
v
[ Execute Verification Skill ] (Launches App, Simulates UI Input)
|
+---> Bug Reproduced? ---> Yes ---> Generate Fix & Submit PR
|
+---> Already Fixed on Main? ---> Confirm Resolution & Notify Team
Benny secara otomatis menyerap umpan balik mentah pengguna dan laporan cacat dari kanal Slack. Setelah menerima laporan, Benny menjalankan instans desktop Cursor yang terisolasi di awan, mengeksekusi lingkungan waktu jalan aplikasi, dan menggunakan keterampilan verifikasi yang tersimpan untuk mereproduksi cacat yang dilaporkan secara terprogram.
Beroperasi dalam lingkungan terisolasi yang dilengkapi kemampuan verifikasi menyeluruh memungkinkan Benny menentukan secara mandiri apakah suatu masalah masih ada atau telah diselesaikan pada cabang utama. Otomatisasi ini menghilangkan kebutuhan bagi insinyur manusia untuk menghabiskan upaya manual dalam mencoba mereproduksi laporan pengguna berkualitas rendah.
2. Demokratisasi Pengembangan di Berbagai Peran Nonteknik#
Pagar pengaman CI deterministik secara mendasar mengubah dinamika operasional organisasi pengembangan produk. Ketika invarian arsitektur, batas memori, dan anggaran kinerja ditegakkan secara deterministik oleh kompilator dan skrip CI, staf nonteknik—termasuk Manajer Produk [PM], perancang Pengalaman Pengguna [UX], dan personel Strategi Pemasaran [GTM]—dapat dengan aman membuat fitur dan mengajukan PR produksi.
Karena infrastruktur secara otomatis menolak implementasi yang tidak sesuai, kontributor nonteknis dapat membangun peningkatan fungsional melalui antarmuka bahasa alami seperti Grokbot tanpa membahayakan stabilitas basis kode atau anggaran kinerja.
Model operasional ini menghadirkan kompromi ekonomi dan Imbal Hasil Investasi [ROI] tertentu:
- Belanja Modal Token di Awal: Membangun rangkaian verifikasi yang komprehensif, menjalankan matriks evaluasi multiagen, dan melakukan refaktorisasi struktural memerlukan pengeluaran token awal yang besar. Refaktorisasi aplikasi Grokbot ke arsitektur Dune memerlukan lebih dari 600 PR individual.
- Peningkatan Efisiensi Tenaga Kerja: Pengeluaran token awal yang tinggi diimbangi oleh pengurangan drastis beban kerja tambahan rekayasa manusia. Alur eksekusi agen berkapasitas tinggi memungkinkan organisasi beroperasi dengan tim ramping, menghindari beban organisasi dari departemen rekayasa yang besar. Kelayakan ekonomi siklus penilaian berkelanjutan dan matriks evaluasi agen semakin ditingkatkan oleh model terdepan seperti Grok 4.6, yang mempertahankan harga token versi 4.5 sambil memberikan kinerja tolok ukur yang lebih tinggi.
Keterbatasan Arsitektur dan Pertanyaan Rekayasa yang Belum Terjawab#
1. Mendokumentasikan Keterbatasan Utama dan Kasus Batas#
Meskipun armada agen berotonomi tinggi meningkatkan kecepatan, pola arsitektur saat ini menimbulkan keterbatasan dan kompromi rekayasa yang jelas:
- Pengeluaran Token di Awal: Membangun alur verifikasi berkelanjutan dan menjalankan upaya refaktorisasi yang melibatkan ratusan PR mengonsumsi token dalam jumlah sangat besar. Bagi tim yang beroperasi dengan anggaran token terbatas, modal yang diperlukan untuk membangun perangkat verifikasi dapat menjadi hambatan signifikan sebelum memperoleh ROI.
- Risiko Pembuatan Prototipe dari Nol: Pembuatan prototipe aplikasi secara cepat tanpa pagar pengaman struktural ("pengodean berdasarkan intuisi") menghasilkan utang teknis arsitektur yang parah. Tanpa batas enkapsulasi yang eksplisit dan batasan statis, agen memilih jalan pintas demi kemudahan yang menyebabkan basis kode cepat menjadi tidak terkendali, sehingga pada akhirnya memerlukan operasi refaktorisasi besar-besaran yang melibatkan ratusan PR untuk memperbaikinya.
- Beban Tambahan Pemeliharaan dan Pertimbangan Rekayasa: Sistem verifikasi otomatis tidak menghilangkan kebutuhan akan pertimbangan rekayasa tingkat senior. Penyusunan evaluasi, pembaruan peta fitur, dan penetapan batasan CI memerlukan keahlian domain yang mendalam serta pengawasan aktif yang memberikan arahan.
Angka utama#
- 1,000 PR: Jumlah permintaan penggabungan kode yang digabungkan oleh Lauren Tan pada bulan sebelumnya menggunakan agen otonom di Cursor.
- Hampir 800 PR: Jumlah permintaan penggabungan kode yang digabungkan oleh Lauren Tan pada bulan berjalan (hingga hari ke-12 bulan tersebut).
- 20 PR: Jumlah permintaan penggabungan kode buatan agen yang secara otomatis digabungkan semalam dan diverifikasi pada cabang utama dalam satu hari.
- 600+ PR: Jumlah permintaan penggabungan kode yang dilaksanakan untuk menyelesaikan refaktorisasi arsitektur penuh basis kode Grokbot.
- 16 milidetik: Batas waktu eksekusi maksimum per bingkai yang diperlukan pada utas perender Electron untuk mempertahankan kinerja UI yang lancar pada 60 Bingkai Per Detik [FPS].
- 5 bulan lalu: Waktu ketika Lauren Tan bergabung dengan Cursor, yang pada awalnya mengalami produktivitas rendah saat membangun kepercayaan awal terhadap agen dan keterampilan verifikasi.
- Grok 4.6: Rilis model yang baru diumumkan yang mempertahankan biaya token model versi 4.5 sambil meningkatkan kinerja tolok ukur.
Apa yang dapat mengubah gambaran ini#
- Pergeseran ke Pagar Pengaman Agen Bawaan Kompilator: Adopsi luas bahasa yang dikompilasi secara ketat dengan kepemilikan memori dan sistem tipe yang ketat (seperti Rust), alih-alih kerangka kerja perangkat lunak dinamis, yang mengalihkan penegakan struktural dari skrip CI khusus langsung ke diagnostik kompilator.
- Standardisasi Protokol Verifikasi Terprogram: Adopsi luas oleh industri atas standar verifikasi Agen-ke-UI yang terpadu dan tidak bergantung pada platform, melampaui Chrome DevTools Protocol, untuk membuka akses bawaan ke antarmuka desktop, seluler, dan web bagi agen AI.
- Penggabungan CI Otonom secara Luas: Peralihan tim perangkat lunak komersial arus utama dari alur peninjauan kode manual ke antrean penggabungan CI yang sepenuhnya otomatis, yang digerakkan oleh skor evaluasi sintetis dan pengujian integrasi berkelanjutan.
- Pengurangan Biaya Token dalam Evaluasi Multiagen: Pengurangan struktural yang signifikan dalam biaya inferensi model fondasi, memungkinkan tim pengembangan nonperusahaan besar menjalankan matriks penilaian multiagen dan siklus optimasi pendakian bukit secara berkelanjutan dengan biaya yang ekonomis.
Untuk mempelajari lebih lanjut tentang penerapan kerangka kerja rekayasa AI tingkat lanjut dan alur eksekusi otonom, jelajahi riset sumber terbuka yang tersedia di situs DeepValues Research atau coba aplikasi DeepValues hari ini.
Sumber yang dikutip#
Lauren Tan - SpaceXAI engineer, interview published on YouTube channel Vision Sabbat
Tonton
Tautan sumber
Tonton & dengarkan
- Cursor工程師讓AI一個月自動合併1000個PR,關鍵不是更聰明 YouTube · 中文
- Cursor Engineer Ships 1,000 PRs a Month. Who Checks Them? YouTube · EN
- Cursor工程師讓AI一個月自動合併1000個PR,關鍵不是更聰明 Podcast · 中文
- Cursor Engineer Ships 1,000 PRs a Month. Who Checks Them? | AI Explained Podcast · EN