કાર્યક્ષમતાનો ભ્રમ: શા માટે AI નો છેલ્લો તબક્કો (Last Mile) બધું જ ખર્ચાવી દે છે

તમે AI કોડના 80/20 નિયમ વિશે વાંચો છો અને સહમત થાઓ છો.

AI તમારા કોડના પ્રથમ 80% સેકન્ડોમાં લખી નાખે છે. તે પ્રગતિ જેવું લાગે છે. તે ઝડપ જેવું લાગે છે.

આ એક જાળ છે.

કામના અંતિમ 20% માટે તમારા 80% સમયની જરૂર પડે છે. અહીં જ પ્રોજેક્ટ્સ અટકી જાય છે. અહીં જ ડેવલપર્સ મૂંઝવણમાં મુકાય છે.

AI સંભાવના (probability) પર કામ કરે છે. તે આગામી સૌથી સંભવિત શબ્દ અથવા કોડની લાઇનનું અનુમાન લગાવે છે. તે logic સમજતું નથી. તે તમારા ચોક્કસ system architecture ને સમજતું નથી. તે એક "happy path" બનાવે છે જે ફક્ત સંપૂર્ણ પરિસ્થિતિઓમાં જ કામ કરે છે.

જ્યારે તમે happy path થી આગળ વધો છો, ત્યારે તમે મુશ્કેલીઓનો સામનો કરો છો.

હું આને Verification Debt કહીશ.

Technical debt ઝડપી સુધારાઓ (quick fixes) માંથી આવે છે. Verification debt સમજણના અભાવમાંથી આવે છે.

જ્યારે તમે જાતે કોડ લખો છો, ત્યારે તમે એક માનસિક નકશો (mental map) બનાવો છો. તમને ખબર હોય છે કે દરેક લાઇન શા માટે છે. જ્યારે AI તેને લખે છે, ત્યારે તમને એક તૈયાર પ્રોડક્ટ આપવામાં આવે છે જે તમે બનાવી નથી. તમે તેના logic ના માલિક નથી. તમે ફક્ત તેના પરિણામના માલિક છો.

જો તમે કોડ સમજતા નથી, તો તમે તેને debug કરી શકતા નથી. તમે AI દ્વારા એક સેકન્ડમાં કરવામાં આવેલી ભૂલને સુધારવા માટે કલાકો બગાડો છો.

Generation ની ઝડપ પૂર્ણતાનો ભ્રમ પેદા કરે છે. તમને લાગે છે કે તમે લગભગ કામ પૂરું કરી લીધું છે. પછી edge cases આવે છે. Integration નિષ્ફળ જાય છે. Security flaws દેખાય છે.

છેલ્લું 20% માત્ર "finishing touches" નથી. તે ગુણવત્તાનો મુખ્ય ભાગ છે. તે testing, debugging, અને edge-case handling છે.

તમે આને કેવી રીતે સુધારી શકો?

AI ના આઉટપુટને અંતિમ ઉત્પાદન તરીકે માનવાનું બંધ કરો. તેને અવિશ્વસનીય ડેટા તરીકે ગણો.

  • પહેલા tests લખો. ટેસ્ટ જનરેટ કર્યા વગર ક્યારેય logic જનરેટ ન કરો. AI બોલે તે પહેલાં નિષ્ફળતા કેવી દેખાશે તે વ્યાખ્યાયિત કરો.
  • ટુકડાઓમાં validate કરો. ભૂલો શોધવા માટે સંપૂર્ણ system integration ની રાહ ન જુઓ. દરેક નાના બ્લોકને અલગથી ટેસ્ટ કરો.
  • Patching કરવાને બદલે તેને કાઢી નાખો. જો AI function ટેસ્ટમાં નિષ્ફળ જાય, તો તેને લાઇન બાય લાઇન સુધારવાનો પ્રયાસ ન કરો. તેને ડિલીટ કરો અને અલગ prompt નો પ્રયાસ કરો. AI ની ભૂલોને patch કરવાથી ઘણીવાર વધુ ભૂલો ઊભી થાય છે.

80/20 નિયમ એક ચેતવણી છે. AI તમારી ઝડપ વધારે છે, પરંતુ તે ચકાસણી કરવાની તમારી જવાબદારી પણ વધારે છે.

જો તમે તમારો બધો સમય AI ની ભૂલો સુધારવામાં વિતાવો છો, તો તમે કાર્યક્ષમતા મેળવી નથી. તમે ફક્ત એક પ્રકારના કામના બદલામાં બીજું કામ મેળવ્યું છે.

છેલ્લો તબક્કો (last mile) એ છે જ્યાં તમે સાબિત કરો છો કે કોડ ખરેખર કામ કરે છે. તે એ છે જ્યાં તમે સાબિત કરો છો કે તમે દેખાવમાં સંપૂર્ણ લાગતા જૂઠથી છેતરાયા નથી.

Source: https://dev.to/amrree/the-illusion-of-efficiency-why-ais-last-mile-costs-everything-a7g

Optional learning community: https://t.me/GyaanSetuAi