નફો:
- ઇનલાઇન પૂર્ણતા સાથે કાર્યના પ્રકારને સુધારવા માટે ચેટ મોડને મેપ કરવાની ક્ષમતા
- શક્તિશાળી ઉત્પાદન સંકેતો લખવાની ક્ષમતા જેમાં ઇનપુટ/આઉટપુટ કોન્ટ્રાક્ટ, એજ કેસ અને શૈલીની મર્યાદાઓનો સમાવેશ થાય છે
- મર્જ કરતા પહેલા જનરેટ કરેલ કોડ અને કોઈપણ નવી સૂચિત નિર્ભરતાને માન્ય કરવાની ક્ષમતા
AI સાથે વિકાસકર્તાનો પ્રથમ સંપર્ક ઘણીવાર સ્વતઃપૂર્ણ હોય છે - એક વિશેષતા જે તમે ટાઇપ કરો ત્યારે આગળની લાઇન સૂચવે છે - અથવા ચેટ વિંડોમાં "તે ફંક્શન ટાઇપ કરો" એમ કહીને. તેઓ બંને એક જ એન્જિનનો ઉપયોગ કરે છે પરંતુ અલગ-અલગ શિસ્તની જરૂર છે. આ એકમમાં, અમે કોડ જનરેશનને રેન્ડમ "તેને લખો" માંથી એન્જિનિયરિંગ સ્ટેપમાં રૂપાંતરિત કરીએ છીએ જેનું આઉટપુટ અનુમાનિત અને ચકાસી શકાય તેવું છે.
ધ્યેય એ છે કે AI ને એવા ટૂલમાંથી ફેરવવું કે જે તમારા ટાઈપિંગ મશીનને એક એપ્રેન્ટિસ તરીકે ઝડપી બનાવે છે જે તમે સેટ કરેલી મર્યાદાઓમાં કામ કરે છે. સારી રીતે માર્ગદર્શન આપનાર એપ્રેન્ટિસ સમય બચાવે છે; એક માર્ગદર્શક એપ્રેન્ટિસ એક વાસણ પેદા કરે છે જેને તમારે પછીથી સાફ કરવી પડશે.
બે ઉપયોગની સ્થિતિઓ: ઇનલાઇન પૂર્ણતા અને ચેટ
જ્યારે તમે તમારા એડિટરમાં ટાઇપ કરો છો તેમ ઇનલાઇન પૂર્ણ થાય છે; તમે ફંક્શન સિગ્નેચર અથવા કોમેન્ટ લાઇન ટાઇપ કરો અને તે બાકીનું સૂચવે છે. તે ઝડપ માટે સરસ છે, પરંતુ તેનો એક સાંકડો સંદર્ભ છે: તે માત્ર નજીકના વિસ્તારમાં જ કોડ જુએ છે. તેથી જ જ્યારે તમે ટિપ્પણીમાં તમારો ઇરાદો સ્પષ્ટ રીતે લખો ત્યારે તે શ્રેષ્ઠ કાર્ય કરે છે. ઉદાહરણ તરીકે, જો અમાન્ય ટિપ્પણી નીચે આપેલા સૂચનને નોંધપાત્ર રીતે સુધારે તો // માન્ય વપરાશકર્તા ઇમેઇલ, માન્યતા ભૂલ ફેંકો.
ચેટ મોડ મોટા અને માળખાગત કાર્યો માટે છે: "આ વર્ગમાં પૃષ્ઠ ક્રમાંકન ઉમેરો", "તે સેવાનો ઇન્ટરફેસ કાઢો". અહીં તમારી પાસે ભૂમિકા, સંદર્ભ અને ફોર્મેટ આપવાની લક્ઝરી છે. સામાન્ય નિયમ છે: નાના અને વહેતા કાર્યોની પૂર્ણતા, વિચારો અને રચનાની જરૂર હોય તેવા કાર્યો માટે વાતચીત.
ટીપ: "ટૅબ" વડે પૂર્ણતાના સૂચનને આંખ બંધ કરીને સ્વીકારશો નહીં. એક સેકન્ડ માટે સૂચિત લાઇન વાંચો; અયોગ્ય ચલ નામ અથવા ઊંધી સ્થિતિ અહીંથી સામાન્ય રીતે લીક થાય છે.
ઈરાદાને કોડમાં અનુવાદિત કરવાના પગલાં
- કરાર વ્યાખ્યાયિત કરો. ફંક્શનનું ઇનપુટ, આઉટપુટ અને એરર બિહેવિયર શું છે? જેમ કે "મેઈલ મેળવો, જો માન્ય હોય તો સામાન્ય કરો, જો અમાન્ય હોય તો ભૂલ ફેંકો".
- અવરોધો જણાવો. બાહ્ય નિર્ભરતાનો ઉપયોગ કરશો નહીં? ચોક્કસ શૈલી માર્ગદર્શિકા? શું પ્રદર્શનની કોઈ મર્યાદા છે?
- એક ઉદાહરણ આપો. ઇનપુટ–આઉટપુટ જોડી (“ali@x.com → માન્ય, ali@ → ભૂલ”) મોડેલની ઉદ્દેશ્યની સમજણને અનુમાનથી ચોકસાઇ તરફ લઈ જાય છે.
- નાના ટુકડાઓ માટે પૂછો. એક કાર્ય, એક જવાબદારી. પછી આગામી એક પર ખસેડો.
- જનરેટ કરેલ કોડ વાંચો અને ચલાવો. કમ્પાઇલ કરવું + એક ઝડપી મેન્યુઅલ પ્રયાસ એ સૌથી સસ્તું ખાતરી પગલું છે.
ત્રણ મિની કેસ
કેસ 1 - ટિપ્પણી-આધારિત ઉત્પાદન ચોકસાઈ વધારે છે. ડેવલપરે પહેલા ખાલી બોડી સાથે ડેટ પાર્સિંગ ફંક્શનની વિનંતી કરી અને 3 રાઉન્ડમાં સાચું પરિણામ મેળવ્યું. બીજા પ્રયાસમાં, જ્યારે મેં 4-લાઇન ટિપ્પણી (સ્વીકૃત ફોર્મેટ્સ, ટાઇમ ઝોનનો નિયમ, ભૂલની સ્થિતિ) સાથે ફંક્શનને વ્યાખ્યાયિત કર્યું અને તેની વિનંતી કરી, ત્યારે પ્રથમ રાઉન્ડમાં કામ કરતો કોડ આવ્યો. સમાન મોડેલ, તે જ દિવસ; તફાવત માત્ર ઇરાદાની સ્પષ્ટતાનો હતો.
કેસ 2 - સંસ્કરણનો ઉલ્લેખ ન કરવો ખર્ચાળ છે. એક ટીમે Node.js માટે ઉત્પાદિત કોડમાં fs.promises ને બદલે લેગસી કૉલબેક-આધારિત API સાથે સંઘર્ષ કર્યો. જ્યારે પ્રોમ્પ્ટમાં "Use Node 20, ESM, async/await" લાઇન ઉમેરવામાં આવી, ત્યારે પ્રોડક્શને પ્રથમ વખત પ્રોજેક્ટને અનુસર્યો; કરેક્શન પર ખર્ચવામાં આવેલ સરેરાશ 12 મિનિટ રીસેટ કરવામાં આવી હતી.
કેસ 3 - બોઈલરપ્લેટ કોડમાં વાસ્તવિક લાભ. માઇક્રોસર્વિસ માટે 6 નવા DTO (ડેટા ટ્રાન્સફર ઑબ્જેક્ટ — એક સરળ ડેટા ક્લાસ કે જે સ્તરો વચ્ચે ડેટા વહન કરે છે) અને તેમના માન્યતા નિયમોની જરૂર છે. લગભગ 90 મિનિટનું મેન્યુઅલ વર્ક જે AI દ્વારા ઉત્પાદન અને સમીક્ષા કરવામાં આવ્યું ત્યારે ઘટાડીને 35 મિનિટ કરવામાં આવ્યું હતું; કોડ રિપીટિશન વધુ હોવાથી અને પેટર્ન સ્પષ્ટ હોવાથી, AI એ અહીં તેના સૌથી કાર્યક્ષમ ક્ષેત્રમાં કામ કર્યું છે.
ચાર નકલ કરી શકાય તેવા નમૂનાઓ
કરાર આધારિત કાર્ય જનરેશન:
ભૂમિકા: તમે મહેનતું {{language}} ડેવલપર છો. કાર્ય કરાર:- નામ: {{name}}- ઇનપુટ: {{પ્રકાર અને તેનો અર્થ}}- આઉટપુટ: {{પ્રકાર અને અર્થ}}- ભૂલની સ્થિતિ: {{શું ફેંકવામાં આવે છે/પાછું આવે છે ત્યારે}}અવરોધ: {{કોઈ બાહ્ય નિર્ભરતા/શૈલી નથી}}-{100}/શૈલી/પ્રદર્શન-પ્રદર્શન/input/input/input {{what is thrown/returned when}} {{output_1}}- {{entry_2}} -> {{error_2}}પહેલા સહી + ટૂંકી યોજના આપો, પછી કોડ આપો. લેખન પરીક્ષણો, માત્ર કાર્ય.
હાલની શૈલી સાથે મેળ કરવા (કોડ આધારને અનુકૂલન):
નીચે અમારા પ્રોજેક્ટમાંથી એક ઉદાહરણ કાર્ય છે; અહીં નામકરણ, ભૂલ સંભાળવાની અને ટિપ્પણી કરવાની શૈલી શીખો. સમાન શૈલી સાથે {{new_task}} માટે ફંક્શન લખો. ઉદાહરણ: {{current_code}}
હાડપિંજરથી ભરવા સુધી (સ્ટબ → અમલીકરણ):
ટિપ્પણીઓમાં TODOs અનુસાર નીચેના ફંક્શન સ્કેલેટન ભરો. સહી અને રીટર્નનો પ્રકાર બદલો. સહાયક કાર્ય ન કરો જે અસ્તિત્વમાં નથી; જો જરૂરી હોય, તો મને જણાવો "આ સહાયકની જરૂર છે". {{સ્કેલેટ_કોડ}}
વૈકલ્પિક એપ્લિકેશન સરખામણી:
{{task}} માટે 2 અલગ-અલગ અમલીકરણો આપો: (a) વાંચનક્ષમતાને પ્રાથમિકતા આપવી, (b) પ્રદર્શનને પ્રાથમિકતા આપવી. દરેકની નીચે 1 વાક્ય "જ્યારે પ્રાધાન્યક્ષમ છે" લખો.
નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ
નબળા: "મને એક ઇમેઇલ ચકાસણી કાર્ય લખો."
સશક્ત: "TypeScript 5, પ્રમાણભૂત લાઇબ્રેરી માત્ર. isValidEmail(ઇનપુટ: સ્ટ્રિંગ): બુલિયન લખો. સ્પેસને ટ્રિમ કરો, તેને કેસને અસંવેદનશીલ બનાવો, a@b.co માન્ય છે, a@, @b.co, ખાલી સ્ટ્રિંગ અમાન્ય છે. જો તમે રેગેક્સનો ઉપયોગ કરવા જઈ રહ્યાં છો, તો વધુ જટિલ ટિપ્પણીઓ ઉમેરશો નહીં."
શક્તિશાળી સંસ્કરણ; ભાષા, સંસ્કરણ, હસ્તાક્ષર, કિનારી કેસો અને શૈલીની મર્યાદા પરત કરે છે. આમ, જનરેટ કરેલ કોડ તમારા પ્રોજેક્ટમાં કામ કરે છે અને બંધબેસે છે.
અભિગમ
ક્યારે વાપરવું
ધ્યાન
ઇનલાઇન પૂર્ણતા
પ્રવાહમાં નાના દાખલ
સૂચન વાંચ્યા વિના સ્વીકારશો નહીં
ચેટમાં કરાર આધારિત ઉત્પાદન
નવું કાર્ય/વર્ગ
ઉદાહરણ અને ધાર કેસ આપો
શૈલી નમૂના દ્વારા ઉત્પાદન
હાલના કોડમાં ઉમેરી રહ્યા છીએ
વર્તમાન નમૂના કોડ પસંદ કરો
હાડપિંજર ભરણ
સહી નિશ્ચિત, શરીર ખાલી
સહી બદલવી
કોડ ડુપ્લિકેશન અને ડિપેન્ડન્સી ટ્રેપ
AI વારંવાર તેના કામને સરળ બનાવવા માટે નવી લાઇબ્રેરીની ભલામણ કરે છે. કેટલીકવાર આ સચોટ હોય છે, કેટલીકવાર તે તમારા પ્રોજેક્ટમાં બિનજરૂરી નિર્ભરતા ઉમેરે છે અથવા કોઈ પેકેજ સૂચવે છે જે અસ્તિત્વમાં નથી (એક આભાસ). નિયમ: તમે દરેક નવી નિર્ભરતાની પુષ્ટિ કરો છો. પેકેજ ખરેખર અસ્તિત્વમાં છે, જાળવવામાં આવે છે અને યોગ્ય લાઇસન્સ ધરાવે છે તેની ચકાસણી કર્યા વિના તેને પ્રોજેક્ટમાં ઉમેરશો નહીં. મોટાભાગે પ્રોજેક્ટમાં પહેલેથી જ હેલ્પર નવા પેકેજ કરતાં વધુ સારી હોય છે.
સાવધાન: AI દ્વારા સૂચવવામાં આવેલી આયાત લાઇનની સમીક્ષા કરો. અવિદ્યમાન પેકેજ નામ (જે "ટાઈપો-સ્ક્વેટિંગ" તરીકે ઓળખાતા નકલી પેકેજો જેવું પણ હોઈ શકે છે) સંકલનને તોડે છે અને સુરક્ષા જોખમ ઊભું કરે છે.
સામાન્ય ભૂલો
- મોડેલ દ્વારા નિર્ધારિત હસ્તાક્ષર રાખવાથી. જો તમે ઇનપુટ/આઉટપુટ પ્રકારોને ઠીક કરતા નથી, તો દરેક ઉત્પાદન સાથે અલગ સહી આવે છે અને એકીકરણ મુશ્કેલ બને છે.
- ધાર કેસો ઉલ્લેખ નથી. ખાલી ઇનપુટ, નલ, નેગેટિવ નંબર, ખૂબ મોટી કિંમત — જો તમે આનો ઉલ્લેખ ન કરો, તો મોડલ "હેપ્પી પાથ" લખે છે, કિનારીઓ છોડીને.
- પરીક્ષણ કર્યા વિના સૂચનને જોડવું. કોડ જે કામ કરતો દેખાય છે તેનો અર્થ એ નથી કે તે કામ કરે છે.
- બિનજરૂરી નિર્ભરતા સ્વીકારવી. વન-લાઇનર માટે આખી લાઇબ્રેરી ઉમેરવાથી ટેક્નિકલ ડેટ સર્જાય છે.
- શૈલીની અસંગતતા. બાકીના પ્રોજેક્ટમાંથી અલગ નામકરણ અને ભૂલ હેન્ડલિંગ કોડ બેઝને પેચી બનાવે છે.
સારાંશમાં
જ્યારે તમે ઇરાદાને સ્પષ્ટ કરારમાં અનુવાદિત કરો છો ત્યારે કોડ જનરેશન શક્તિશાળી હોય છે. નાના, ઇન-સ્ટ્રીમ કાર્યો અને વાતચીતમાં માળખું સ્થાપિત કરતા કાર્યો માટે ઇનલાઇન પૂર્ણતાનો ઉપયોગ કરો. તમે ઇનપુટ/આઉટપુટ પ્રકારો, ધાર કેસો, સંસ્કરણ અને શૈલીનો ઉલ્લેખ કરો છો; મોડેલનું ઉદાહરણ આપો; દરેક નવી નિર્ભરતાને ચકાસો; અને ચલાવો અને ઉત્પાદિત દરેક ભાગ વાંચો. AI ફોર્મ્યુલેક, પુનરાવર્તિત કોડમાં શ્રેષ્ઠ ચૂકવણી કરે છે — તમે સેટ કરેલી મર્યાદામાં, તેને ત્યાં જ ચલાવો.
એપ્લિકેશન કાર્ય
તમારા પ્રોજેક્ટમાંથી એક વાસ્તવિક નાનું કાર્ય પસંદ કરો જે તમારે લખવાની જરૂર છે. ઇનપુટ/આઉટપુટ પ્રકારો, બે એજ કેસ અને શૈલીની મર્યાદા આપીને પહેલા તેને AI પર “કોન્ટ્રાક્ટ-આધારિત ફંક્શન જનરેશન” ટેમ્પલેટ સાથે પ્રિન્ટ કરો. જનરેટ કરેલ કોડ કમ્પાઇલ કરો અને તેને બે અલગ અલગ ઇનપુટ્સ સાથે અજમાવો. પછી એ જ ફંક્શનને ફરીથી પૂછો, આ વખતે કોઈ પણ સંદર્ભ વગર “મને આ લખો” અને બે આઉટપુટની લાઇન બાય લાઇનની સરખામણી કરો: કયા કિસ્સાઓ ચૂકી ગયા હતા, કેટલા સુધારા જરૂરી હતા?
ચેકલિસ્ટ
- [ ] હું જાણું છું કે ઇનલાઇન પૂર્ણતા સાથે ચેટ મોડનો ક્યાં ઉપયોગ કરવો.
- [ ] હું ફંક્શન જનરેશનમાં ઇનપુટ/આઉટપુટ કોન્ટ્રાક્ટ અને એજ કેસ નક્કી કરું છું.
- [ ] મેં પ્રોમ્પ્ટમાં ભાષા અને સંસ્કરણ માહિતી ઉમેરવાની આદત બનાવી છે.
- [ ] હું દરેક ઉત્પાદિત ટુકડાને એસેમ્બલ કરતા પહેલા તેનું કમ્પાઇલ અને પરીક્ષણ કરું છું.
- [ ] હું એઆઈ દ્વારા પ્રસ્તાવિત દરેક નવી નિર્ભરતાને તેના અસ્તિત્વ અને આવશ્યકતાની ચકાસણી કરીને પુષ્ટિ કરું છું.
- [ ] હું તપાસું છું કે જનરેટ કરેલ કોડ પ્રોજેક્ટની શૈલી સાથે મેળ ખાય છે.