સૉફ્ટવેર ટીમો માટે આર્ટિફિશિયલ ઇન્ટેલિજન્સ: વર્કિંગ મોડલ અને મર્યાદાઓ

નફો:

• કોડિંગ સહાયક ભાષા મોડેલ તરીકે કેવી રીતે કાર્ય કરે છે અને ટોકન, સંદર્ભ વિન્ડો, આભાસની વિભાવનાઓ સમજાવવાની ક્ષમતા
• સૉફ્ટવેર કાર્યોને અલગ કરવાની ક્ષમતા જ્યાં AI મજબૂત અને માનસિક નકશા સાથે નબળા છે
• તેમના પોતાના કાર્યો માટે પ્રસ્તાવ-ઉત્પાદન-ચકાસણીના મૂળભૂત કાર્ય ચક્રને લાગુ કરવાની ક્ષમતા

સોફ્ટવેર ડેવલપરનો દિવસ "શરૂઆતથી કોડ લખવામાં" ભાગ્યે જ પસાર થાય છે. વાસ્તવિક સમય; કોઈ બીજા દ્વારા લખાયેલ કોડ વાંચવો, બગનું પુનઃઉત્પાદન કરવાનો પ્રયાસ કરો, લોગ સ્કેન કરો (ચાલતી વખતે એપ્લિકેશન દ્વારા ઉત્પાદિત લોગ લાઈનો), પરીક્ષણો લખવા, PR લખવા (પુલ વિનંતી - એક મર્જ વિનંતી જ્યાં ટીમ સમીક્ષા માટે કોડમાં ફેરફાર સબમિટ કરવામાં આવે છે) સમજૂતી અને દસ્તાવેજીકરણ અપડેટ કરવું. આર્ટિફિશિયલ ઇન્ટેલિજન્સ (AI) એ સ્પીડ મલ્ટીપ્લાયર છે જે લગભગ આ બધી અદ્રશ્ય નોકરીઓને સ્પર્શ કરી શકે છે. પરંતુ તેનો સુરક્ષિત ઉપયોગ કરવાની પ્રથમ શરત એ છે કે તે શું છે અને શું નથી તે યોગ્ય રીતે સમજવું.

આ એકમમાં, અમે સૌપ્રથમ સાદી ભાષામાં કોડિંગ સહાયકની અંતર્ગત ટેકનોલોજી સમજાવીએ છીએ; પછી અમે મોડેલની શક્તિ અને નબળાઈઓનો માનસિક નકશો બનાવીએ છીએ; અંતે, અમે મૂળભૂત કાર્યકારી શિસ્ત સ્થાપિત કરીએ છીએ જેનો અમે સમગ્ર મોડ્યુલ દરમિયાન ઉપયોગ કરીશું: પ્રસ્તાવ, ઉત્પાદન, ચકાસણી. આ ત્રણ પગલાં આગામી અગિયાર એકમોની કરોડરજ્જુ છે.

નોંધ: આ મોડ્યુલ એક સામાન્ય તાલીમ છે. સુરક્ષા-નિર્ણાયક સોફ્ટવેરમાં (ચુકવણી પ્રક્રિયા, આરોગ્યસંભાળ, પ્રમાણીકરણ, નિર્ણાયક ઇન્ફ્રાસ્ટ્રક્ચર) AI આઉટપુટ એ યોગ્ય ઇજનેર દ્વારા સમીક્ષા અને મંજૂરીનો વિકલ્પ નથી. AI એક સહાયક છે; હસ્તાક્ષર કરનાર એન્જિનિયર છે.

કોડિંગ સહાયક ખરેખર શું કરે છે?

મોટા ભાગના કોડિંગ આસિસ્ટન્ટ્સ મોટા ભાષાના મોડલ પર બનેલા છે (LLM—એક AI વિશાળ માત્રામાં ટેક્સ્ટ અને કોડ પર પ્રશિક્ષિત છે જે આગામી સંભવિત "ચંક"ની આગાહી કરે છે). મોડેલ માણસની જેમ કોડને "સમજતું" નથી; તે ઉદાહરણોના વિશાળ પૂલમાંથી તે શીખે છે તે દાખલાઓના આધારે, તમે તેને જે સંદર્ભ આપો છો તેની સંભવતઃ ચાલુ રહે છે. આ દેખીતી રીતે સરળ પદ્ધતિ વ્યવહારમાં આશ્ચર્યજનક રીતે નિપુણ પરિણામો આપે છે - કારણ કે મોટાભાગના સોફ્ટવેરમાં પુનરાવર્તિત પેટર્નનો સમાવેશ થાય છે: એક HTTP વિનંતી, લૂપ, નલ ચેક, એક પરીક્ષણ પેટર્ન.

