Agile - Apa yang kita lakukan salah?

Saya seorang pengembang dalam tim yang gesit, dan kami mencoba menggunakan Scrum.

Jadi saya akan menempatkan di sini masalah hipotetis untuk menggambarkan situasi.

Kami memiliki aplikasi yang sangat lama, menggunakan beberapa kode JQuery yang berantakan dan tidak terpelihara. Kami juga memiliki sebagian aplikasi menggunakan Bereaksi, dan bagian-bagian itu lebih mudah diperbarui / dirawat. Selain itu, tujuan perusahaan adalah membuat aplikasi klien-halaman-tunggal, di React, jadi menggunakan JQuery membuat Anda semakin jauh dari itu.

Ketika kita melakukan perencanaan, kita selalu mencari solusi mudah dalam hal waktu pengembangan, jadi misalnya jika kita membuat dialog baru atau sesuatu, kita menggunakan JQuery lama karena lebih cepat, dan kita mengatakan bahwa kita kembali nanti untuk merapikan dan mengubah menjadi React, tetapi itu jarang terjadi.

Kami mendapatkan persyaratan apa yang harus kami lakukan dari cerita pengguna (yang dilakukan dengan baik IMO, mereka ramping tetapi mereka menjelaskan apa yang kami lakukan, dan mengapa kami melakukannya).

Terkadang, persyaratan fitur baru sangat tipis, jadi misalnya jika persyaratan mengatakan "buat dialog yang memuat banyak konten" tetapi tidak mengatakan untuk menerapkan fitur pemuatan, kami, dalam banyak kasus, tidak akan mengimplementasikannya , meskipun kita semua tahu itu akan lebih baik bagi pelanggan, dengan alasan bahwa hal ini dapat membahayakan tujuan sprint kami (meskipun saya pribadi percaya itu tidak akan).

Hasilnya adalah bahwa basis kode kami adalah kekacauan besar dengan pemeliharaan yang sangat buruk, dan fitur-fitur baru kadang-kadang, sangat kecil dan mengambil sprint penuh untuk membuat (sesuatu yang dapat dicapai dalam satu hari dalam basis kode yang baik) terutama karena perkembangan ini strategi, cepat, cepat.

Dalam hal ini, apa yang kita lakukan salah? Haruskah kita menangani solusi dengan cara yang lebih lengkap sehingga kita tidak akan menulis kode buruk dan menulis ulang kode yang baru kita tulis minggu lalu? Atau haruskah kita terus melakukan itu hanya memastikan semua kode itu ditulis ulang? Apa yang akan menjadi pendekatan tangkas yang baik untuk masalah ini?

Ini tidak ada hubungannya dengan Agile atau Scrum.

Masalah dengan "lakban sekarang dan kami akan memperbaikinya nanti" adalah bahwa nanti tidak pernah datang dan dalam waktu yang berarti Anda mengumpulkan banyak utang teknis .

Langkah pertama untuk pemulihan adalah mengenali masalah dan berhenti memperburuknya.

Untuk setiap kisah pengguna baru, tim harus mempertimbangkan "apa cara yang tepat untuk kode ini?", Bukan "apa cara tercepat untuk meretas ini?" dan rencanakan sprint yang sesuai.

Untuk membersihkan masalah yang ada, lihat jawaban yang sangat baik untuk saya mewarisi 200 ribu baris kode spageti - sekarang bagaimana?

Apa yang Anda miliki di sana adalah apa yang disebut Martin Fowler "flacid scrum".

Jika Anda membaca dengan benar semua 12 Prinsip di balik Agile Manifesto , Anda akan mengetahui bahwa Anda paling banyak gagal.

Sering-seringlah mengirimkan perangkat lunak yang berfungsi, mulai dari beberapa minggu hingga beberapa bulan, dengan preferensi ke skala waktu yang lebih pendek.

Bisakah Anda mengatakan Anda memberikan perangkat lunak yang benar-benar berfungsi? Atau hanya perangkat lunak yang nyaris tidak berfungsi?

