AI દ્વારા બનાવેલા કોડની સમીક્ષા કેવી રીતે કરવી

AI-બનેલા કોડની સમીક્ષા કરવા માટે, શું બદલાયું — કઈ ફાઇલો અને શા માટે — તેથી શરૂઆત કરો, પછી કોડની કોઈ પણ લાઇન વાંચતા પહેલાં વર્તનનું જાતે પરીક્ષણ કરો. તે પછી, એવા ક્ષેત્રો તપાસો જ્યાં AI કોડ સૌથી વધુ વાર ખોટો પડે છે: સર્વર-બાજુ permission checks ખૂટવા, બ્રાઉઝરને દેખાતા રહસ્યો, ચકાસાયા વગરનો input, એવા packages કે functions જે અસ્તિત્વમાં નથી, અને જે વસ્તુઓને સ્પર્શ કરવા તમે ક્યારેય કહ્યું ન હોય તેમાં ફેરફારો.

AI એવો કોડ લખે છે જે સામાન્ય રીતે ચાલે છે અને ઘણી વાર સુઘડ દેખાય છે. આથી ખરેખર તપાસ્યા વગર મંજૂરી આપવી સરળ બને છે. આ માર્ગદર્શિકા એક સમીક્ષા routine છે જે ત્યારે પણ કામ કરે છે, પછી ભલે તમે કોડ સરળતાથી વાંચી શકો કે બિલકુલ નહીં.

જોખમ પ્રમાણે સમીક્ષા માપો

દરેક ફેરફારને એકસરખું ધ્યાન જોઈતું નથી.

પગલું 1: શું બદલાયું તે જુઓ

કોડનો ન્યાય કરતા પહેલાં, ફેરફારોની યાદી મેળવો:

• જો પ્રોજેક્ટ Git માં છે, તો diff જુઓ: છેલ્લા commit પછી બદલાયેલી ફાઇલો અને લાઇનો. જુઓ AI-બનેલી એપ સાથે Git કેવી રીતે વાપરવું.
• અથવા સીધું AI ને પૂછો:

તમે છેલ્લા ફેરફારમાં બદલેલી દરેક ફાઇલની યાદી બનાવો, અને દરેક માટે એક વાક્યમાં સમજાવો કે શું બદલાયું અને શા માટે.

આ તબક્કે લાલ ધ્વજ: વિનંતી સાથે સંબંધ ન ધરાવતી ફાઇલો, કાઢી નાખેલી ફાઇલો, તમે માંગ્યા ન હોય તેવા configuration કે dependencies ના ફેરફારો.

પગલું 2: પહેલા વર્તન ચકાસો

કોડ વાંચવાથી ખબર પડે છે કે તે શું કરવા માટે છે; પરીક્ષણથી ખબર પડે છે કે તે ખરેખર શું કરે છે. વાંચતા પહેલાં:

• સામાન્ય વપરાશકર્તા તરીકે, desktop અને phone-કદની સ્ક્રીન પર ફેરફાર અજમાવો.
• ખોટા input સાથે અજમાવો: ખાલી fields, ખૂબ લાંબું લખાણ, ઋણ સંખ્યાઓ, ભૂતકાળની તારીખ.
• લૉગ આઉટ અવસ્થામાં, અને બીજા વપરાશકર્તા તરીકે અજમાવો.
• સૌથી મહત્વના flows ફરી ચલાવો: sign up, log in, મુખ્ય ક્રિયા, પેમેન્ટ.

જો પરીક્ષણ નિષ્ફળ જાય, તો તમે વાંચવાનો સમય બચાવ્યો છે — તેને સ્પષ્ટપણે જણાવો અને AI ને ઠીક કરવા દો. જુઓ સારો bug report કેવી રીતે લખવો.

પગલું 3: સર્વર પર permissions તપાસો

તપાસવાની સૌથી મહત્વની વસ્તુ. AI tools ઘણી વાર પેજમાં બટન છુપાવે છે, પણ સર્વરને કોઈ પણ પૂછનાર માટે ક્રિયા કરવા તૈયાર છોડી દે છે.

દરેક route કે function માટે જે ડેટા વાંચે કે બદલે, પૂછો:

