കോഡിംഗ് ഏജന്റുകൾക്ക് Swift നന്നായി എഴുതാൻ കഴിയും, പക്ഷേ അവയ്ക്ക് അത് പൂർത്തിയാക്കാൻ കഴിയില്ല

യഥാർത്ഥ Swift, Xcode ടാസ്ക്കുകളിൽ AI കോഡിംഗ് ഏജന്റുകളെ പരീക്ഷിച്ചുകൊണ്ട് ഞാൻ മാസങ്ങൾ ചെലവഴിച്ചു. ഞാൻ വെറും ഡെമോകൾ മാത്രമല്ല ഉപയോഗിച്ചത്. ബിൽഡ് ടാർഗറ്റുകളും ടെസ്റ്റുകളും ഉൾപ്പടെയുള്ള യഥാർത്ഥ ടാസ്ക്കുകളാണ് ഞാൻ അവയ്ക്ക് നൽകിയത്.

ആദ്യത്തെ ഡ്രാഫ്റ്റ് സാധാരണയായി ശരിയായിരിക്കും. കഴിവുള്ള ഒരു മോഡൽ ശരിയാണെന്ന് തോന്നുന്ന കോഡ് എഴുതുന്നു. ടൈപ്പുകൾ കൃത്യമായി വരുന്നു. വ്യൂകൾ (views) യുക്തിസഹമാണ്. Swift എഴുതുക എന്നത് മാത്രമായിരുന്നു പ്രശ്നമെങ്കിൽ, ഈ ടൂളുകൾ പൂർണ്ണതയിലെത്തുമായിരുന്നു.

യഥാർത്ഥ പ്രശ്നം ആദ്യത്തെ ഡ്രാഫ്റ്റിന് ശേഷമാണ് സംഭവിക്കുന്നത്. പൂർത്തിയായതായി തോന്നുന്ന കോഡും യഥാർത്ഥത്തിൽ ശരിയായ കോഡും തമ്മിലുള്ള വ്യത്യാസമാണത്.

Claude Code അല്ലെങ്കിൽ Codex പോലുള്ള ആധുനിക ടൂളുകൾ കംപൈൽ എററുകൾ (compile errors) നന്നായി കൈകാര്യം ചെയ്യുന്നു. ബിൽഡ് ചെയ്യാൻ കഴിയാത്ത കോഡ് അവ നിങ്ങൾക്കായി നൽകില്ല. എന്നാൽ കംപൈലറിന് കാണാൻ കഴിയാത്ത പിഴവുകളാണ് യഥാർത്ഥ പരാജയങ്ങൾ.

ഈ പരാജയങ്ങൾ എന്റെ സമയം പാഴാക്കുന്നു:

• ഉദ്ദേശ്യത്തിലെ പൊരുത്തക്കേട് (Intent mismatch): കോഡ് കംപൈൽ ചെയ്യുകയും ടെസ്റ്റുകൾ പാസ്സാകുകയും ചെയ്യുന്നു. എന്നിരുന്നാലും, അതിന്റെ പ്രവർത്തനം തെറ്റായിരിക്കും. ഏജന്റ് നിങ്ങളുടെ യഥാർത്ഥ ലക്ഷ്യത്തിന് പകരം പാസ്സാകുന്ന ടെസ്റ്റിന്റെ 'ഗ്രീൻ ലൈറ്റ്' പിന്തുടരുന്നു. ഉദ്ദേശ്യം പരിശോധിക്കാൻ അതിന് മാർഗമില്ല.

• കൺകറൻസി റേസുകൾ (Concurrency races): കോഡ് ക്ലീൻ ആയി ബിൽഡ് ആകുമെങ്കിലും ഡാറ്റാ റേസുകൾ (data races) ഉണ്ടാകാം. ഇവ റൺടൈമിൽ (runtime) മാത്രമേ പ്രത്യക്ഷപ്പെടുകയുള്ളൂ. ഏജന്റ് ഒരു ഗ്രീൻ ബിൽഡ് കാണുകയും അടുത്തതിലേക്ക് നീങ്ങുകയും ചെയ്യുന്നു. ഇവ പരിഹരിക്കാൻ സാധാരണയായി ഒരു റീഡിസൈൻ ആവശ്യമാണ്, അത് ചെയ്യാൻ ഏജന്റിന് സാധിക്കില്ല.

