ગયા મહિને, એક AI આસિસ્ટન્ટે પ્રોડક્શન પ્રોજેક્ટ માટે Python સ્ક્રિપ્ટ બનાવી હતી. આઉટપુટ કોઈપણ ભૂલ વગર ચાલ્યું. ડેટા પણ સચોટ લાગતો હતો. પરંતુ મેન્યુઅલ રિવ્યુ દરમિયાન ડેટાબેઝ કોલ્સમાં છુપાયેલું N+1 ક્વેરી પેટર્ન જોવા મળી. નાના ડેટાસેટ માટે, કોડ બરાબર કામ કરતો હતો. પરંતુ જ્યારે તેને હજારો રેકોર્ડ્સ સુધી વધારવામાં આવે, ત્યારે એપ્લિકેશન પેરેન્ટ ઓબ્જેક્ટ્સ માટે એક ક્વેરી કરશે અને પછી સંબંધિત ડેટા માટે હજારો ફોલો-અપ ક્વેરીઝ કરશે. પરિણામે એક ભયાનક પર્ફોર્મન્સ સમસ્યા (performance cliff) ઊભી થશે જેને કોઈ યુનિટ ટેસ્ટ પકડી શકશે નહીં.
આ આધુનિક સોફ્ટવેર ડેવલપમેન્ટની વાસ્તવિકતા છે. AI ટૂલ્સ હવે એવી ઝડપે કોડિંગ, ડિબગિંગ અને આર્કિટેક્ચરલ સૂચનો આપી રહ્યા છે જેની સાથે કોઈ માનવી મેચ કરી શકતું નથી. આ ઝડપ સાચી છે. છતાં, તે તમારા કામના સ્વરૂપને મૂળભૂત રીતે બદલી નાખે છે. હવે તમને મુખ્યત્વે સિન્ટેક્સ ટાઈપ કરવા માટે પૈસા આપવામાં આવતા નથી. તમને ઓડિટ કરવા, આર્કિટેક્ટ તૈયાર કરવા અને બરાબર આ પ્રકારના અદ્રશ્ય જાળ (traps) પકડવા માટે ચૂકવવામાં આવે છે.
"તાર્કિક પણ ખોટું" હોવાનું છુપા જોખમ
AI દ્વારા જનરેટ થયેલો કોડ ઘણીવાર સાચો લાગે છે કારણ કે તે કમ્પાઈલ થાય છે, ચાલે છે અને અપેક્ષિત મૂલ્ય આપે છે. ઉપરછટ રીતે લોજિક બરાબર લાગે છે. પરંતુ અંદરથી તે શાંતિથી તૂટી શકે છે.
રેગ્યુલર એક્સપ્રેશન્સ (regular expressions) લો. એક AI તમને એવું પેટર્ન આપી શકે છે જે અંગ્રેજીમાં ઈમેલ એડ્રેસ અથવા આઈડેન્ટિફાયર્સને સંપૂર્ણ રીતે મેચ કરે છે. પરંતુ જ્યારે તમે તે જ એક્સપ્રેશન જર્મન ઉમલાઉટ્સ (umlauts), અરબી લિપિ અથવા યુનિકોડ નોર્મલાઇઝેશન એજ કેસ પર ચલાવો છો, ત્યારે તે નિષ્ફળ જાય છે. કોડ એવી રીતે ખોટો નથી કે જે એક્સેપ્શન (exception) ફેંકે, પરંતુ તે ફક્ત વાસ્તવિક દુનિયાના માન્ય ડેટાને બાકાત રાખે છે.
ડેટાબેઝ ક્વેરીઝમાં પણ સમાન જોખમ રહેલું છે. એક AI PostgreSQL ક્વેરી લખી શકે છે જે ટેસ્ટિંગ દરમિયાન સાચી રો (rows) આપે છે, છતાં તે તમારા ટેબલ્સને ડેડ ટ્યુપલ્સ (dead tuples) થી ભરી શકે છે, ઇન્ડેક્સના ઉપયોગને અવગણી શકે છે અથવા સિક્વન્શિયલ સ્કેન (sequential scans) માટે મજબૂર કરી શકે છે જે પ્રોડક્શન વર્કલોડને નુકસાન પહોંચાડે છે. ડેમો ડેટાસેટમાં જે કામ કરે છે અને વાસ્તવિક લોડ હેઠળ જે કામ કરે છે તે બંને અલગ બાબતો છે. મશીનને લેટન્સી (latency) અનુભવાતી નથી. તે ક્લાઉડનું બિલ ચૂકવતું નથી.
લખવાથી વેરિફાય કરવા તરફ
મુખ્ય પરિવર્તન "હું આ કેવી રીતે લખું?" થી "હું આ કેવી રીતે વેરિફાય કરું?" તરફ જવાનું છે. જ્યારે AI પ્રથમ ડ્રાફ્ટ સંભાળે છે, ત્યારે તમારું કોગ્નિટિવ લોડ (cognitive load) નીચેના તબક્કા તરફ ખસવું જોઈએ. તમારે કોડને એવી રીતે વાંચવાની જરૂર છે જે રીતે એક સિક્યુરિટી ઓડિટર વાંચે છે, નહીં કે એવી રીતે જે રીતે એક થાકેલો લેખક પોતાનું કામ ઝડપથી વાંચી જાય છે.
આ માટે અલગ પ્રકારના શિસ્તની જરૂર છે. ઓટોમેશન બાયસ (Automation bias) વાસ્તવિક છે. જ્યારે કોઈ ટૂલ પ્રવાહી અને સિન્ટેક્ટિકલી પરફેક્ટ આઉટપુટ આપે છે, ત્યારે માનવ મગજ રિલેક્સ થઈ જાય છે. તમે રજૂઆત સુંદર હોવાથી તેને સાચું માની લો છો. તે આવેશનો પ્રતિકાર કરવો એ હવે મુખ્ય કૌશલ્ય છે. જ્યાં સુધી સાબિત ન થાય ત્યાં સુધી તમારે દરેક સૂચનને એક પરિકલ્પના (hypothesis) માનવી જોઈએ.
મશીન સાથે કામ કરવું
AI કોડિંગ આસિસ્ટન્ટ પાસેથી ઉપયોગી આઉટપુટ મેળવવાનો અર્થ ઝડપથી ટાઈપ કરવું એ નથી. તે મશીનના ટ્રેનિંગ ડેટા અને તમારી ચોક્કસ વાસ્તવિકતા વચ્ચેનું અંતર ઘટાડવા વિશે છે. તમે કેટલીક નક્કર પદ્ધતિઓ દ્વારા તે અંતર ઘટાડી શકો છો.
તમારા પ્રોમ્પ્ટ્સમાં ચોકસાઈ રાખો. અહીં અસ્પષ્ટતા કવિતા નથી બનાવતી; તે બગ્સ (bugs) બનાવે છે. "optimize this function" જેવો પ્રોમ્પ્ટ સામાન્ય સલાહ લાવશે. તેના બદલે, "refactor this Python loop to use a single bulk database update instead of iterated saves" લખો. ચોકસાઈ શક્યતાઓને મર્યાદિત કરે છે.
વાસ્તવિક સંદર્ભ (context) પૂરો પાડો. જ્યાં સુધી તમે ન કહો ત્યાં સુધી AI ને ખબર નથી કે તમે Kubernetes ક્લસ્ટરની અંદર PostgreSQL 15 પર Django 4.2 ચલાવી રહ્યા છો જેમાં 30 સેકન્ડનો સ્ટ્રિક્ટ રિક્વેસ્ટ ટાઈમઆઉટ છે. તેને તમારા ડિપેન્ડન્સી વર્ઝન, તમારી ઇન્ટરનલ લાઇબ્રેરીઓ અને તમારી અનિવાર્ય મર્યાદાઓ આપો. સંદર્ભ એ માત્ર શણગાર નથી; તે ગાર્ડરેલ્સ (guardrails) છે.
તમારા પોતાના દસ્તાવેજો સાથે જવાબોને આધારિત કરો. Retrieval-Augmented Generation, અથવા RAG, એ માત્ર ચેટબોટ્સ માટેનો શબ્દ નથી. તમારા આસિસ્ટન્ટને તમારા વાસ્તવિક API સ્પેસિફિકેશન્સ, તમારા આર્કિટેક્ચર ડિસિઝન રેકોર્ડ્સ અને તમારા કોડબેઝ કન્વેન્શન્સ તરફ નિર્દેશિત કરો. જ્યારે મોડેલ ટ્રેનિંગ ડેટામાંથી અનુમાન લગાવવાને બદલે તમારા ડોક્યુમેન્ટેશનમાંથી તથ્યો મેળવે છે, ત્યારે સામાન્ય સલાહ અને ઉપયોગી કોડ વચ્ચેનું અંતર નોંધપાત્ર રીતે ઘટી જાય છે.
જટિલ કામને અલગ-અલગ કાર્યોમાં વહેંચો. એજન્ટ પેટર્ન ત્યારે શ્રેષ્ઠ રીતે કામ કરે છે જ્યારે દરેક સ્ટેપનો વ્યાપ મર્યાદિત હોય. એકસાથે આખું માઇક્રોસર્વિસ રિફેક્ટર કરવાનું ન પૂછો. પહેલા ડેટા સ્કીમા માંગો. તેને વેરિફાય કરો. પછી માઇગ્રેશન સ્ક્રિપ્ટ માંગો. તેને વેરિફાય કરો. પછી સર્વિસ લેયર પર આગળ વધો.