എന്റെ കോഡിംഗ് ഏജന്റ് ഓരോ ചെറിയ കാര്യത്തിനും അനുമതി ചോദിച്ചു

എന്റെ AI അസിസ്റ്റന്റിന് ഒരു വലിയ പ്രശ്നമുണ്ടായിരുന്നു. അത് അനുമതി ചോദിക്കുന്നത് നിർത്തുകയല്ല ചെയ്തത്, മറിച്ച് അത് അമിതമായി അനുമതി ചോദിക്കുകയായിരുന്നു ചെയ്തത്.

ഒരു PDF വായിക്കുന്നത് പോലുള്ള ലളിതമായ ഒരു ജോലി ഞാൻ അതിന് നൽകും. അസിസ്റ്റന്റ് ഒരു ചുവടുവെപ്പ് നടത്തും, അനുമതിക്കായി ചോദിക്കും, കമാൻഡ് പ്രവർത്തിപ്പിക്കും, തുടർന്ന് അടുത്ത ചെറിയ ഘട്ടത്തിനായി ഉടൻ തന്നെ വീണ്ടും ചോദിക്കും. ഒരു ജോലി എന്നത് പ്രോംപ്റ്റുകളുടെ ഒരു തുടർച്ചയായ കുരുക്കായി മാറി.

അനുമതിക്കായുള്ള പ്രോംപ്റ്റുകൾ ആവശ്യമാണ്. കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പോ, ഫയലുകൾ എഴുതുന്നതിന് മുമ്പോ, അല്ലെങ്കിൽ ആപ്പുകൾ തുറക്കുന്നതിന് മുമ്പോ ഒരു ലോക്കൽ അസിസ്റ്റന്റ് നിൽക്കണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നുണ്ടാകാം. എന്നാൽ യഥാർത്ഥ ജോലികൾക്ക് പല ഘട്ടങ്ങൾ ആവശ്യമാണ്. ഒരു PDF വായിക്കുന്നതിൽ Python ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നത്, ഒരു കൺവെർട്ടർ കണ്ടെത്തുന്നത്, ആ കൺവെർട്ടർ പ്രവർത്തിപ്പിക്കുന്നത്, ടെക്സ്റ്റ് വായിക്കുന്നത് എന്നിവ ഉൾപ്പെടുന്നു.

ഓരോ ഘട്ടത്തിലും അനുമതി ചോദിച്ചുകൊണ്ടിരുന്നാൽ, നിങ്ങൾ റിസ്ക് വിലയിരുത്തുന്നത് നിർത്തും. തടസ്സങ്ങൾ ഒഴിവാക്കാൻ വേണ്ടി മാത്രം നിങ്ങൾ അവ ക്ലിക്ക് ചെയ്യാൻ തുടങ്ങും. ഇത് സുരക്ഷാ സംവിധാനങ്ങളെ അവഗണിക്കാൻ നിങ്ങളെ ശീലിപ്പിക്കുന്നു. സുരക്ഷാ സംവിധാനങ്ങൾ ഇല്ലാതിരിക്കുന്നതിനേക്കാൾ അപകടകരമാണിത്.

പഴയ പ്രവർത്തനരീതി ഇപ്രകാരമായിരുന്നു:

അസിസ്റ്റന്റ് ഉപയോക്താവിന്റെ ഉദ്ദേശ്യം മനസ്സിലാക്കുന്നതിൽ പരാജയപ്പെട്ടു. നിങ്ങൾ ഒരു ചെറിയ പരീക്ഷണത്തിന് അനുമതി നൽകുകയല്ല ചെയ്തത്, മറിച്ച് ഒരു പൂർണ്ണമായ ജോലിക്കാണ് അനുമതി നൽകിയത്.

ഞാൻ CliGate-ന്റെ പ്രവർത്തനരീതിയിൽ മാറ്റം വരുത്തി. ഇപ്പോൾ, ഒരു ചാറ്റിലെ ആദ്യത്തെ നടപടിക്ക് നിങ്ങൾ അനുമതി നൽകിക്കഴിഞ്ഞാൽ, സിസ്റ്റം ഒരു ഫ്ലാഗ് (flag) സെറ്റ് ചെയ്യുന്നു. ഇത് പുതിയ അനുമതികൾക്കായി കാത്തുനിൽക്കാതെ അടുത്ത ഘട്ടങ്ങൾ തുടരാൻ സഹായിക്കുന്നു. അസിസ്റ്റന്റിന് യഥാർത്ഥ ഫലങ്ങൾ ലഭിക്കുന്നുണ്ടെന്നും അതിനാൽ അതിന് ജോലി തുടരാൻ കഴിയുമെന്നും ഉറപ്പാക്കുന്നു.

ഞാൻ ഒരു എസ്‌കേപ്പ് ഹാച്ച് (escape hatch) കൂടി ചേർത്തു: /safe. ഈ കമാൻഡ് ഉപയോഗിച്ച് എക്സ്പ്ലിസിറ്റ് കൺഫർമേഷൻ മോഡ് (explicit confirmation mode) വീണ്ടും ഓൺ ചെയ്യാം.

