കഴിഞ്ഞ മാസം, ഒരു AI അസിസ്റ്റന്റ് ഒരു പ്രൊഡക്ഷൻ പ്രോജക്റ്റിനായി ഒരു Python സ്ക്രിപ്റ്റ് തയ്യാറാക്കി. ഔട്ട്പുട്ട് തെറ്റുകളില്ലാതെ പ്രവർത്തിച്ചു. ഡാറ്റ കൃത്യമായിരുന്നു. എന്നാൽ ഒരു മാനുവൽ റിവ്യൂവിൽ ഡാറ്റാബേസ് കോളുകളの中に ഒളിഞ്ഞിരിക്കുന്ന ഒരു N+1 query pattern കണ്ടെത്തി. ചെറിയൊരു ഡാറ്റാസെറ്റിന് ഈ കോഡ് നന്നായി പ്രവർത്തിച്ചു. എന്നാൽ ആയിരക്കണക്കിന് റെക്കോർഡുകളിലേക്ക് ഇത് വ്യാപിപ്പിക്കുമ്പോൾ, ആപ്ലിക്കേഷൻ ആദ്യം പാരന്റ് ഒബ്ജക്റ്റുകൾക്കായി ഒരു ക്വറി നടത്തുകയും, തുടർന്ന് ബന്ധപ്പെട്ട ഡാറ്റയ്ക്കായി ആയിരക്കണക്കിന് ഫോളോ-അപ്പ് ക്വറികൾ നടത്തുകയും ചെയ്യും. ഇതിന്റെ ഫലമായി ഉണ്ടാകുന്ന പെർഫോമൻസ് തകർച്ച ഒരു യൂണിറ്റ് ടെസ്റ്റിനും കണ്ടെത്താൻ കഴിയില്ല.
ആധുനിക സോഫ്റ്റ്വെയർ ഡെവലപ്മെന്റിന്റെ യാഥാർത്ഥ്യം ഇതാണ്. കോഡിംഗ്, ഡിബഗ്ഗിംഗ്, ആർക്കിടെക്ചറൽ നിർദ്ദേശങ്ങൾ എന്നിവ മനുഷ്യർക്ക് എത്തിപ്പിടിക്കാൻ കഴിയാത്ത വേഗതയിൽ ഇപ്പോൾ AI ടൂളുകൾ കൈകാര്യം ചെയ്യുന്നു. ആ വേഗത യഥാർത്ഥമാണ്. എന്നിരുന്നാലും, അത് നിങ്ങളുടെ ജോലിയുടെ സ്വഭാവത്തെ അടിസ്ഥാനപരമായി മാറ്റുന്നു. സിന്റാക്സ് ടൈപ്പ് ചെയ്യാനല്ല നിങ്ങൾക്ക് പ്രധാനമായും ശമ്പളം ലഭിക്കുന്നത്. ഓഡിറ്റ് ചെയ്യാനും, ആർക്കിടെക്റ്റ് ചെയ്യാനും, ഇത്തരത്തിലുള്ള അദൃശ്യമായ കെണികൾ കണ്ടെത്താനുമാണ് നിങ്ങൾക്ക് പ്രതിഫലം ലഭിക്കുന്നത്.
"യുക്തിസഹമാണെങ്കിലും തെറ്റായ" അവസ്ഥയിലെ നിശബ്ദമായ അപകടം
AI നിർമ്മിക്കുന്ന കോഡുകൾ പലപ്പോഴും ശരിയാണെന്ന് തോന്നും, കാരണം അവ കംപൈൽ ചെയ്യുകയും പ്രവർത്തിക്കുകയും പ്രതീക്ഷിച്ച മൂല്യം നൽകുകയും ചെയ്യുന്നു. ഉപരിതലത്തിൽ ലോജിക് കൃത്യമായി തോന്നും. എന്നാൽ ഉള്ളിൽ അത് തകരാറിലാകാം.
റെഗുലർ എക്സ്പ്രഷനുകൾ (Regular expressions) എടുക്കുക. ഇംഗ്ലീഷിൽ ഇമെയിൽ വിലാസങ്ങളോ ഐഡന്റിഫയറുകളോ കൃത്യമായി മാച്ച് ചെയ്യുന്ന ഒരു പാറ്റേൺ AI നിങ്ങൾക്ക് നൽകിയേക്കാം. എന്നാൽ അതേ എക്സ്പ്രഷൻ ജർമ്മൻ ഉംലൗട്ടുകൾക്കോ (umlauts), അറബിക് ലിപികൾക്കോ, അല്ലെങ്കിൽ യൂണിക്കോഡ് നോർമലൈസേഷൻ എഡ്ജ് കേസുകൾക്കോ (Unicode normalization edge cases) ഉപയോഗിക്കുമ്പോൾ അത് നിശബ്ദമായി പരാജയപ്പെടുന്നു. കോഡ് ഒരു എക്സെപ്ഷൻ (exception) എറിയുന്ന രീതിയിൽ തെറ്റല്ല. അത് യഥാർത്ഥ ലോകത്തിലെ സാധുവായ ഡാറ്റയെ ഒഴിവാക്കുക മാത്രമാണ് ചെയ്യുന്നത്.
ഡാറ്റാബേസ് ക്വറികൾക്കും സമാനമായ റിസ്ക് ഉണ്ട്. ടെസ്റ്റിംഗ് സമയത്ത് ശരിയായ വരികൾ നൽകുന്ന ഒരു PostgreSQL ക്വറി എഴുതാൻ AI-ക്ക് കഴിയും, എന്നാൽ അത് നിങ്ങളുടെ ടേബിളുകളിൽ ഡെഡ് ട്യൂപ്പിൾസ് (dead tuples) നിറയ്ക്കാനോ, ഇൻഡക്സ് ഉപയോഗിക്കുന്നത് ഒഴിവാക്കാനോ, അല്ലെങ്കിൽ പ്രൊഡക്ഷൻ വർക്ക്ലോഡുകളെ തളർത്തുന്ന സീക്വൻഷ്യൽ സ്കാനുകൾക്ക് (sequential scans) കാരണമാകാനോ ഇടയാക്കിയേക്കാം. ഒരു ഡെമോ ഡാറ്റാസെറ്റിൽ പ്രവർത്തിക്കുന്നതും യഥാർത്ഥ ലോഡിൽ പ്രവർത്തിക്കുന്നതും രണ്ട് വ്യത്യസ്ത കാര്യങ്ങളാണ്. മെഷീന് ലേറ്റൻസി (latency) അനുഭവപ്പെടില്ല. അത് ക്ലൗഡ് ബില്ലുകൾ അടയ്ക്കില്ല.
എഴുത്തിൽ നിന്ന് പരിശോധനയിലേക്ക്
"ഇത് എങ്ങനെ എഴുതാം?" എന്നതിൽ നിന്ന് "ഇത് എങ്ങനെ പരിശോധിക്കാം?" എന്നതിലേക്കുള്ള മാറ്റമാണ് പ്രധാനപ്പെട്ടത്. AI ആദ്യ ഡ്രാഫ്റ്റ് തയ്യാറാക്കുമ്പോൾ, നിങ്ങളുടെ ശ്രദ്ധ പരിശോധനയിലേക്ക് മാറണം. ഒരു ക്ഷീണിതനായ എഴുത്തുകാരൻ തന്റെ സ്വന്തം ജോലി വേഗത്തിൽ വായിച്ചുപോകുന്നതുപോലെയല്ല, മറിച്ച് ഒരു സെക്യൂരിറ്റി ഓഡിറ്റർ കോഡ് പരിശോധിക്കുന്നത് പോലെ നിങ്ങൾ കോഡ് വായിക്കേണ്ടതുണ്ട്.
ഇതിന് വ്യത്യസ്തമായ ഒരു അച്ചടക്കം ആവശ്യമാണ്. ഓട്ടോമേഷൻ ബയാസ് (Automation bias) എന്നത് ഒരു യാഥാർത്ഥ്യമാണ്. ഒരു ടൂൾ ഒഴുക്കുള്ളതും സിന്റാക്സൽ ആയി കൃത്യവുമായ ഔട്ട്പുട്ട് നൽകുമ്പോൾ, മനുഷ്യ മസ്തിഷ്കം അയവിറുക്കുന്നു. അവതരണം മികച്ചതായതുകൊണ്ട് അത് ശരിയാണെന്ന് നിങ്ങൾ അനുമാനിക്കുന്നു. ആ പ്രേരണയെ പ്രതിരോധിക്കുക എന്നതാണ് ഇപ്പോൾ പ്രധാനമായ കഴിവ്. തെളിവ് ലഭിക്കുന്നത് വരെ ഓരോ നിർദ്ദേശവും ഒരു ഹൈപ്പോത്തിസിസ് (hypothesis) മാത്രമാണെന്ന് നിങ്ങൾ കരുതണം.
മെഷീനുമായി ചേർന്ന് പ്രവർത്തിക്കുമ്പോൾ
ഒരു AI കോഡിംഗ് അസിസ്റ്റന്റിൽ നിന്ന് ഉപയോഗപ്രദമായ ഔട്ട്പുട്ട് നേടുക എന്നത് വേഗത്തിൽ ടൈപ്പ് ചെയ്യുന്നതിനെക്കുറിച്ചല്ല. അത് മെഷീന്റെ ട്രെയിനിംഗ് ഡാറ്റയും നിങ്ങളുടെ പ്രത്യേക യാഥാർത്ഥ്യവും തമ്മിലുള്ള അകലം കുറയ്ക്കുന്നതിനെക്കുറിച്ചാണ്. ചില പ്രായോഗിക രീതികളിലൂടെ നിങ്ങൾക്ക് ആ അകലം കുറയ്ക്കാം.
നിങ്ങളുടെ പ്രോംപ്റ്റുകളിൽ കൃത്യത പാലിക്കുക. ഇവിടെ അവ്യക്തത കവിതകളല്ല, മറിച്ച് ബഗുകൾ (bugs) ആണ് സൃഷ്ടിക്കുന്നത്. "optimize this function" എന്ന പ്രോംപ്റ്റ് പൊതുവായ നിർദ്ദേശങ്ങൾ മാത്രമേ നൽകൂ. അതിനുപകരം, "iterated saves-ന് പകരം ഒരു സിംഗിൾ ബൾക്ക് ഡാറ്റാബേസ് അപ്ഡേറ്റ് ഉപയോഗിക്കുന്ന രീതിയിൽ ഈ Python ലൂപ്പ് റീഫാക്ടർ ചെയ്യുക" എന്ന് എഴുതുക. കൃത്യത നൽകുന്നത് സാധ്യതകളുടെ പരിധി കുറയ്ക്കുന്നു.
യഥാർത്ഥ കോൺടെക്സ്റ്റ് നൽകുക. നിങ്ങൾ ഒരു Kubernetes ക്ലസ്റ്ററിനുള്ളിൽ PostgreSQL 15 ഉപയോഗിച്ച് Django 4.2 ആണ് പ്രവർത്തിപ്പിക്കുന്നത് എന്നും, അതിന് കർശനമായ 30 സെക്കൻഡ് റിക്വസ്റ്റ് ടൈമൗട്ട് ഉണ്ടെന്നും നിങ്ങൾ പറയുന്നില്ലെങ്കിൽ AI അത് അറിയാൻ പോകുന്നില്ല. നിങ്ങളുടെ ഡിപെൻഡൻസി വേർഷനുകൾ (dependency versions), നിങ്ങളുടെ ഇന്റേണൽ ലൈബ്രറികൾ, നിങ്ങളുടെ മാറ്റാൻ കഴിയാത്ത നിയന്ത്രണങ്ങൾ എന്നിവ നൽകുക. കോൺടെക്സ്റ്റ് എന്നത് വെറുമൊരു അലങ്കാരമല്ല; അത് സുരക്ഷാ വേലികളാണ് (guardrails).
നിങ്ങളുടെ സ്വന്തം ഡോക്യുമെന്റുകൾ ഉപയോഗിച്ച് ഉത്തരങ്ങൾ ഉറപ്പിക്കുക. Retrieval-Augmented Generation, അല്ലെങ്കിൽ RAG എന്നത് ചാറ്റ്ബോട്ടുകൾക്കായുള്ള വെറുമൊരു വാക്കല്ല. നിങ്ങളുടെ യഥാർത്ഥ API സ്പെസിഫിക്കേഷനുകൾ, നിങ്ങളുടെ ആർക്കിടെക്ചർ ഡിസിഷൻ റെക്കോർഡുകൾ, നിങ്ങളുടെ കോഡ്ബേസ് കൺവെൻഷനുകൾ എന്നിവയിലേക്ക് നിങ്ങളുടെ അസിസ്റ്റന്റിനെ നയിക്കുക. മോഡൽ ട്രെയിനിംഗ് ഡാറ്റയിൽ നിന്ന് ഊഹിക്കുന്നതിന് പകരം നിങ്ങളുടെ ഡോക്യുമെന്റേഷനിൽ നിന്ന് വസ്തുതകൾ കണ്ടെത്തുമ്പോൾ, പൊതുവായ നിർദ്ദേശങ്ങളും ഉപയോഗപ്രദമായ കോഡും തമ്മിലുള്ള വ്യത്യാസം ഗണ്യമായി കുറയുന്നു.
സങ്കീർണ്ണമായ ജോലികളെ ചെറിയ ടാസ്ക്കുകളായി തിരിക്കുക. ഓരോ ഘട്ടത്തിനും കൃത്യമായ വ്യാപ്തി (scope) ഉള്ളപ്പോഴാണ് ഏജന്റ് പാറ്റേണുകൾ (Agent patterns) ഏറ്റവും നന്നായി പ്രവർത്തിക്കുന്നത്. ഒറ്റയടിക്ക് ഒരു പൂർണ്ണമായ മൈക്രോസർവീസ് റീഫാക്ടർ ആവശ്യപ്പെടരുത്. ആദ്യം ഡാറ്റാ സ്കീമ ആവശ്യപ്പെടുക. അത് പരിശോധിക്കുക. തുടർന്ന് മൈഗ്രേഷൻ സ്ക്രിപ്റ്റ് ആവശ്യപ്പെടുക. അത് പരിശോധിക്കുക. അതിനുശേഷം സർവീസ് ലെയറിലേക്ക് നീങ്ങുക.