Developer vs Architect: Kapan Masing-Masing Menang
Developer vs architect bukan soal jabatan, melainkan siapa yang memegang keputusan arsitektur. Bahas ADR, coupling, dan reversibilitas untuk promosi tak terduga Anda.

Bulan lalu saya mereview sebuah diff di mana asisten coding AI menulis rangkaian blok try/catch untuk mencatat instalasi baru sebuah add-on browser. Pertama, ia mencoba mengambil email pengguna. Kalau itu error, ia jatuh ke user ID. Kalau itu juga error, ia mencatat angkat bahu: ada yang install, kita tidak tahu siapa. Kodenya jalan. Tapi kodenya salah, karena platform baru saja memperketat data identitas apa yang boleh diminta oleh sebuah add-on. Pertanyaan developer vs architect bersembunyi di diff seperti ini, dan tidak ada yang memberi tahu Anda di sisi mana Anda berdiri sekarang.
Jawaban yang tepat bukan catch block yang lebih baik. Jawabannya adalah mencatat timestamp, menampilkan welcome screen, dan memberi tahu tim marketing bahwa mereka tidak bisa mendapatkan email saat install kecuali pengguna memberikannya nanti. Tidak ada model yang bisa membuat keputusan itu, karena model tidak tahu pengguna Anda, kebijakan platform Anda, atau target kuartal tim marketing Anda. Ia melakukan persis apa yang Anda minta, dengan kecepatan yang menakutkan. Artinya, orang yang meminta, yaitu Anda, baru saja bertanggung jawab atas sesuatu yang lebih besar dari sekadar kode. Selamat atas promosinya. Maaf tidak ada yang memberi tahu.
Ada argumen balasan yang wajar: banyak engineer akan bilang bahwa setiap pekerjaan yang pernah mereka punya menuntut mereka menantang requirement dan merancang data model untuk tiket apa pun yang mereka ambil. Benar, di tim yang bagus itu selalu menjadi pekerjaannya. Tapi ada yang benar-benar berubah. Kecepatan mengetik dulu menjadi rem alami untuk ide buruk. Ketika rencana yang biasa-biasa saja memakan tiga hari implementasi, Anda memikirkannya dulu. Ketika biayanya sembilan puluh detik, rencana itu sudah dibangun sebelum ada yang sempat berpikir. Gesekan yang dulu memaksa orang berpikir secara arsitektural sudah hilang, dan tidak ada yang menggantikannya selain Anda.
Developer vs Architect: Dua Pekerjaan yang Berbeda
Ini cara paling bersih yang bisa saya pakai untuk menjelaskan perbedaannya. Seorang developer mengambil tiket dan bertanya bagaimana. Seorang architect melihat tiket yang sama dan bertanya apakah ini seharusnya ada, dan dalam bentuk apa. Developer mengoptimalkan di dalam batasan. Architect memilih batasannya, dan yang paling penting, menanggung konsekuensi pilihan itu untuk dua tahun ke depan. Keduanya adalah engineering sungguhan. Hanya saja pekerjaannya berbeda, dan cara gagalnya pun berbeda. Kegagalan developer adalah bug. Kegagalan architect adalah data model dengan tabel redundan yang sudah dibangun di atasnya oleh tiga tim sebelum ada yang sadar.
Alat coding AI diam-diam sudah duduk di kursi developer. Mereka seperti junior tercepat yang pernah Anda rekrut: tak kenal lelah, lancar, dan sama sekali tidak mau bilang bahwa requirement Anda adalah masalah sebenarnya. Minta logging install per pengguna, dan Anda akan mendapatkan logging install per pengguna, dengan rentetan fallback untuk memastikan semuanya "berjalan" meski platform tidak menginginkannya. Model tidak punya kepentingan terhadap latency budget aplikasi Anda, privacy posture Anda, atau rotasi on-call Anda. Itu bukan kelemahan alatnya. Itu deskripsi pekerjaan dari kursi yang ia ambil, yang berarti kursi lainnya, yang bilang tidak, kosong kecuali Anda yang duduk di sana.
Jadi seperti apa sebenarnya duduk di kursi itu? Ada tiga hal, kurang lebih. Mengenal pengguna Anda cukup baik untuk tahu kapan sebuah requirement bertentangan dengan kepentingan mereka. Memahami coupling sistem Anda cukup dalam untuk melihat radius dampak dari perubahan satu baris. Dan bersedia melakukan percakapan canggung dengan siapa pun yang menulis requirement itu, sebelum kode ada, bukan di postmortem. Tidak ada yang melibatkan diagram kotak-dan-panah di wiki yang tidak dibaca siapa pun. Semuanya melibatkan penilaian yang tidak bisa didelegasikan ke alat yang tidak pernah membantah.
Keputusan Arsitektur yang Sebenarnya Sudah Anda Buat
Anda tidak perlu jabatan untuk membuat keputusan arsitektur. Anda membuatnya setiap minggu, di dalam tiket biasa. Di mana validasi diletakkan (klien, API, atau database). Apakah sebuah pemanggilan bersifat sinkron atau masuk antrean. Apa yang dicatat dan apa yang sengaja tidak dicatat. Bentuk tabel baru dan foreign key-nya ke mana. Masing-masing adalah taruhan tentang masa depan, dan masing-masing membatasi atau memungkinkan sepuluh tiket berikutnya. Diff logging install tadi kelihatannya seperti tugas monitoring. Padahal itu keputusan privasi, keputusan keamanan, dan keputusan produk yang menyamar sebagai kode satu baris.
Ini versi sebelumnya, yaitu apa yang dihasilkan asisten, yang mengimplementasikan "catat siapa yang install" dengan setia:
async function logInstall(req, res) {
let identity = null;
try {
identity = { email: await getUserEmail(req) };
} catch {
try {
identity = { userId: await getUserId(req) };
} catch {
identity = { note: "install without identity" };
}
}
await db.installs.insert({ ...identity, at: new Date() });
res.redirect("/welcome");
}
Lima belas baris, tiga mode gagal, dan skema yang harus mengakomodasi email-atau-userId-atau-tidak-keduanya selamanya. Setiap fallback diam-diam mengaitkan jalur install ke identity API, sehingga gangguan di layanan yang bergantung pada consent bisa memperlambat atau merusak funnel onboarding Anda. Dan baris yang bilang "ada yang install, kita tidak tahu siapa" tidak berguna secara analitik, karena tidak ada yang bisa ditindaklanjuti tim marketing dari situ. Requirement-nya terpenuhi secara harfiah dan gagal secara semangat.
async function logInstall(req, res) {
await db.installs.insert({ at: new Date() });
res.redirect("/welcome");
// Email is collected on the welcome screen, with consent,
// posted asynchronously — and never gates the install path.
}
Versi setelahnya hanya empat baris. Tapi perhatikan apa yang sebenarnya berubah: bukan kodenya, melainkan requirement-nya. Tujuan awalnya bukan "mengambil email", tapi "mengukur install dan menindaklanjuti pengguna baru". Timestamp mengukur install. Welcome screen, tempat pengguna sudah melihat permintaan persetujuan, adalah tempat yang tepat untuk meminta email, secara asinkron, di mana kegagalan tidak menimbulkan kerugian. Langkah architect bukan menulis lebih sedikit kode. Melainkan menegosiasikan ulang untuk apa kode itu sebenarnya.
Kebiasaan yang layak dibangun: sebelum perubahan apa pun yang tidak sepele, lakukan inventaris coupling selama dua menit. Tanyakan apa yang akan dipanggil kode ini, apa yang akan memanggilnya, dan apa yang rusak ketika masing-masing lambat, mati, atau deprecated. Di versi sebelumnya, jalur install bergantung pada dua layanan identitas yang tidak seharusnya ia tahu. Di versi setelahnya, ia bergantung pada satu tabel. Jumlah dependensi itu, bukan jumlah baris, bukan cyclomatic complexity, adalah angka yang memprediksi insiden masa depan Anda. Kami sudah melihat pola yang sama dalam cara asisten coding AI gagal dengan cara yang bisa diprediksi dan diuji: outputnya masuk akal secara lokal tetapi terkait secara global.
ADR vs Pengetahuan Tribal: Kapan Masing-Masing Menang
Architecture Decision Record memang sengaja dibuat membosankan: satu halaman berisi konteks, keputusan, alternatif yang dipertimbangkan, dan konsekuensi yang diterima. Itu saja. Tanpa seremoni, tanpa alur persetujuan kecuali Anda memang mau. Alasan ADR berpindah dari "boleh ada" menjadi wajib di era AI adalah memori. Model tidak punya memori. Enam bulan dari sekarang, seseorang akan mengarahkan asisten ke modul install, meminta perubahan, dan penalaran matang tentang consent dan kebijakan platform akan menguap, kecuali jika tertulis di tempat yang bisa ditemukan manusia maupun alat. ADR di repo akan dibaca oleh siapa pun (atau apa pun) yang menyentuh kode berikutnya.
Pengetahuan tribal memang menang dalam beberapa situasi, dan berpura-pura sebaliknya adalah alasan ADR mendapat reputasi birokratis. Tim dua orang yang membangun prototipe dengan usia hitungan minggu tidak butuh catatan keputusan; pengambil keputusannya duduk berdampingan dan kodenya toh akan ditulis ulang. Konteks lisan lebih cepat, lebih kaya, dan lebih murah di skala itu. Masalahnya, tim jarang menyadari saat mereka melewati ambang batas: ketika karyawan baru pertama masuk, tim pertama mengonsumsi API Anda, atau insiden pertama di mana pertanyaan "kenapa kita melakukannya begini?" tidak punya jawaban.
- Keputusan itu mahal untuk dibalik: perubahan skema pada data live, kontrak API publik, vendor lock-in.
- Keputusan itu melintasi batas tim, sehingga orang yang terdampak tidak ada di ruangan saat keputusan dibuat.
- Anda sudah bisa mendengar pertanyaan di masa depan: "kenapa sih kita melakukannya seperti ini?"
- Alat AI yang menghasilkan implementasinya, sehingga tidak ada manusia yang harus mengartikulasikan penalarannya dengan lantang.
- Trade-off-nya tidak jelas: Anda menerima biaya nyata (latency, permukaan privasi, beban operasional) dengan sengaja.
Poin keempat itulah yang baru. Ketika manusia menulis kode, penalarannya meninggalkan jejak: commit message, argumen di PR, bentuk percobaannya sendiri. Ketika asisten yang menulis, penalarannya hanya ada di kepala Anda, sebentar, lalu hilang. ADR adalah artefak yang membuat review menjadi mungkin, karena memberi reviewer sesuatu untuk dicek kodenya terhadap. Tanpa itu, review merosot menjadi komentar gaya sementara arsitekturnya perlahan melenceng.