અહીં ત્રણ શબ્દો મહત્વપૂર્ણ છે. ટોકન એ સૌથી નાનું એકમ છે જે મોડેલ ટેક્સ્ટને વિભાજિત કરીને પ્રક્રિયા કરે છે; તે લગભગ થોડા અક્ષરો અથવા શબ્દનો ભાગ છે. સંદર્ભ વિન્ડો એ ટોકન્સનો જથ્થો છે જે મોડેલ એક જ સમયે "જોઈ" શકે છે; તમારો કોડ, ભૂલ સંદેશ અને સૂચના આ વિન્ડોમાં ફિટ હોવી જોઈએ. પ્રોમ્પ્ટ એ બધી સૂચનાઓ અને સંદર્ભ છે જે તમે મોડેલને આપો છો. તમે મેળવો છો તે આઉટપુટની ગુણવત્તા આ બે પર સીધો આધાર રાખે છે: તમે મોડેલને જેટલો બહેતર સંદર્ભ અને સ્પષ્ટ સૂચનાઓ આપશો, તેટલું સારું પરિણામ તમને મળશે. ખરાબ ઇનપુટ ખરાબ આઉટપુટ પેદા કરે છે, ભલે તે સ્માર્ટ મોડલ હોય — સોફ્ટવેરનો ક્લાસિક “ગાર્બેજ ઇન, ગાર્બેજ આઉટ” નિયમ AI પર પણ લાગુ પડે છે.

શક્તિ અને નબળાઈઓનો નકશો

AI ને યોગ્ય નોકરીઓ તરફ દિશામાન કરવા માટે, તે જાણવું જરૂરી છે કે તે ક્યાં ચમકે છે અને ક્યાં ઠોકર ખાય છે. આ નકશાને યાદ રાખવાથી તમને દરેક આગામી મિશન સાથે આશ્ચર્ય થશે, "શું મારે આ કામ AI ને આઉટસોર્સ કરવું જોઈએ કે જાતે કરવું જોઈએ?" તે તમને સેકંડમાં પ્રશ્નનો જવાબ આપવા દે છે.

તેની શક્તિઓ છે: બોઈલરપ્લેટ કોડ જનરેટ કરવો, એક ભાષામાંથી બીજી ભાષામાં અનુવાદ કરવો, રેગ્યુલર એક્સપ્રેશન (રેજેક્સ) લખવું, ફંક્શનનું વર્ણન કરવું, ટેસ્ટ સ્કેલેટન બનાવવું, એરર મેસેજનું અર્થઘટન કરવું, દસ્તાવેજીકરણનો મુસદ્દો તૈયાર કરવો, ચલ/ફંક્શનના નામ સૂચવવા અને નાના રિફેક્ટરિંગ્સ (કોડની વર્તણૂક બદલ્યા વિના તેની રચનામાં સુધારો કરવો).

નબળાઈઓ: તમારા કંપની-વિશિષ્ટ વ્યવસાય નિયમોને જાણવું, તમારા સમગ્ર કોડ બેઝને યાદ રાખવું, કોડને વાસ્તવમાં ચલાવવું અને તેની ચકાસણી કરવી, લાઇબ્રેરીના નવીનતમ સંસ્કરણોને ખાતરીપૂર્વક જાણવું, સો ટકા ગેરંટી સાથે સુરક્ષા નબળાઈઓ શોધવી. સૌથી ખતરનાક બાબત આભાસ છે: મોડલ એક અવિદ્યમાન ફંક્શન, લાઇબ્રેરી અથવા API (ઇંટરફેસ કે જે એપ્લિકેશન્સ વચ્ચે ડેટા એક્સચેન્જને સક્ષમ કરે છે) ખૂબ જ વિશ્વાસપાત્ર ભાષામાં શોધે છે. આ જોખમ વાસ્તવમાં તમારા ફાયદામાં ફેરવી શકાય છે, કારણ કે કોડ, સાદા ટેક્સ્ટથી વિપરીત, તે "કાર્ય કરે છે" કે કેમ તે જોવા માટે પરીક્ષણ કરી શકાય છે - ફક્ત ચકાસણી પગલું અવગણો નહીં.

મિશન પ્રકાર

AI ની ભૂમિકા

માણસની ભૂમિકા

બોઈલરપ્લેટ/હાડપિંજર ઉત્પન્ન કરો

ડ્રાફ્ટ બનાવે છે

અનુકૂલન, સમીક્ષાઓ

કોડ વર્ણન

