AI കോഡിന്റെ 80/20 നിയമം

എന്റെ ഫീച്ചറിന്റെ 80 ശതമാനവും AI വെറും 10 മിനിറ്റിനുള്ളിൽ എഴുതിത്തന്നു. കോഡ് വളരെ വൃത്തിയുള്ളതായിരുന്നു. ലോജിക് കൃത്യമായിരുന്നു. ആദ്യ ശ്രമത്തിൽ തന്നെ അത് പ്രവർത്തിച്ചു. എനിക്ക് വലിയ സന്തോഷം തോന്നി.

എന്നാൽ ആദ്യത്തെ 80 ശതമാനത്തിന് AI ഉപകാരപ്രദമാണ്, പക്ഷേ അവസാനത്തെ 20 ശതമാനത്തിന് അത് ഒന്നിനും കൊള്ളില്ല.

AI 'happy path'-ന് മുൻഗണന നൽകുന്നു. എല്ലാം ശരിയായി നടക്കുന്ന ഒരു ലോകത്തിന് വേണ്ടിയാണ് അത് നിർമ്മിക്കുന്നത്. എന്നാൽ കാര്യങ്ങൾ തെറ്റായി സംഭവിക്കുന്ന ഒരു ലോകത്താണ് യഥാർത്ഥ സോഫ്റ്റ്‌വെയറുകൾ പ്രവർത്തിക്കുന്നത്.

അടുത്തിടെ ഞാൻ ഒരു Sol Email Worker നിർമ്മിച്ചു. അതിന്റെ core logic, threading, routing എന്നിവ AI വെറും 20 മിനിറ്റിനുള്ളിൽ തയ്യാറാക്കി. അതായിരുന്നു എളുപ്പമുള്ള ഭാഗം.

അവസാനത്തെ 20 ശതമാനത്തിന് എന്റെ യഥാർത്ഥ വൈദഗ്ധ്യം ആവശ്യമായിരുന്നു:

• Deduplication: ഡ്യൂപ്ലിക്കേറ്റ് മെസ്സേജുകൾ കൈകാര്യം ചെയ്യുക. • Sender-skip logic: സ്വന്തം മെസ്സേജുകൾ പ്രോസസ്സ് ചെയ്യുന്നത് ഒഴിവാക്കുക. • Error recovery: അപ്രതീക്ഷിതമായ API റെസ്‌പോൺസുകൾ കൈകാര്യം ചെയ്യുക. • Log output: പുലർച്ചെ 2 മണിയിലും ഡീബഗ്ഗിംഗ് സാധ്യമാക്കുക.

ഞാൻ ആവശ്യപ്പെട്ടത് AI ചെയ്തു. എന്നാൽ edge cases കുറിച്ച് ഞാൻ ചിന്തിച്ചിരുന്നില്ല, അതുകൊണ്ട് അവ ആവശ്യപ്പെടാൻ എനിക്ക് കഴിഞ്ഞില്ല.

നമുക്കൊരു അളവുകോൽ പ്രശ്നമുണ്ട്. നമ്മൾ കോഡിന്റെ വരികളും ക്ലോസ് ചെയ്ത ടിക്കറ്റുകളും ആണ് കണക്കാക്കുന്നത്. ഈ അളവുകോലുകൾ വേഗത്തിൽ തീരുന്ന 80 ശതമാനത്തെയാണ് പ്രോത്സാഹിപ്പിക്കുന്നത്. എറർ ഹാൻഡ്‌ലിംഗിനോ (error handling) നൾ ചെക്കുകൾക്കോ (null checks) വേണ്ടി ചെലവഴിക്കുന്ന സമയം ആരും കണക്കിലെടുക്കുന്നില്ല.

ഡാഷ്‌ബോർഡുകളിൽ ആ 20 ശതമാനത്തെ കാണാൻ കഴിയില്ല, എന്നാൽ യഥാർത്ഥ ജോലി നടക്കുന്നത് അവിടെയാണ്. ഇപ്പോൾ ഞാൻ prompt-to-ship time ആണ് കണക്കാക്കുന്നത്. അതായത് ആദ്യത്തെ പ്രോംപ്റ്റിൽ നിന്ന് ഒരു സ്റ്റേബിൾ പ്രൊഡക്ഷൻ ഫീച്ചർ തയ്യാറാകുന്നത് വരെയുള്ള സമയം. ഈ സമയം എപ്പോഴും AI കോഡ് തയ്യാറാക്കുന്ന സമയത്തേക്കാൾ കുറഞ്ഞത് 4 മടങ്ങ് കൂടുതലായിരിക്കും.

ഇപ്പോൾ ഞാൻ ജോലി ചെയ്യുന്നത് ഇങ്ങനെയാണ്:

  • ഓരോ ടാസ്കിനും AI എടുക്കുന്ന സമയത്തിന്റെ 4 മടങ്ങ് ഞാൻ കണക്കാക്കുന്നു.
  • ഞാൻ 'unhappy path'-നായി പ്രോംപ്റ്റുകൾ നൽകുന്നു. നെറ്റ്‌വർക്ക് പരാജയപ്പെടുകയോ അല്ലെങ്കിൽ API 'null' നൽകുകയോ ചെയ്യുമെന്ന് ഞാൻ AI-യോട് പറയുന്നു.
  • ആദ്യത്തെ ഡ്രാഫ്റ്റിനെ ഒരു തുടക്കമായിട്ടാണ് ഞാൻ കാണുന്നത്, അല്ലാതെ ഒരു അവസാനമായിട്ടല്ല.

30 സെക്കൻഡ് കൊണ്ട് AI കോഡ് തയ്യാറാക്കിയ ശേഷം എറർ ഹാൻഡ്‌ലിംഗിനായി ഞാൻ ചെലവഴിച്ച 3 മണിക്കൂർ വെറുതെയായതല്ല. അതാണ് യഥാർത്ഥ ജോലി. കോഡിന്റെ ഘടന എഴുതുന്നതിൽ നിന്ന് കോഡിനെ യഥാർത്ഥമായി മാറ്റുന്നതിലേക്ക് AI ജോലിയെ മാറ്റിയിരിക്കുന്നു.

കോഡിനെ യഥാർത്ഥമായി മാറ്റുന്നത് സാവധാനത്തിലുള്ള പ്രക്രിയയാണ്. അതിന് നിങ്ങളുടെ പ്രത്യേക സാഹചര്യങ്ങളും, ഉപയോക്താക്കളും, കോഡ്ബേസ് ചരിത്രവും ആവശ്യമാണ്. അതാണ് വൈദഗ്ധ്യം കൊണ്ട് അർത്ഥമാക്കുന്നത്.

പരിചിതമായ മേഖലകളിൽ AI പ്രവർത്തിക്കുന്നു. എന്നാൽ edge cases എപ്പോഴും അപരിചിതമായ മേഖലകളാണ്.

അടുത്ത തവണ ഒരു AI ഡെമോ നിങ്ങളെ അത്ഭുതപ്പെടുത്തിയാൽ, ഡെമോ കഴിഞ്ഞതിന് ശേഷം എന്താണ് സംഭവിച്ചത് എന്ന് ചോദിച്ചു നോക്കൂ.

സ്രോതസ്സ്: https://dev.to/amrree/the-8020-rule-of-ai-code-id

ഓപ്ഷണൽ ലേണിംഗ് കമ്മ്യൂണിറ്റി: https://t.me/GyaanSetuAi