Keputusan yang Bisa dan Tidak Bisa Dibalik dalam Desain Sistem
Pertanyaan paling berguna di perlengkapan architect adalah ini: seberapa mahal biayanya untuk mengubah pikiran saya? Sebagian keputusan adalah pintu dua arah. Format log, signature fungsi internal, TTL cache: Anda bisa membatalkannya kapan saja dalam satu sore. Lainnya adalah pintu satu arah. Kontrak API publik yang diintegrasikan klien eksternal. Skema database yang sudah menumpuk enam bulan data produksi. Alur consent yang posisi hukum Anda kini bergantung padanya. Begitu Anda melewati pintu satu arah, biaya untuk mempertimbangkan ulang bukan lagi refactor, melainkan migrasi, jadwal deprecation, dan permintaan maaf.
Klasifikasikan pintunya sebelum membangun, karena AI sudah membuat membangun menjadi murah, sementara membatalkan tetap semahal dulu. Tanpa batasan, asisten dengan senang hati akan merancang data model untuk Anda, dan mode gagalnya adalah tabel redundan, kolom duplikat, dan kode migrasi yang menumpuk di atas kode migrasi, karena setiap prompt menambah tabel alih-alih mempertimbangkan ulang modelnya. Menghapus tabel dengan data live yang dibaca tiga service adalah salah satu operasi paling menyebalkan di industri kita. Murahnya pembuatan skema justru alasan mengapa skema pantas dipikirkan dengan mahal. Alokasikan anggaran deliberasi Anda sebanding dengan sifat tidak bisa dibalik, bukan sebanding dengan lamanya kode ditulis. Rasio itu sudah terbalik.
Aturan kerja saya: jika sebuah keputusan menyentuh data yang tidak bisa Anda buat ulang, atau antarmuka yang akan diandalkan oleh orang di luar tim Anda, keputusan itu mendapat ADR dan sepasang mata kedua sebelum implementasi dimulai. Yang lain langsung dikirim dan diiterasi. Aturan ini bisa diskalakan dari proyek solo ke platform team tanpa modifikasi, dan inilah bedanya antara bergerak cepat dan bergerak cepat ke arah yang tidak bisa Anda tinggalkan.
Menantang Requirement seperti Architect
Inti yang tidak nyaman dari pekerjaan architect adalah berkata tidak kepada orang yang posisinya lebih tinggi. "Catat siapa yang install" terdengar seperti requirement, padahal sebenarnya itu solusi yang sudah dibayangkan seseorang untuk tujuan "mengukur install dan menindaklanjuti pengguna baru". Architect menerjemahkan solusi kembali menjadi tujuan, lalu menawarkan jalur yang lebih murah menuju tujuan itu. Terjemahan itulah triknya, dan tidak ada alat yang melakukannya, karena seluruh desain alat itu adalah untuk patuh. Sebagian engineer membekali asisten mereka dengan konteks pengguna dan mendapat penilaian yang lumayan darinya. Itu membantu di pinggiran, tapi model tetap tidak akan masuk rapat dan memberi tahu tim marketing bahwa email follow-up mereka tidak akan terjadi saat install.
- Sampaikan kembali tujuannya, bukan solusinya: "kita ingin mengukur install dan menjangkau pengguna baru."
- Tawarkan jalur yang lebih murah beserta hasilnya: logging timestamp mengukur install dengan sempurna.
- Sebutkan apa biaya jalur mahal itu sebenarnya: friksi consent, jalur install yang terkait, baris yang tidak bisa dipakai marketing.
- Berikan mereka pilihan nyata: "kalau email memang penting, kita tanya di welcome screen. Ini versi satu harinya."
- Tulis apa pun yang sudah diputuskan, supaya orang berikutnya tidak membahasnya lagi dari nol.
Sekarang keberatan yang jujur, karena layak mendapat ruang: tidak ada yang naik jabatan. Kemungkinan lebih besar, Anda sedang menjadi tempat pembuangan tanggung jawab untuk keputusan yang dibuat model, dengan gaji yang sama, dan dengan bagian yang menyenangkan yang lebih sedikit. Menurut saya itu tidak sepenuhnya salah, dan itu alasan untuk menganggap serius kebiasaan dokumentasi, bukan melewatkannya. Jejak ADR juga merupakan jejak kertas. Menjadi manusia yang memutuskan hanya jadi masalah ketika Anda tidak bisa menunjukkan penalaran Anda. Orang yang menulis "kita memilih timestamp daripada pengambilan email karena platform membatasi data identitas" aman. Orang yang menggabungkan apa pun yang dikeluarkan asisten tidak.
Developer vs Architect: Kapan Masing-Masing Menang
Ini bukan peringkat, melainkan perpindahan mode, dan keahliannya adalah tahu mode mana yang dibutuhkan pekerjaan di depan Anda. Beberapa kasus konkret dari backlog saya sendiri:
- Perbaikan bug yang sudah jelas spesifikasinya, radius dampak diketahui: mode developer menang. Reproduksi, perbaiki, uji, kirim. Pertimbangan arsitektural di sini hanyalah penundaan yang berpakaian rapi.
- Prototipe untuk memvalidasi permintaan pasar: mode developer. Kodenya akan ditulis ulang kalau berhasil dan dihapus kalau tidak. ADR untuk sesuatu yang sekali pakai itu sia-sia.
- Fitur greenfield dengan requirement yang kabur: mode architect dulu, meski hanya satu jam. Kekaburan adalah tempat momentum yang dihasilkan AI paling banyak merusak.
- Apa pun yang menyentuh uang, identitas, atau consent: mode architect, tanpa pengecualian. Asimetri biaya antara membangun dan membatalkan ada di titik terburuknya di sini.
- Perubahan skema pada data live atau perubahan API publik: mode architect dengan ADR, sesuai aturan reversibilitas.
- Tim dua orang, codebase yang usianya di bawah enam bulan: mode developer dengan file catatan yang berjalan. Seremoni penuh belum memberi manfaat apa-apa.
- Domain yang diregulasi atau banyak tim konsumen: mode architect dengan catatan, karena "kenapa" akan ditanyakan oleh auditor dan orang asing, bukan teman.
Kegagalan di kedua arah adalah terus berada di satu mode. Developer yang tidak pernah berpindah naik menghasilkan implementasi elegan untuk hal yang salah. Architect yang tidak pernah turun menghasilkan diagram untuk sistem yang tidak ada. Orang yang paling tidak ingin saya kehilangan di tim adalah mereka yang melakukan keduanya dalam satu sore: berdebat soal data model jam 10 pagi, lalu memperbaiki off-by-one jam 2 siang tanpa mengeluh bahwa itu di bawah level mereka. Kalau Anda membangun proses review di sekitar output AI, ada baiknya membaca tentang bagaimana alat coding agentic menyusun loop, konteks, dan permission, karena perpindahan mode harus terjadi di dalam loop itu, bukan setelahnya.
AI akan dengan senang hati membangun hal yang salah dengan kecepatan tinggi, selamanya. Tugas architect adalah memutuskan apa yang benar, dan menuliskan alasannya sebelum penalarannya menguap.