• શું તે તપાસે છે કે વપરાશકર્તા લોગ ઇન છે?
• શું તે તપાસે છે કે આ વપરાશકર્તાને આ record ઍક્સેસ કરવાની મંજૂરી છે?
• શું તે તપાસ સર્વર પર છે, ફક્ત પેજમાં નહીં?

તમે ઉમેરેલા કે બદલેલા દરેક API route માટે, કહો કે સર્વર પર તે કયો permission check કરે છે, તે લાઇન ટાંકીને. જે route માં તે નથી તેને ચિહ્નિત કરો.

પછી તેનું પરીક્ષણ કરો: વપરાશકર્તા A તરીકે લોગ ઇન કરો, એક record નો ID નોંધો, પછી વપરાશકર્તા B તરીકે લોગ ઇન કરીને તે માંગો. પૂર્ણ પરીક્ષણ AI-બનેલી એપ્સ માટે સુરક્ષા ચેકલિસ્ટ માં છે.

પગલું 4: ખુલ્લા રહસ્યો શોધો

• બદલાયેલી ફાઇલોમાં કોઈ key અથવા password જેવું લાગે તે શોધો.
• તપાસો કે secret keys environment variables માંથી વંચાય છે અને ફક્ત server કોડમાં વપરાય છે.
• secret variables પર VITE_ અથવા NEXT_PUBLIC_ જેવા જાહેર prefixes માટે સાવધ રહો — તે બ્રાઉઝર કોડમાં બિલ્ડ થઈ જાય છે.

જુઓ API keys કેવી રીતે સુરક્ષિત રાખવી.

પગલું 5: input અને ભૂલો તપાસો

• સર્વર પર માન્યતા. બ્રાઉઝર તપાસો છોડી શકાય છે. ફરજિયાત fields, લંબાઈ, ફોર્મેટ અને માન્ય કિંમતો સર્વર પણ તપાસે.
• Database queries parameters વાપરે, વપરાશકર્તાના input ને query માં જોડીને બનાવેલા લખાણથી નહીં.
• ભૂલો દબાવાતી નથી. કંઈ ન કરતું try/catch નિષ્ફળતાઓ છુપાવે છે. ભૂલો લૉગ થવી જોઈએ, અને વપરાશકર્તાને સાદો સંદેશ દેખાવો જોઈએ.
• વપરાશકર્તાઓને આંતરિક વિગતો બતાવાતી નથી — stack traces અને database ભૂલો logs માં હોવી જોઈએ.

પગલું 6: શું તે ખરેખર અસ્તિત્વમાં છે તે તપાસો

AI મોડેલો ક્યારેક એવો કોડ બનાવે છે જે સાચો લાગે પણ જે વસ્તુઓ અસ્તિત્વમાં નથી તેનો ઉલ્લેખ કરે.

• Packages: દરેક નવી dependency એ એ જ નામનું વાસ્તવિક, જાળવાયેલું package હોવું જોઈએ. લોકપ્રિય packages ના ટાઇપો જેવા લાગતા નામોથી સાવધ રહો.
• Functions અને API વિકલ્પો: જો કોડ કોઈ library function કે બાહ્ય API વિકલ્પને બોલાવે જે તમે ક્યારેય જોયો નથી, તો સત્તાવાર દસ્તાવેજ તપાસો.
• Placeholder કોડ: TODO, mock, fake, કોડમાં લખેલો નમૂના ડેટા, અથવા નિશ્ચિત મૂલ્ય પાછું આપતા functions શોધો.

શું તમે કોઈ નવા packages ઉમેર્યા? દરેક માટે ચોક્કસ નામ, તે શા માટે છે, અને શું આપણે તેના વગર ચલાવી શકીએ તે આપો.

પગલું 7: તે બંધબેસે છે કે નહીં તે તપાસો

કોડ કામ કરી શકે અને છતાં પછીથી એપને બદલવી મુશ્કેલ બનાવે:

• પુનરાવર્તન. એક જ લોજિક ઘણી જગ્યાએ નકલ કરાય તો તે અલગ પડી જશે.
• સુસંગતતા. તે એપના બાકીના ભાગના patterns અનુસરવા જોઈએ.
• કદ. 20 લાઇનની વિનંતીથી 600 લાઇન બની હોય તો પ્રશ્ન પૂછવા જેવો છે.
• ન વપરાતો કોડ. નવી આવૃત્તિઓની બાજુમાં છોડી દેવાયેલી જૂની આવૃત્તિઓ.

શું આ ફેરફારને કારણે પ્રોજેક્ટમાં હવે કોઈ કોડ ન વપરાતો છે, અથવા બીજે ક્યાંક નકલ થયેલું લોજિક છે? કંઈ બદલશો નહીં; ફક્ત યાદી બનાવો.

સામાન્ય ભૂલો

• સુઘડ દેખાય છે એટલે મંજૂરી આપવી. સુઘડ કોડ પણ permission check છોડી શકે.
• પરીક્ષણને બદલે વાંચવું. પહેલા ચકાસો; પછી વાંચો.
• ફક્ત સફળ માર્ગ (happy path) ચકાસવો. ખોટો input, ખોટો વપરાશકર્તા અને લૉગ આઉટ અવસ્થા અજમાવો.
• સંબંધ વગરની ફાઇલ ફેરફારોને અવગણવી. દરેક ફાઇલ કેમ બદલાઈ તે પૂછો.
• સ્વ-review પર સંપૂર્ણ ભરોસો. AI ના review ને પહેલો પાસ ગણો અને પરીક્ષણથી ખાતરી કરો.
• એક અઠવાડિયાના ફેરફારો એકસાથે review કરવા. નાના ફેરફારો જેમ થાય તેમ review કરો.

ચેકલિસ્ટ

• હું જાણું છું કે કઈ ફાઇલો શા માટે બદલાઈ, અને સંબંધ વગરનું કંઈ બદલાયું નથી.
• ફેરફાર desktop અને phone પર, ખોટા input સાથે, લૉગ આઉટ અવસ્થામાં અને બીજા વપરાશકર્તા તરીકે કામ કરે છે.
• દરેક ડેટા route સર્વર પર login અને માલિકી તપાસે છે.
• કોડમાં કે બ્રાઉઝર bundles માં કોઈ રહસ્યો નથી.
• Input સર્વર પર ચકાસાયેલ છે; queries parameters વાપરે છે.
• ભૂલો લૉગ થાય છે, દબાવાતી નથી, અને વપરાશકર્તાઓને વિગતવાર બતાવાતી નથી.
• નવા packages વાસ્તવિક અને જરૂરી છે; બનાવટી functions કે placeholders બાકી નથી.
• ઊંચા જોખમવાળા ફેરફારોની ધ્યાનપૂર્વક વાંચણી થઈ છે અને, જ્યાં જરૂરી હોય, બીજા reviewer એ પણ જોયા છે.

Mythex પર કોડની સમીક્ષા

• Ask mode કોડને સંપાદિત કર્યા વગર તેના પ્રશ્નોના જવાબ આપે છે — "દરેક ફેરફાર સમજાવો" અને "કયા routes માં permission check નથી" જેવા prompts માટે આદર્શ. જુઓ Chat.
• Code view દરેક plan પર ફાઇલ ટ્રી, editor અને terminal બતાવે છે (Free પર ફક્ત વાંચવા માટે, Pro પર સંપાદનયોગ્ય), જેથી તમે જાતે જોઈ શકો કે શું બદલાયું. જુઓ Code editor.
• /test એજન્ટને વપરાશકર્તા તરીકે preview માં ક્લિક કરાવે છે અને તૂટેલા flows ની જાણ કરાવે છે.
• Checkpoints તમને review માં નિષ્ફળ જતો ફેરફાર પાછો લેવા દે છે.

જો તમારા માટે કોઈ developer સમીક્ષા કરી રહ્યો હોય, તો AI-બનેલી એપ પર developer સાથે કેવી રીતે કામ કરવું હસ્તાંતરણ સમજાવે છે; જો સમીક્ષામાં બગ મળે, તો AI-બનેલી એપને કેવી રીતે debug કરવી જુઓ.

પ્રશ્નો