𝗟𝗼𝗰𝗮𝗹 𝗖𝗼𝗱𝗶𝗻𝗴 𝗔𝗴𝗲𝗻𝘁𝘀 𝗔𝗿𝗲 𝗔𝗻 𝗘𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁 𝗣𝗿𝗼𝗯𝗹𝗲𝗺

കോഡിംഗ് ഏജന്റ് സജ്ജീകരണത്തിന്റെ (setup) കേന്ദ്രബിന്ദു ഇനി പ്രോംപ്റ്റുകൾ മാത്രമല്ല.

മിക്ക ഡെമോകളും പ്രോംപ്റ്റുകളെയാണ് ഉൽപ്പന്നത്തിന്റെ മുഴുവൻ മുഖമായി കാണിക്കുന്നത്. നിങ്ങൾ ഒരു ഫീച്ചറിനായി ആവശ്യപ്പെടുന്നു. ഏജന്റ് ഫയലുകൾ വായിക്കുന്നു. അത് കോഡ് എഡിറ്റ് ചെയ്യുന്നു. ടെസ്റ്റുകൾ റൺ ചെയ്യുന്നു. ഒരു വീഡിയോയിൽ ഇത് കാണാൻ വളരെ ലളിതമായി തോന്നും.

യഥാർത്ഥ ലോക്കൽ ഏജന്റുകൾ അല്പം സങ്കീർണ്ണമാണ്. ഒരു ഏജന്റ് നിങ്ങളുടെ റെപ്പോസിറ്ററിന് (repo) അടുത്തിരുന്ന് കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുകയും ടൂളുകൾ ഉപയോഗിക്കുകയും ചെയ്യുമ്പോൾ, പ്രധാന ചോദ്യം മാറുന്നു.

അത് "ഞാൻ ഒരു മികച്ച പ്രോംപ്റ്റ് എഴുതിയോ?" എന്നതല്ല. മറിച്ച് "ഞാൻ ഇതിന് എങ്ങനെയുള്ള ഒരു എൻവയോൺമെന്റ് നൽകി?" എന്നതാണ്.

ഒരു ചാറ്റ് അസിസ്റ്റന്റിന് വ്യക്തമായ അതിർവരമ്പുകളുണ്ട്. നിങ്ങൾ കോൺടെക്സ്റ്റ് നൽകുന്നു, തിരിച്ച് ടെക്സ്റ്റ് ലഭിക്കുന്നു. എന്നാൽ ഒരു ലോക്കൽ കോഡിംഗ് ഏജന്റ് വ്യത്യസ്തമാണ്. അത് നിങ്ങളുടെ ഷെൽ (shell), ലോക്കൽ ടൂളുകൾ, പാക്കേജ് മാനേജർമാർ, ക്രെഡൻഷ്യലുകൾ എന്നിവയിൽ ഇടപെടുന്നു. ഇവിടെ എൻവയോൺമെന്റ് ആണ് യഥാർത്ഥ ഉൽപ്പന്നം.

ഒരു ലോക്കൽ ഏജന്റ് സജ്ജീകരിക്കുന്നത് ഡെവലപ്പർ ഇൻഫ്രാസ്ട്രക്ചറാണ് (developer infrastructure). ഇത് വെറുമൊരു AI ടൂൾ ഇൻസ്റ്റാൾ ചെയ്യൽ മാത്രമല്ല.

നിങ്ങൾ തീരുമാനിക്കേണ്ടതുണ്ട്:

  • ഏജന്റിന് എന്തൊക്കെ വായിക്കാൻ കഴിയും?
  • അതിന് എന്തൊക്കെ എഡിറ്റ് ചെയ്യാൻ കഴിയും?
  • ഏതെല്ലാം കമാൻഡുകൾ അതിന് റൺ ചെയ്യാൻ കഴിയും?
  • ഡിഫോൾട്ട് ആയി ഏതെല്ലാം ടൂളുകൾ ലഭ്യമാണ്?
  • സ്റ്റേറ്റ് (state) എവിടെയാണ് നിലനിൽക്കുന്നത്?
  • മറ്റൊരു ഡെവലപ്പർക്ക് ഈ സെറ്റപ്പ് പുനരാവിഷ്കരിക്കാൻ കഴിയുമോ?
  • ഏജന്റ് എന്തൊക്കെ തെളിവുകൾ ബാക്കിവെക്കുന്നു?

ഈ ഉത്തരങ്ങൾ അവ്യക്തമാണെങ്കിൽ, നിങ്ങളുടെ പ്രോംപ്റ്റ് നിങ്ങളെ രക്ഷിക്കില്ല.