• റിഗ്രഷൻ ലൂപ്പുകൾ (Regression loops): ഏജന്റ് ഒരു ബഗ് പരിഹരിക്കുമ്പോൾ മറ്റൊന്ന് ഉണ്ടാക്കുന്നു. രണ്ടാമത്തെ ബഗ് പരിഹരിക്കുമ്പോൾ, അത് ആദ്യത്തെ പരിഹാരം ഇല്ലാതാക്കുന്നു. രണ്ട് തകരാറുള്ള അവസ്ഥകൾക്കിടയിൽ ആവർത്തിച്ചു വരുന്ന ഒരു ലൂപ്പിലേക്ക് അത് പ്രവേശിക്കുന്നു. മുമ്പ് എന്താണ് പരാജയപ്പെട്ടത് എന്നതിനെക്കുറിച്ച് അതിന് ഓർമ്മയില്ല.

• മോശം ആർക്കിടെക്ചർ (Poor architecture): ഫ്രെയിംവർക്കിന് വിരുദ്ധമായ കോഡ് ഏജന്റ് എഴുതുന്നു. അത് നിങ്ങളുടെ ആപ്പ് സ്ട്രക്ചർ അവഗണിക്കുന്നു. ഒരു താൽക്കാലിക സ്ക്രിപ്റ്റിന് ഇത് പ്രവർത്തിച്ചേക്കാം, എന്നാൽ ഒരു യഥാർത്ഥ കോഡ്ബേസിൽ ഇത് പരാജയപ്പെടുന്നു.

ഇവ ഭാഷയുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങളല്ല. മോഡലിന് Swift അറിയാം. കംപൈലറിന് കാണാൻ കഴിയാത്ത കാര്യങ്ങൾ അത് ശ്രദ്ധിക്കാതെ പോകുന്നു. ഫലം നിങ്ങളുടെ ഉദ്ദേശ്യത്തിന് അനുസരിച്ചാണോ എന്നോ അല്ലെങ്കിൽ സ്ട്രക്ചർ പ്രൊഫഷണൽ ആണോ എന്നോ അതിന് അറിയില്ല.

ഇത് ചിലവ് ടോക്കണുകളിൽ നിന്ന് ശ്രദ്ധയിലേക്ക് (attention) മാറ്റുന്നു. ഓരോ കുറച്ചു ഘട്ടങ്ങളിലും നിങ്ങൾ ശ്രദ്ധിക്കേണ്ടി വരുന്ന ഒരു ഏജന്റ് നിങ്ങളുടെ ജോലി ലാഭിക്കുന്നില്ല. അത് എഴുതുന്നതിനെ മേൽനോട്ടം വഹിക്കുന്നതിലേക്ക് (supervising) മാറ്റിയിരിക്കുന്നു.

മോഡലിന് ചുറ്റുമുള്ള ലൂപ്പ് മാറ്റിക്കൊണ്ട് ഞാൻ എന്റെ ഫലങ്ങൾ മെച്ചപ്പെടുത്തുന്നു. ഏജന്റ് എന്താണ് പരിശോധിക്കുന്നതെന്നും ഓർമ്മിച്ചുവെക്കുന്നതെന്നും ഞാൻ ശ്രദ്ധിക്കുന്നു.

ഇത് നിങ്ങളുടെ അനുഭവവുമായി യോജിക്കുന്നുണ്ടോ? ആപ്പിൾ പ്ലാറ്റ്‌ഫോമുകളിൽ നിങ്ങൾ ഏജന്റുകൾ പ്രവർത്തിപ്പിക്കുമ്പോൾ, എവിടെയാണ് പിഴവ് സംഭവിക്കുന്നത്? ഉദ്ദേശ്യത്തിലെ പൊരുത്തക്കേടുകളാണോ, റൺടൈം റേസുകളാണോ, അതോ മറ്റെന്തെങ്കിലും ആണോ?

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

Optional learning community: https://t.me/GyaanSetuAi