ઝડપી સારાંશ આપે છે

કોડમાં નિર્ણાયક ભાગને ચકાસે છે

લેખન પરીક્ષણો

કેસ સૂચવે છે

કવરેજ અને ચોકસાઈની પુષ્ટિ કરે છે

સુરક્ષા-નિર્ણાયક તર્ક

મદદરૂપ વિચાર

નિર્ણય અને જવાબદારી સંપૂર્ણપણે માણસો પર રહે છે.

API/લાઇબ્રેરીનો ઉપયોગ

સેમ્પલ જનરેટ કરે છે

અસ્તિત્વ અને સંસ્કરણની ચકાસણી કરે છે

આર્કિટેક્ચરલ નિર્ણય

વિકલ્પો પ્રકારના

સંદર્ભ જાણીને પસંદ કરે છે અને બચાવ કરે છે

સ્ટેપ બાય સ્ટેપ: બેઝિક વર્કિંગ સાયકલ

1. કાર્ય સ્પષ્ટ કરો. જો તમે એક વાક્યમાં તમને જે જોઈએ છે તે લખી શકતા નથી, તો મોડેલ પણ કરી શકતા નથી. અગાઉની અનિશ્ચિતતા ઇનપુટમાં પ્રવેશે છે, તે આઉટપુટમાં વધુ વધે છે.
2. સંદર્ભ આપો. પ્રોમ્પ્ટમાં સંબંધિત કોડ, સંપૂર્ણ ભૂલ સંદેશ, ભાષા/ફ્રેમવર્ક સંસ્કરણ અને અવરોધો ઉમેરો. "આને ઠીક કરો" ન કહો, "Python 3.11, FastAPI 0.110; કહો; આ ફંક્શન 500 ભૂલ આપે છે, જ્યારે વિનંતીનો ભાગ ખાલી હોય ત્યારે તે વિસ્ફોટ થાય છે".
3. ઇમ્પોઝિશન રોલ અને ફોર્મેટ. "તમે સિનિયર ગો ડેવલપર છો; માત્ર કોડ આપો અને બે-વાક્યનો તર્ક" જેવું માળખું આઉટપુટ પર ધ્યાન કેન્દ્રિત કરે છે.
4. નાના માટે પૂછો. એક વિશાળ વિનંતીને બદલે તેને પગલાંઓમાં વિભાજીત કરો; દરેક પગલાને અલગથી ચકાસો. મોટા ફેરફારો જોખમી છે કારણ કે તે ચકાસવા મુશ્કેલ છે અને ભૂલો છુપાવવાની સંભાવના છે.
5. ચકાસો. તેને ચલાવો, તેનું પરીક્ષણ કરો, તેને દૃષ્ટિની રીતે વાંચો. વણચકાસાયેલ AI કોડ એ "સ્કેચ" છે, "સોલ્યુશન" નથી. આ ચક્રનું સૌથી બિન-વાટાઘાટ કરી શકાય તેવું પગલું છે.

ત્રણ મિની કેસ

કેસ 1 - સમયની બચત વાસ્તવિક છે પરંતુ સાધારણ છે. જ્યારે ટીમે AI સાથે નવા CRUD (ક્રિએટ-રીડ-અપડેટ-ડિલીટ) એન્ડપોઇન્ટનું હાડપિંજર બનાવ્યું, ત્યારે પ્રથમ ડ્રાફ્ટનો સમય આશરે 40 મિનિટથી ઘટીને 8 મિનિટ થઈ ગયો. જો કે, સમીક્ષા અને પરીક્ષણ સાથે, કુલ સમય 25 મિનિટ હતો; તેથી વાસ્તવિક લાભ 40 થી 25 છે, લગભગ 38%. આ દર, "અમે 10 વખત વેગ આપ્યો છે" ની અપેક્ષાને બદલે માપવામાં આવે છે, તે ટકાઉ લાભ છે.

કેસ 2 - આભાસ ખર્ચાળ છે. વિકાસકર્તાએ માન્યતા વિના AI-suggested requests.get_json() કૉલનો ઉપયોગ કર્યો; આવી કોઈ પદ્ધતિ નહોતી (ચોક્કસ રીતે response.json()). જ્યારે કોડ કમ્પાઈલ ન થયો ત્યારે 20 મિનિટ ખોવાઈ ગઈ. એક સરળ "શું આ પદ્ધતિ ખરેખર અસ્તિત્વમાં છે?" ચકાસણી નુકશાન રીસેટ કરશે.