Proses lincah mempromosikan pembangunan berkelanjutan. Sponsor, pengembang, dan pengguna harus dapat mempertahankan kecepatan konstan tanpa batas.

Bisakah Anda mengatakan proses Anda berkelanjutan? Apakah Anda membuat keputusan dengan mempertimbangkan keberlanjutan? Atau apakah Anda memilih solusi yang memecahkan masalah saat ini tanpa memperhitungkan efek jangka panjang?

Perhatian terus menerus terhadap keunggulan teknis dan desain yang baik meningkatkan kelincahan.

Prinsip yang benar-benar utama. Saya percaya ini harus dimasukkan dalam SURAT BESAR MERAH pada halaman. Di sinilah Anda paling gagal.

Secara berkala, tim merefleksikan bagaimana menjadi lebih efektif, kemudian menyesuaikan dan menyesuaikan perilakunya.

Dan yang paling jelas. Jika Anda mengetahui perilaku Anda tidak mengarah ke hasil yang diinginkan, Anda harus mengubahnya. Jika tim Anda tidak dapat melihatnya memiliki masalah, maka tim tidak dapat mulai memperbaikinya.

Dari komentar Anda

Bagaimana cara mencegahnya dengan gesit?

Pertama, dengan mempelajari apa sebenarnya tangkas itu. Scrum tidak gesit. Beberapa orang akan mengatakan Scrum adalah kerangka kerja yang paling tangkas, karena terlalu mudah untuk mencapai situasi Anda yang sebenarnya. Anda harus belajar tentang kerangka kerja tangkas lainnya. Yang saya sarankan adalah Extreme Programming. Yang jelas memecahkan masalah Anda. Solusi tidak sederhana (fokus pada keunggulan teknis melalui pengujian otomatis yang kuat, pemrograman pasangan dan pengiriman berkelanjutan), tetapi sangat efektif. Seperti yang dilaporkan dalam laporan State of DevOps .

Apa yang Anda gambarkan adalah - setidaknya dalam pengalaman saya - pola tim yang muncul cukup umum yang mencoba "menjadi Agile". Sangat terbuka untuk diperdebatkan apakah ini sebenarnya bagian dari Agile itu sendiri atau kesalahan penerapannya, bertentangan dengan manifest / prinsip lincah atau konsekuensi yang melekat padanya, dan sebagainya. Hanya dari sudut pandang empiris dan hanya berdasarkan pada sekelompok kecil sampel pengalaman saya sendiri (dan orang-orang yang saya ajak bicara), jika sebuah tim gesit tampaknya memiliki peluang lebih tinggi daripada rata-rata untuk menjalankan pola ini. Kita tinggalkan saja itu dan fokus pada contoh konkret Anda.

Ada dua aspek terpisah dari apa yang Anda gambarkan:

• Tidak ada kesepahaman / visi dan karenanya tidak efisien
• Bagaimana mengukur keberhasilan / kemajuan dan total biaya

Turun jalan yang salah atau berjalan dalam lingkaran

Dalam pengalaman saya, alasan utama untuk ini terjadi adalah bahwa dalam upaya untuk menghasilkan kode dengan cepat, tim secara aktif menyingkirkan kasus penggunaan atau persyaratan yang sudah mereka ketahui atau dapat dengan mudah mengetahuinya. Pikirkan seperti ini: 10-20 tahun yang lalu, orang mencoba untuk menulis spesifikasi raksasa dan memikirkan segalanya sebelumnya dan sering gagal. Mereka mengambil terlalu lama atau mengabaikan sesuatu. Salah satu pembelajaran di masa lalu adalah bahwa dalam pengembangan perangkat lunak ada hal-hal yang tidak dapat Anda ketahui dan banyak hal berubah, maka ide untuk beralih dengan cepat dan menghasilkan beberapa keluaran yang masuk akal dengan cepat. Prinsip yang sangat bagus. Tetapi hari ini, kita berada di ujung lain: "Saya tidak peduli tentang ini karena ini adalah bagian dari sprint berikutnya" atau "Saya tidak mengajukan bug itu, saya mengatasinya ketika muncul lagi".