മികച്ച ഒരു പ്രോംപ്റ്റ് ഒരു ഉത്തരത്തെ മെച്ചപ്പെടുത്തുന്നു. എന്നാൽ മികച്ച ഒരു എൻവയോൺമെന്റ് മുഴുവൻ പ്രക്രിയയെയും (loop) മെച്ചപ്പെടുത്തുന്നു.

ഏജന്റ് സെറ്റപ്പിനെ CI/CD അല്ലെങ്കിൽ ഡിപ്ലോയ്‌മെന്റ് ഗേറ്റുകൾ (deployment gates) പോലെ കാണുക. ഇതിനെ ഒരു വ്യക്തിപരമായ താൽപ്പര്യമായി കാണരുത്. ഇതിനെ ഒരു സിസ്റ്റമായി കാണുക.

ഒരു ഏജന്റിന് ഫയലുകൾ എഡിറ്റ് ചെയ്യാൻ കഴിയുമെങ്കിലും ചെക്കുകൾ (checks) റൺ ചെയ്യാൻ കഴിയില്ലെങ്കിൽ, അത് കണ്ണ് കെട്ടിയ ഒരു കോഡ് ജനറേറ്റർ പോലെയാണ്. കൂടുതൽ ഇന്റഗ്രേഷനുകൾ നല്ലതാണെന്ന് കരുതി എല്ലാ ടൂളുകളുമായും അതിനെ ബന്ധിപ്പിക്കുന്നുണ്ടെങ്കിൽ, നിങ്ങൾ അറിയാതെ തന്നെ ഒരു പെർമിഷൻ മോഡൽ (permission model) സൃഷ്ടിക്കുകയാണ് ചെയ്യുന്നത്.

ചെറിയതും പരിശോധിക്കാവുന്നതുമായ (inspectable) കപ്പാബിലിറ്റികളിലേക്ക് മാറുന്നതാണ് ലക്ഷ്യം.

"ഈ ടെസ്റ്റ് റൺ ചെയ്യുക, പരാജയങ്ങൾ സംഗ്രഹിക്കുക" എന്ന കൃത്യമായ നിർദ്ദേശം "എല്ലാം ശരിയാണെന്ന് ഉറപ്പുവരുത്തുക" എന്ന തുറന്ന നിർദ്ദേശത്തേക്കാൾ നല്ലതാണ്. ആദ്യത്തേത് ഒരു പാത (trail) അവശേഷിപ്പിക്കുന്നു. രണ്ടാമത്തേത് വെറും നാടകീയതയ്ക്ക് (theater) മാത്രമേ സഹായിക്കൂ.

നല്ല സോഫ്റ്റ്‌വെയറിന് കൃത്യമായ അതിർവരമ്പുകളുണ്ട്.

ഒരു ഏജന്റിന് എത്ര ടൂളുകളുമായി ബന്ധപ്പെടാൻ കഴിയും എന്നതിലല്ല ശ്രദ്ധിക്കേണ്ടത്. ഓരോ ടൂളും ഏജന്റിനെ എന്താണ് ചെയ്യാൻ അനുവദിക്കുന്നത് എന്നതിലാണ് ശ്രദ്ധിക്കേണ്ടത്. അതിന് സ്റ്റേറ്റ് മാറ്റാൻ (mutate state) കഴിയുമോ? പ്രൊഡക്ഷനിൽ (production) എത്താൻ കഴിയുമോ? രഹസ്യവിവരങ്ങൾ (secrets) വെളിപ്പെടുത്തുന്നുണ്ടോ?

ഔട്ട്‌പുട്ട് (Output) എന്നത് ലിവറേജ് (leverage) അല്ല. ഏജന്റുകൾക്ക് കൂടുതൽ കോഡും കൂടുതൽ ബ്രാഞ്ചുകളും (branches) നിർമ്മിക്കാൻ കഴിയും. ജോലി വായിച്ചു മനസ്സിലാക്കാൻ എളുപ്പമല്ലെങ്കിൽ ഇത് റിവ്യൂ ഡെബ്റ്റ് (review debt) ഉണ്ടാക്കിയേക്കാം.

ഒരു ലോക്കൽ സെറ്റപ്പ് മനുഷ്യന്റെ ജോലി എളുപ്പമാക്കണം. അത് ഏജന്റിനെ വേഗത്തിലാക്കാൻ മാത്രമേ സഹായിക്കുന്നുള്ളൂ എങ്കിൽ, നിങ്ങളുടെ ടീമിന്റെ വേഗത വർദ്ധിച്ചേക്കില്ല.

ഔട്ട്‌പുട്ടിനെ വിശ്വസിക്കുന്നതിന് മുമ്പ് എൻവയോൺമെന്റിനെ വിശ്വസിക്കുക.

Source: https://dev.to/hefty_69a4c2d631c9dd70724/local-coding-agents-are-an-environment-problem-1o4p

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