કેસ 3 - સારો સંદર્ભ આઉટપુટને બમણું કરે છે. સમાન બગ માટે, એક વિકાસકર્તાએ ફક્ત "મને ભૂલ થઈ રહી છે" લખ્યું હતું અને બીજાએ સંપૂર્ણ સ્ટેક ટ્રેસ, સંસ્કરણ અને ઇનપુટ નમૂના ઉમેર્યા હતા. બાદમાં પ્રથમ પ્રયાસમાં યોગ્ય ઉકેલ મળ્યો; પ્રથમ એક ત્રણ વળાંક ખર્ચ્યા. તફાવત મોડેલમાં ન હતો, પરંતુ ઇનપુટમાં હતો.

ચાર નકલ કરી શકાય તેવા નમૂનાઓ

એક સામાન્ય હેતુ, શક્તિશાળી સ્ટાર્ટઅપ પ્રોમ્પ્ટ:

ભૂમિકા: તમે એક અનુભવી {{language}} વિકાસકર્તા છો.કાર્ય: {{what_want}}સંદર્ભ:- ફ્રેમવર્ક/સંસ્કરણ: {{framework_and_version}}- અવરોધો: {{પ્રદર્શન, શૈલી, નિર્ભરતા નિયમો}}નિયમો:- અસ્તિત્વમાં ન હોય તેવી લાઇબ્રેરી/ફંક્શનનો ઉપયોગ કરશો નહીં; જો તમને ખાતરી ન હોય, તો તેને "ચકાસણી કરો" તરીકે ચિહ્નિત કરો. - પ્રથમ, ટૂંકી યોજના, પછી કોડ, પછી વાજબીતાના 2 વાક્યો આપો. - ટેસ્ટેબલ, વર્કિંગ કોડ તૈયાર કરો.

મોડલમાં અનિશ્ચિતતાને ફિલ્ટર કરવા માટે:

નીચે આપેલા કાર્યને ઉકેલતા પહેલા, ઓછામાં ઓછા 3 મુદ્દાઓની સૂચિ બનાવો જે તમને પ્રશ્નો તરીકે ખૂટે છે અથવા અસ્પષ્ટ લાગે છે. હું જવાબ આપું તે પહેલાં કોડ લખશો નહીં. Task: {{task}}

આઉટપુટ સ્વ-તપાસ કરવા માટે:

તમે નીચેનો કોડ બનાવ્યો છે. હવે તમારી ભૂમિકા બદલો અને આ કોડની ટીકા કરો:- 3 કેસ (એજ કેસો) ની યાદી બનાવો જે કદાચ કામ ન કરે.- શું એવા કોઈ API/ફંક્શન છે જે તમે બનાવી શક્યા હોત? માર્ક કરો.- સુધારેલ સંસ્કરણ આપો.કોડ:{{code}}

નિર્ણયને વિકલ્પોમાં વિભાજીત કરવા માટે:

{{problem}} માટે 2-3 ઉકેલના અભિગમો સૂચવો. દરેક માટે: ટૂંકું વર્ણન, વત્તા/માઈનસ, ક્યારે પસંદ કરવું. ટેબ્યુલર સ્વરૂપમાં આપો. મારા માટે પસંદ કરશો નહીં; ફક્ત વિકલ્પ સ્પષ્ટ કરો.

નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ

નબળા: "આ કોડમાં બગ ઠીક કરો." (કઈ ભૂલ? કઈ ભાષા? અપેક્ષિત વર્તન શું છે?)

સશક્ત: "Python 3.11 / FastAPI 0.110. નીચેનો એન્ડપોઇન્ટ જ્યારે વિનંતીનો મુખ્ય ભાગ ખાલી હોય ત્યારે KeyError સાથે 500 પરત કરે છે; હું ઇચ્છું છું કે તે 400 પરત કરે અને ખાલી બોડી પર અર્થપૂર્ણ સંદેશ આપે. પ્રથમ કારણ સમજાવો, પછી સુધારેલ કાર્ય આપો, પછી આ દૃશ્ય માટે પરીક્ષણ લખો. [code]"

શક્તિશાળી સંસ્કરણ; તે ભાષા, સંસ્કરણ, વાસ્તવિક ભૂલ, અપેક્ષિત વર્તન અને આઉટપુટ ફોર્મેટ આપે છે. મોડેલને હવે આગાહી કરવાની જરૂર નથી.

સામાન્ય ભૂલો