1. Kumpulkan semua kasus penggunaan tingkat tinggi , persyaratan, dependensi, dan batasan yang dapat Anda temukan. Masukkan ke dalam wiki sehingga semua pemangku kepentingan dan pengembang dapat melihatnya. Tambahkan kepada mereka ketika sesuatu yang baru muncul. Bicaralah dengan pemegang saham & pengguna Anda. Gunakan ini sebagai daftar periksa sambil mengembangkan untuk mencegah penerapan hal-hal yang tidak berkontribusi pada produk akhir atau solusi / peretasan yang memecahkan satu masalah tetapi menyebabkan tiga yang baru.
2. Merumuskan konsep tingkat tinggi . Saya tidak berbicara tentang mendesain antarmuka atau kelas, tetapi secara kasar menggambarkan domain masalah. Apa elemen utama, mekanisme dan interaksi dalam solusi akhir? Dalam kasus Anda, itu harus membuatnya jelas ketika menggunakan bantuan jquery-penyelesaian sebagai langkah menengah dan ketika itu hanya menyebabkan pekerjaan tambahan.
3. Validasi konsep Anda menggunakan daftar yang Anda kumpulkan. Apakah ada masalah yang jelas di dalamnya? Apakah masuk akal? Apakah ada cara yang lebih efisien untuk mencapai nilai pengguna yang sama tanpa menyebabkan hutang teknologi lama?

Jangan berlebihan. Anda hanya perlu sesuatu sehingga semua orang dalam tim (termasuk non-devs) memiliki pemahaman yang sama tentang jalan terbaik menuju MVP Anda. Setiap orang harus setuju bahwa tidak ada kekeliruan yang jelas dan itu bisa berhasil. Ini secara umum membantu mencegah jalan buntu atau harus mengulangi hal yang sama beberapa kali. Agile dapat membantu Anda menghadapi hal-hal yang tidak terduga dengan lebih baik, tidak ada argumen untuk mengabaikan apa yang diketahui.

Waspadai kekeliruan biaya-sunk : jika Anda mulai dengan satu tipe arsitektur atau database, kebanyakan orang ragu untuk mengubahnya di tengah proyek. Jadi adalah ide yang baik untuk menginvestasikan waktu untuk memiliki "tebakan terbaik yang berpendidikan" sebelum mulai menerapkan hal-hal. Pengembang memiliki kecenderungan untuk ingin menulis kode dengan cepat. Tetapi sering memiliki beberapa ejekan, prototipe langsung, tangkapan layar, gambar rangka, dll memungkinkan iterasi lebih cepat daripada menulis kode. Perlu diketahui bahwa setiap baris kode yang ditulis atau bahkan unit test mempersulit Anda untuk mengubah konsep keseluruhan Anda lagi.

Mengukur Keberhasilan

Aspek yang sepenuhnya terpisah adalah bagaimana Anda mengukur kemajuan. Katakanlah tujuan proyek Anda adalah membangun menara setinggi 1m menggunakan benda-benda yang tergeletak di sekitar. Membangun rumah kartu bisa menjadi solusi yang benar-benar valid jika misalnya waktu memasarkan lebih penting daripada stabilitas. Jika tujuan Anda adalah untuk membangun sesuatu yang tahan lama, menggunakan Lego akan lebih baik. Intinya adalah: apa yang dianggap sebagai retasan dan apa solusi elegan bergantung sepenuhnya pada bagaimana kesuksesan proyek diukur .

Contoh "memuat" Anda cukup bagus. Saya memiliki hal-hal seperti ini di masa lalu di mana semua orang (termasuk penjualan, PO, pengguna) setuju itu menjengkelkan. Tapi itu tidak berdampak pada kesuksesan produk dan tidak menyebabkan hutang jangka panjang. Jadi kami membatalkannya karena ada lebih banyak hal berharga yang harus dilakukan dengan sumber daya dev.

Saran saya di sini adalah:

1. Simpan semuanya, bahkan bug kecil, sebagai tiket di sistem tiket Anda . Buat keputusan aktif apa yang ada dalam ruang lingkup proyek dan apa yang tidak. Buat tonggak sejarah atau filter backlog Anda sehingga Anda selalu memiliki daftar "lengkap" dari semua yang masih perlu dilakukan.
2. Memiliki urutan kepentingan yang ketat dan titik potong yang jelas di mana proyek dapat dianggap sukses. Tingkat stabilitas / kualitas kode / dokumentasi apa yang dibutuhkan produk akhir? Cobalah untuk menghabiskan setiap hari kerja sebaik mungkin dengan memilih dari atas. Ketika mengerjakan satu tiket, cobalah menyelesaikannya sepenuhnya tanpa memperkenalkan tiket baru (kecuali masuk akal untuk menunda hal-hal karena prioritas yang lebih rendah). Setiap komit harus membawa Anda ke depan menuju tujuan akhir Anda, bukan ke samping atau ke belakang. Tetapi untuk menekankan lagi: kadang-kadang peretasan yang menghasilkan pekerjaan tambahan di kemudian hari masih bisa menjadi positif bersih untuk proyek!
3. Gunakan PO / pengguna Anda untuk mengetahui nilai pengguna tetapi juga minta dev Anda untuk mengetahui biaya teknologi . Non-dev biasanya tidak dapat menilai apa biaya jangka panjang sebenarnya (bukan hanya biaya implementasi!), Jadi bantu mereka. Waspadai masalah katak mendidih: banyak masalah kecil yang tidak relevan dari waktu ke waktu dapat membawa tim untuk bertahan. Cobalah untuk mengukur seberapa efisien tim Anda dapat bekerja.
4. Mengawasi tujuan / biaya keseluruhan. Alih-alih berpikir dari sprint ke sprint, lebih baik menjaga pola pikir "bisakah kita sebagai tim melakukan semua yang diperlukan sampai akhir proyek" . Sprint hanyalah cara untuk memecah masalah dan memiliki check point.
5. Alih-alih ingin menunjukkan sesuatu sejak dini, plot kursus Anda di jalur tercepat ke produk minimum yang layak yang dapat diberikan kepada pengguna. Namun, strategi keseluruhan Anda harus memungkinkan hasil yang dapat diverifikasi di antaranya.

Jadi, ketika seseorang melakukan sesuatu yang tidak sesuai dengan tujuan implementasi akhir Anda, idealnya jangan menganggap cerita itu selesai. Jika bermanfaat untuk menutup cerita (mis. Untuk mendapatkan umpan balik dari pelanggan), segera buka cerita / bug baru untuk mengatasi kedatangan singkat. Jadikan transparan bahwa mengambil jalan pintas tidak mengurangi biaya, itu hanya menyembunyikan atau menunda mereka!

Kuncinya di sini adalah untuk berdebat dengan total biaya proyek: jika misalnya PO mendorong untuk mengambil jalan pintas untuk membuat tenggat waktu, menghitung jumlah pekerjaan yang harus dilakukan setelah itu untuk mempertimbangkan proyek selesai!

Waspadalah juga terhadap pengoptimalan berbasis kriteria : jika tim Anda diukur dengan jumlah cerita yang dapat mereka tunjukkan pada ulasan sprint, cara terbaik untuk mencapai "skor" yang baik adalah dengan memotong setiap cerita menjadi sepuluh cerita kecil. Jika diukur dengan jumlah unit tes yang ditulis, itu akan cenderung menulis banyak yang tidak perlu. Jangan menghitung cerita, melainkan mengukur seberapa banyak fungsionalitas pengguna yang dibutuhkan bekerja, seberapa besar biaya hutang teknologi yang harus diselesaikan dalam lingkup proyek, dll.

Ringkasan