Rekomendasi: Ambil Promosinya
Ini posisi saya, dan bukan "tergantung": secara default gunakan mode architect untuk apa pun yang menyentuh data model, kontrak eksternal, atau postur keamanan, dan tetap di mode developer untuk semua yang terisolasi. Pembagiannya tidak 50/50. Bagi kebanyakan engineer, itu 20% merancang dan 80% membangun, sama seperti sebelumnya. Yang berubah adalah pembangunan menjadi cepat, dan biaya melewatkan 20% itu naik sebesar pengali kecepatannya. Semakin banyak mengetik yang Anda delegasikan, semakin nilai Anda terkonsentrasi di bagian yang tidak bisa didelegasikan.
Paket pemula terdiri dari tiga kebiasaan, dan Anda bisa menerapkan semuanya minggu ini. Pertama, tambahkan template ADR di repo (konteks, keputusan, alternatif, konsekuensi, setengah halaman) dan tulis satu setiap kali Anda menerima trade-off nyata. Kedua, tambahkan inventaris coupling dua menit ke setiap epic: apa yang dipanggil ini, apa yang memanggilnya, apa yang rusak ketika itu gagal. Ketiga, letakkan pertanyaan reversibilitas di template tiket Anda: "jika ini salah, berapa biaya mengubah pikiran kita?" Kalau jawabannya "migrasi dan permintaan maaf", perlambat. Kalau jawabannya "satu sore", jangan.
Pekerjaan coding tidak akan hilang, yang hilang adalah pekerjaan mengetik. Keduanya tidak pernah sama, dan orang yang diam-diam panik adalah mereka yang perannya diam-diam menyusut menjadi menerjemahkan tiket menjadi sintaks. Kalau Anda membaca diff dan bertanya "kenapa ini terkait dengan identity API?", Anda sebenarnya sudah melakukan pekerjaan architect. Satu-satunya perubahan nyata adalah sekarang itu resmi, terdokumentasi, dan milik Anda. Ambil promosinya.