ഞാൻ ഒരു ഭാഷാപരമായ പിശകും (language bug) പരിഹരിച്ചു. സിസ്റ്റം ഒരു ജോലി തുടരുമ്പോൾ, ചിലപ്പോൾ പ്രോംപ്റ്റുകളുടെ ഭാഷ മാറുന്നുണ്ടായിരുന്നു. നിങ്ങൾ ചൈനീസ് ഭാഷയിലാണെങ്കിൽ, അടുത്ത പ്രോംപ്റ്റിനായി അസിസ്റ്റന്റ് ഇംഗ്ലീഷിലേക്ക് മാറുന്ന അവസ്ഥ ഉണ്ടായിരുന്നു. ഇപ്പോൾ, ശരിയായ ഭാഷ തിരഞ്ഞെടുക്കുന്നതിനായി അസിസ്റ്റന്റ് നിങ്ങളുടെ അവസാനത്തെ യഥാർത്ഥ സന്ദേശം പരിശോധിക്കുന്നു.

അനുമതികൾ ഒഴിവാക്കുക എന്നതല്ല പരിഹാരം. ഉപയോക്താവ് എന്തിനാണ് അനുമതി നൽകിയത് എന്ന് ഓർമ്മിക്കുക എന്നതാണ് ശരിയായ പരിഹാരം.

ലോക്കൽ ടൂളുകൾക്കായി, ടാസ്ക്-സ്കോപ്പ്ഡ് ട്രസ്റ്റ് (task-scoped trust) ഉപയോഗിക്കുക:

ഇതാണ് CliGate-ൽ ഞാൻ അനുമതികൾ ക്രമീകരിക്കുന്ന രീതി. Claude Code, Codex CLI, Gemini CLI എന്നിവയ്ക്കായുള്ള എന്റെ ലോക്കൽ കൺട്രോൾ പ്ലെയിൻ (local control plane) ആണിത്.

നിങ്ങൾ അനുമതി നൽകുന്നതിലെ തളർച്ചയെ (approval fatigue) എങ്ങനെയാണ് കൈകാര്യം ചെയ്യുന്നത്? ഓരോ ടൂൾ കോളിനും അനുമതി നൽകുന്നുണ്ടോ, ഓരോ ജോലിക്കാണോ, അതോ ഓരോ സെഷനാണോ?

എന്റെ കോഡിംഗ് ഏജന്റ് ഓരോ ചെറിയ കാര്യത്തിനും അനുമതി ചോദിച്ചു തുടങ്ങി

എന്റെ ഡെവലപ്‌മെന്റ് വർക്ക്ഫ്ലോയിൽ (development workflow) സഹായിക്കുന്നതിനായി അടുത്തിടെ ഞാൻ ഒരു AI കോഡിംഗ് ഏജന്റ് ഉപയോഗിക്കാൻ തുടങ്ങി. തുടക്കത്തിൽ ഇത് അത്ഭുതകരമായിരുന്നു. കോഡ് നിർദ്ദേശിക്കാനും ബഗുകൾ കണ്ടെത്താനും മുഴുവൻ ഫംഗ്ഷനുകൾ പോലും എഴുതാനും ഇതിന് സാധിക്കുമായിരുന്നു. എന്നാൽ പിന്നീട്, എന്റെ വേഗത ഗണ്യമായി കുറയ്ക്കുന്ന ഒരു കാര്യം സംഭവിച്ചു.

ഏജന്റ് ഓരോ ചെറിയ ചുവടുവെപ്പിനും അനുമതി ചോദിക്കാൻ തുടങ്ങി.

'എനിക്ക് package.json ഫയൽ വായിക്കാമോ?' 'എനിക്ക് src ഡയറക്ടറിയിലെ ഫയലുകൾ ലിസ്റ്റ് ചെയ്യാമോ?' 'എനിക്ക് npm install റൺ ചെയ്യാമോ?' 'എനിക്ക് utils.ts എന്ന പേരിൽ ഒരു പുതിയ ഫയൽ ക്രിയേറ്റ് ചെയ്യാമോ?'

ഓരോ ശ്വാസം വിടുന്നതിന് മുൻപും അനുമതി ചോദിച്ചുകൊണ്ടിരിക്കുന്ന, സൂക്ഷ്മമായി നിയന്ത്രിക്കുന്ന (micro-managing) ഒരു ഇന്റേൺ എന്റെ അടുത്തിരിക്കുന്നതുപോലെ തോന്നി. എന്റെ ഡെവലപ്‌മെന്റ് വേഗത്തിലാക്കുന്നതിന് പകരം, ഈ നിരന്തരമായ തടസ്സങ്ങൾ എന്റെ 'ഫ്ലോ' (flow) തകർത്തു കൊണ്ടിരുന്നു.

പ്രശ്നം ഏജന്റിന്റെ കഴിവിൽ ആയിരുന്നില്ല, മറിച്ച് അതിന്റെ കോൺഫിഗറേഷനിൽ (configuration) ആയിരുന്നു. മിക്ക ഏജന്റുകളും 'human-in-the-loop' രീതിയിലാണ് ക്രമീകരിച്ചിരിക്കുന്നത്, അതായത് ഓരോ ടൂൾ കോളിനും (tool call) മാനുവൽ അനുമതി ആവശ്യമാണ്. ഇത് സുരക്ഷിതമാണെങ്കിലും, ആവർത്തന സ്വഭാവമുള്ള ജോലികൾക്ക് ഇത് വളരെയധികം ബുദ്ധിമുട്ടുണ്ടാക്കുന്നു.

എനിക്ക് 'human-in-the-loop' രീതിയിൽ നിന്ന് 'human-on-the-loop' രീതിയിലേക്ക് മാറേണ്ടതുണ്ടെന്ന് ഞാൻ മനസ്സിലാക്കി.

ഓരോ