Untuk mendidihkannya: Melaju cepat dan minimal adalah pendekatan yang baik. T dia masalah adalah dalam menafsirkan "cepat" dan "minim". Orang harus selalu mempertimbangkan biaya jangka panjang (kecuali jika Anda memiliki proyek di mana ini tidak relevan). Menggunakan jalan pintas yang hanya membutuhkan waktu 1 hari tetapi menghasilkan utang teknologi 1 bulan setelah tanggal pengiriman membuat perusahaan Anda lebih dari solusi yang memakan waktu 1 minggu. Segera mulai menulis tes tampaknya cepat, tetapi tidak jika konsep Anda cacat dan mereka memperkuat pendekatan yang salah.

Dan perlu diingat apa arti "jangka panjang" dalam kasus Anda: Saya tahu lebih dari satu perusahaan yang bangkrut dengan mencoba menulis kode yang bagus dan karena itu dikirim terlambat. Arsitektur yang baik atau kode yang bersih - dari sudut pandang perusahaan - hanya bernilai jika biaya untuk mencapainya lebih rendah daripada biaya tidak memilikinya.

Semoga itu bisa membantu!

Dari perspektif scrum, sepertinya kesalahan Anda adalah Anda tidak bekerja dengan klien. Anda perlu bekerja sama dengan klien untuk memahami apa yang mereka butuhkan dan bukan hanya apa yang mereka inginkan . Apakah mereka membutuhkan serangkaian perbaikan cepat, atau apakah mereka membutuhkan sistem yang stabil dan dapat dipelihara yang akan melayani mereka dalam jangka panjang? Itu bisa sulit untuk ditentukan, tetapi kualitas adalah persyaratan seperti warna latar belakang atau tolok ukur kinerja. Pelanggan perlu menyadari bahwa stabilitas dan pemeliharaan tidak gratis, dan harus direkayasa ke dalam produk.

Jika mereka mengatakan itu adalah yang pertama, Anda tidak melakukan kesalahan - dengan asumsi Anda menjelaskan kepada mereka dalam ulasan sprint bahwa Anda memotong sudut-sudut teknik untuk memenuhi tujuan mereka.

Jika mereka mengatakan itu adalah yang terakhir, maka apa yang Anda lakukan salah adalah Anda tidak memberi mereka apa yang mereka inginkan.

Salah satu landasan Scrum adalah transparansi. Jika Anda melakukan scrum, Anda harus melakukan ulasan sprint dengan pelanggan. Dalam ulasan tersebut, apakah Anda memberi tahu pelanggan bahwa Anda berhemat untuk memberikan perangkat lunak lebih cepat? Jika tidak, Anda seharusnya. Anda harus 100% jelas dengan pelanggan Anda tentang konsekuensi pilihan desain Anda, untuk memberi mereka kesempatan untuk membuat keputusan berdasarkan informasi, apakah Anda memberikan perangkat lunak Anda dengan tingkat kualitas yang sesuai.

Ewan benar. Alasan manajemen menyukai scrum adalah karena mereka dapat meminta fitur dalam gaya staccato dan mendapatkan hasil dengan cepat. Sampai kekacauan yang dihasilkan adalah masalah seseorang lain.

Sekarang saya mendapatkan perhatian Anda, izinkan saya menjelaskannya. Bukan Scrum seperti itu. Ini adalah pengaturan khas manajer produk yang kuat dan tim pengembangan yang lemah yang tidak dapat meletakkan perkiraan yang masuk akal dan realistis karena mereka merasakan tekanan. Jadi mereka datang dengan jauh ke perkiraan optimis dan membuat diri mereka lebih dalam kesulitan, memotong sudut untuk memberikan tepat waktu.

Dalam scrum Anda (sebagai pengembang) dapat melakukan perencanaan Anda sendiri. Tidak ada yang memberitahu Anda untuk memberikan beberapa fitur dalam x hari. Jika seseorang memberitahu Anda untuk mengirimkan dalam x hari, Anda tidak melakukan Scrum.

Apa pun masalahnya adalah yang perlu diperbaiki, ambil waktu Anda. Apakah Anda pikir Anda perlu waktu untuk mengerjakan ulang sesuatu terlebih dahulu? Masukkan dalam perkiraan Anda. Bisakah Anda melakukan itu?