• ચકાસણી વિના વિશ્વાસ કરવો. સૌથી સામાન્ય અને સૌથી ખર્ચાળ ભૂલ. જ્યાં સુધી કોડ કમ્પાઈલ અને ટેસ્ટ ન થાય ત્યાં સુધી "સોલ્વ્ડ" કહો નહીં.
• સંદર્ભ વિના પ્રશ્નો પૂછવા. સંસ્કરણ, ભૂલ ટેક્સ્ટ અને પ્રતિબંધો વિનાનો જવાબ સામાન્ય અને ઘણીવાર ખોટો હોય છે.
• એક વિશાળ વિનંતી. એક જ સમયે 300-લાઇન ઉત્પાદનની વિનંતી અને સમીક્ષા કરવામાં સક્ષમ ન હોવાને કારણે ભૂલો અદૃશ્ય થઈ જાય છે.
• સાબિતી તરીકે મોડેલના આત્મવિશ્વાસને ભૂલ કરવી. AI વિશ્વાસપૂર્વક કંઈક ખોટું કહી શકે છે; ટોન એ ચોકસાઈનું સૂચક નથી.
• રેન્ડમલી કંપની સિક્રેટ પેસ્ટ. ખાનગી ચાવીઓ, ગ્રાહક ડેટા અથવા ખાનગી સ્ત્રોત કોડને અપ્રુવ્ડ ટૂલ્સમાં દાખલ કરવો જોઈએ નહીં (અમે એકમ 10 માં આ વિષયનો અભ્યાસ કરીશું).

ટીપ: દરેક AI આઉટપુટને "આ એક ડ્રાફ્ટ છે" તરીકે માનો. આ એક માનસિક આદત મોટાભાગના જોખમોને ઓલવી નાખે છે જે તમે સમગ્ર મોડ્યુલમાં જોશો.

સારાંશમાં

કોડિંગ આસિસ્ટન્ટ એ એક ભાષાનું મોડેલ છે જે આગામી સંભવિત ભાગની આગાહી કરે છે; તે કોડને સમજી શકતો નથી, તે પેટર્ન બનાવે છે. તેથી જ તે પુનરાવર્તિત, ફોર્મ્યુલાયુક્ત નોકરીઓમાં મજબૂત છે; તે કામ માટે સાવધાનીપૂર્વક ઉપયોગ કરવો જોઈએ જેમાં તમારા સંદર્ભ માટે વિશિષ્ટ હોય તેવી ચકાસણીની જરૂર હોય. સૌથી મોટું જોખમ આભાસ છે, અને એકમાત્ર મારણ એ ચકાસણી છે. આખા મોડ્યુલ દરમિયાન અમે જે શિસ્તનું પાલન કરીશું તે સ્પષ્ટ છે: કાર્યને સ્પષ્ટ કરો, સંદર્ભ આપો, નાના માટે પૂછો, દરેક ડિલિવરેબલને માન્ય કરો.

એપ્લિકેશન કાર્ય

છેલ્લા અઠવાડિયે તમે કરેલા ત્રણ સોફ્ટવેર કાર્યો (દા.ત. બગ ફિક્સ, ટેસ્ટ, README અપડેટ) લખો. દરેક માટે "શક્તિ અને નબળાઈઓનો નકશો" જુઓ અને એક વાક્યમાં વર્ણન કરો કે જો તમારી પાસે AI આ કરે તો તમારી અને AI ની ભૂમિકા શું હશે. પછી ઉપરના "સ્ટાર્ટ પ્રોમ્પ્ટ" ટેમ્પલેટ સાથે AI ને આમાંથી એક કાર્ય આપો અને આઉટપુટ ચલાવો અને ચકાસો; નોંધ કરો કે તમે કેટલી મિનિટો બચાવી છે અને તમારે કેટલી ભૂલો સુધારવાની હતી.

ચેકલિસ્ટ

• [ ] મને સમજાયું કે LLM પેટર્ન બનાવે છે, કોડ "સમજે" નથી.
• હું ટોકન, કોન્ટેસ્ટ વિન્ડો અને પ્રોમ્પ્ટની વિભાવનાઓને એક વાક્યમાં સમજાવી શકું છું.
• [ ] હું કાર્યોના પ્રકારો વચ્ચે તફાવત કરી શકું છું જ્યાં AI મજબૂત અને નબળું છે.
• [ ] હું જાણું છું કે આભાસ શું છે અને એકમાત્ર મારણ એ ચકાસણી છે.
• [ ] મેં મારા પોતાના કાર્ય માટે "પ્રપોઝ, પ્રોડ્યુસ, વેરિફાય" ચક્રને અનુકૂલિત કર્યું.
• [ ] હું નક્કર ઉદાહરણમાં મજબૂત પ્રોમ્પ્ટ અને નબળા પ્રોમ્પ્ટ વચ્ચેનો તફાવત બતાવી શકું છું.