𝗖𝗼𝗱𝗶𝗻𝗴 𝗔𝗴𝗲𝗻𝘁𝘀 𝗪𝗿𝗶𝘁𝗲 𝗦𝘄𝗶𝗳𝘁 𝗪𝗲𝗹𝗹, 𝗕𝘂𝘁 𝗧𝗵𝗲𝘆 𝗖𝗮𝗻'𝘁 𝗙𝗶𝗻𝗶𝘀𝗵 𝗜𝘁

મેં વાસ્તવિક Swift અને Xcode કાર્યો પર AI કોડિંગ એજન્ટ્સનું પરીક્ષણ કરવામાં મહિનાઓ વિતાવ્યા છે. મેં માત્ર સાદા ડેમોનો ઉપયોગ કર્યો નથી. મેં તેમને બિલ્ડ ટાર્ગેટ્સ અને ટેસ્ટ સાથેના વાસ્તવિક કાર્યો આપ્યા હતા.

પ્રથમ ડ્રાફ્ટ સામાન્ય રીતે બરાબર હોય છે. એક સક્ષમ મોડેલ એવો કોડ લખે છે જે સાચો લાગે છે. ટાઇપ્સ (types) યોગ્ય રીતે ગોઠવાયેલા હોય છે. વ્યુઝ (views) તર્કસંગત હોય છે. જો Swift લખવું એ જ એકમાત્ર સમસ્યા હોત, તો આ સાધનો સંપૂર્ણ રીતે તૈયાર હોત.

વાસ્તવિક સમસ્યા પ્રથમ ડ્રાફ્ટ પછી ઊભી થાય છે. તે એવો કોડ જે પૂર્ણ લાગે છે અને એવો કોડ જે ખરેખર સાચો છે, તે વચ્ચેનો તફાવત છે.

Claude Code અથવા Codex જેવા આધુનિક સાધનો કમ્પાઈલ એરર્સ (compile errors) ને સારી રીતે હેન્ડલ કરે છે. તેઓ તમને એવો કોડ આપતા નથી જે બિલ્ડ કરવામાં નિષ્ફળ જાય. વાસ્તવિક નિષ્ફળતાઓ એ છે જે કમ્પાઈલર જોઈ શકતું નથી.

આ નિષ્ફળતાઓ મારો સમય બગાડે છે:

• ઇન્ટેન્ટ મિસમેચ (Intent mismatch): કોડ કમ્પાઈલ થાય છે અને ટેસ્ટ પાસ થાય છે. જોકે, વર્તણૂક ખોટી હોય છે. એજન્ટ તમારા વાસ્તવિક લક્ષ્યને બદલે પાસ થયેલા ટેસ્ટના 'ગ્રીન લાઈટ'ને અનુસરે છે. તેની પાસે ઇન્ટેન્ટ (હેતુ) તપાસવાની કોઈ રીત નથી.

• કન્કરન્સી રેસીસ (Concurrency races): કોડ ક્લીનલી બિલ્ડ થાય છે પરંતુ તેમાં ડેટા રેસીસ (data races) હોય છે. આ માત્ર રનટાઇમ (runtime) દરમિયાન જ દેખાય છે. એજન્ટ ગ્રીન બિલ્ડ જુએ છે અને આગળ વધી જાય છે. આને સુધારવા માટે સામાન્ય રીતે રીડિઝાઇનિંગની જરૂર પડે છે, જે કરવામાં એજન્ટ નિષ્ફળ જાય છે.

• રિગ્રેસન લૂપ્સ (Regression loops): એજન્ટ એક બગ (bug) સુધારે છે પરંતુ બીજો બગાડી નાખે છે. બીજા બગને સુધારતી વખતે, તે પ્રથમ સુધારો રદ કરી નાખે છે. તે એવા લૂપમાં પ્રવેશે છે જ્યાં તે બે ખરાબ સ્થિતિઓ વચ્ચે ઝૂલતું રહે છે. તેની પાસે અગાઉ શું નિષ્ફળ ગયું હતું તેની યાદશક્તિ હોતી નથી.

• નબળી આર્કિટેક્ચર (Poor architecture): એજન્ટ એવો કોડ લખે છે જે ફ્રેમવર્ક સાથે લડે છે. તે તમારા એપ સ્ટ્રક્ચરને અવગણે છે. તે કામચલાઉ સ્ક્રિપ્ટ માટે કામ કરે છે પરંતુ વાસ્તવિક કોડબેઝમાં નિષ્ફળ જાય છે.

આ ભાષાની સમસ્યાઓ નથી. મોડેલ Swift જાણે છે. તે એ બાબત ચૂકી જાય છે જે કમ્પાઈલર જોઈ શકતું નથી. પરિણામ તમારા ઇન્ટેન્ટ સાથે મેળ ખાય છે કે નહીં અથવા સ્ટ્રક્ચર પ્રોફેશનલ છે કે નહીં તે તેને ખબર હોતી નથી.

આ ખર્ચને ટોકન્સ (tokens) થી બદલીને ધ્યાન (attention) પર લઈ જાય છે. એવો એજન્ટ જેને તમારે દર થોડા સ્ટેપ્સ પછી જોવો પડે છે, તેણે તમારું કામ બચાવ્યું નથી. તેણે લખવાના કામને સુપરવાઇઝિંગ (નિરીક્ષણ) માં બદલી નાખ્યું છે.

હું મોડેલની આસપાસના લૂપમાં ફેરફાર કરીને મારા પરિણામો સુધારી રહ્યો છું. હું એ બાબત પર ધ્યાન કેન્દ્રિત કરું છું કે એજન્ટ શું તપાસે છે અને શું યાદ રાખે છે.

શું આ તમારા અનુભવ સાથે મેળ ખાય છે? જ્યારે તમે Apple પ્લેટફોર્મ પર એજન્ટ્સ ચલાવો છો, ત્યારે તે ક્યાં નિષ્ફળ જાય છે? શું તે ઇન્ટેન્ટ મિસમેચ છે, રનટાઇમ રેસીસ છે, કે બીજું કંઈક?

Source: https://dev.to/jbrackin/coding-agents-are-good-at-writing-swift-theyre-bad-at-finishing-it-md3

વૈકલ્પિક લર્નિંગ કોમ્યુનિટી: https://t.me/GyaanSetuAi