Mari kita periksa apa yang Anda lakukan, sisihkan Agile sejenak.

Ketika kita melakukan perencanaan, kita pergi mencari solusi mudah dalam hal waktu pengembangan, jadi misalnya jika kita membuat dialog baru atau sesuatu, kita menggunakan jquery lama karena lebih cepat, dan kita katakan kita akan kembali lagi nanti untuk merapikan dan berubah menjadi reaksi, tetapi itu jarang terjadi.

Ini disebut "Mengambil Hutang Teknis". Martin Fowler menggambarkan "Kuadran Utang Teknis" di sebuah blognya di sepanjang dua sumbu: "Reckless vs Prudent" dan "Disengaja vs Tidak Disengaja".

Anda secara eksplisit memutuskan untuk menggunakan jquery teknologi lama yang dikenal yang membuat Anda semakin jauh dari salah satu tujuan ekspres Anda (yaitu aplikasi satu halaman). Anda melakukan ini untuk mengirimkan "dengan cepat". Ini disengaja.

Yang tidak termasuk dalam perhitungan "cepat" ini adalah waktu yang Anda perlukan untuk mengimplementasikan fungsionalitas sebagai reaksi setelahnya. Anda memilih alternatif yang hanya memiliki kelemahan dari alternatif yang Anda tahu adalah yang benar (yaitu meluangkan waktu untuk mengimplementasikan fitur dalam bereaksi) berdasarkan pada penilaian bahwa kecepatan adalah esensi. Ini sembrono.

Martin Fowler menjumlahkan utang semacam ini di bawah "Kami tidak punya waktu untuk mendesain". Itu adalah pilihan yang tepat di lingkungan di mana Anda tidak mengharapkan untuk mempertahankan kode atau bahkan mengharapkan kode selama lebih dari beberapa hari. Tetapi proyek Anda adalah proyek jangka panjang yang secara eksplisit melibatkan pemeliharaan untuk pelanggan Anda

Apa yang Anda lakukan salah pada level paling dasar. Ini rekayasa buruk !

Anda mengambil utang teknis, mengabaikan bahwa utang ini perlu dilunasi dan membebankan bunga. Dan Anda terus melakukan itu sampai tingkat bunga hutang Anda mulai mendekati pekerjaan Anda yang tersedia selama sprint Anda.

Yang harus Anda lakukan adalah mengurangi tingkat utang . Bicaralah dengan atasan Anda, bicaralah dengan klien Anda. Anda harus mengerjakan pemeliharaan kemarin.

Hanya berhenti menggunakan Agile ...

Atau lebih tepatnya, berhentilah mencoba melakukan sesuatu dengan cara tertentu semata-mata karena itulah yang (pemahaman Anda tentang) gesit (atau scrum dll ...) menentukan. Mencoba menerapkan satu (salah) interpretasi dari salah satu istilah ini ke proyek pada tahap yang salah dapat dengan cepat menjadi tindakan terburuk. Gunakan alasan Anda sebagai gantinya.

Alasan proyek Anda, dan hampir setiap proyek lainnya di dunia, adalah kekacauan kode dan pendekatan yang berbeda, disebabkan oleh kurangnya desain arsitektur yang tersentralisasi dan maha tahu (di sana, saya katakan itu).

Alasan yang mungkin kurang adalah:

• Arsitek tidak memiliki keahlian (Seperti sepuluh proyek hobi pertama Anda)
• Arsitek tidak punya waktu
• Arsitek tidak memiliki kekuatan (Manajer mengatakan tidak, atau ya tetapi hanya untuk beberapa bagian)
• Tim memiliki keyakinan pada beberapa metodologi voodoo yang akan menyelamatkan mereka (Itu semua akan keluar dengan sendirinya karena kami menggunakan Agile)

Solusi sederhana adalah dengan menjatuhkan semua kata ajaib ini, dan melihat kenyataan situasi, yang dapat diringkas sebagai:

1. Keadaan kode menghambat kemampuan tim untuk memenuhi waktu dan bebas bug.
2. Semakin banyak fitur yang kita tambahkan, semakin buruk jadinya.
3. Karenanya sangat masuk akal untuk berhenti sejenak, menilai kembali, dan (mungkin secara drastis) mendesain ulang bagian-bagian.

Anda tentu akan datang untuk bertanya mengapa itu sampai pada keadaan ini di tempat pertama, dengan jari menyalahkan berputar-putar. Jawabannya adalah bahwa hal ini tidak terhindarkan: ketika desain Anda matang Anda menyadari bahwa Anda harus melakukannya secara berbeda, tetapi Anda tidak dapat memperkirakannya. Lebih jauh lagi ini bukan realisasi sekali proyek, itu akan terjadi beberapa kali, dan Anda perlu merencanakan untuk itu.

Karena itu, ada banyak hal yang dapat dilakukan manajer untuk memperburuk hal-hal:

1. Deathmarching devs Anda hingga tenggat waktu.
2. Menyatakan bahwa pengembang hanya dapat mencatat waktu terhadap tiket, tanpa ada tiket untuk "berfikir, konsolidasi dan refactoring kualitas" dan tunjangan waktu yang murah hati pada mereka.
3. Tidak memberi siapa pun kepemilikan arsitektur cukup lama untuk bisa mengatasinya
4. Tidak mengizinkan orang itu untuk melakukan perubahan yang menurut mereka diperlukan

Melihatnya dengan cara ini, mudah untuk melihat bagaimana beberapa interpretasi dari gesit & scrum akan benar-benar berbaris di rute ini bahkan lebih cepat!

Salah satu pendekatan adalah membuat tiket untuk setiap bit refactoring. Masalahnya adalah bahwa Anda sering tidak menyadari bahwa Anda memerlukan refactor besar sampai Anda mulai bekerja pada tiket yang lebih kecil, yang mendorong tenggat waktu kembali, dan jika tiket melewati loop persetujuan, itu hanya memperlambat semuanya.

Pendekatan lain adalah merencanakan sprint menggunakan hanya 25-50% dari kapasitas tim Anda. Dev kemudian mencatat waktu mereka di tiket asli (mencatat waktu yang seharusnya diambil tanpa refactoring) dan waktu refactoring (satu tiket besar untuk minggu ini, tidak ada loop persetujuan, hanya diskusi antara devs). Jika tidak ada refactoring, Anda dapat menarik tiket dari sprint minggu depan. Anda menyesuaikan penggeser persentase untuk beberapa minggu mendatang saat kode dasar proyek meningkat.

Jadi untuk menjawab "apa yang kita lakukan salah" Saya akan mengatakan Anda menempatkan kepercayaan pada metodologi di atas akal sehat. Anda bahkan meminta "pendekatan gesit untuk masalah ini" . Saya akan mengatakan kata-kata dan berpikir tentang masalah yang sebenarnya. Jika Anda benar-benar ingin memisahkan berbagai manifesto yang mencoba menguraikan apakah pendekatan akal sehat akhir Anda memang jatuh di bawah kedok "gesit" atau "scrum", tentu saja berlaku untuknya :-)

Anda tidak melakukan kesalahan apa pun. Metodologi semacam ini dirancang untuk menghadirkan fitur secara spesifik dan secepat mungkin.

Jika Anda memang memiliki tujuan sekunder yang sedang Anda upayakan maka yang terbaik untuk menyatakannya sebagai 'persyaratan non-fungsional' atau 'definisi selesai'.

misalnya, Anda dapat memiliki persyaratan non-fungsional:

"Semua fitur baru harus ditulis dalam Bereaksi"

dan

"Semua panggilan tidak sinkron harus menerapkan pemintal pemuatan dan penanganan kesalahan"

Anda hanya perlu membuat Pemilik Produk Anda (atau yang setara) untuk setuju bahwa ini adalah hal-hal yang layak dilakukan, daripada menyelundupkannya ke dalam karena pengembang menyukainya.