Claude Code അതിന്റെ ടോക്കൺ ബജറ്റിന്റെ മുക്കാൽ ഭാഗവും കോഡ്‌ബേസ് വായിക്കാൻ വേണ്ടി മാത്രമാണ് ചെലവഴിക്കുന്നത്, 219 യഥാർത്ഥ സെഷനുകളെക്കുറിച്ചുള്ള Red Hat-ന്റെ വിശകലനമനുസരിച്ച്. AI അധിഷ്ഠിത കോഡിംഗ് ഏജന്റുകൾ കോഡ് നിർമ്മിക്കുന്നതിനായി സമയം പാഴാക്കുന്നു എന്ന സാധാരണ ധാരണയെ ഈ കണ്ടെത്തൽ തിരുത്തുന്നു. പകരം, ഡെവലപ്പർമാർ മോഡൽ വേഗതയിൽ മാത്രമല്ല, കോൺടെക്സ്റ്റ് മാനേജ്‌മെന്റ് (context-management) പ്രശ്നത്തിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കണമെന്നാണ് ഇത് സൂചിപ്പിക്കുന്നത്.

ഈ അവകാശവാദത്തിന് പിന്നിലെ വിവരങ്ങൾ

Red Hat, Anthropic-ന്റെ Claude Code-മായുള്ള 219 സംഭാഷണങ്ങൾ പരിശോധിക്കുകയും ഓരോ ടേണിലും (turn) എത്ര ടോക്കണുകൾ ഉപയോഗിക്കുന്നു എന്ന് കണക്കാക്കുകയും ചെയ്തു. ഈ സാമ്പിളുകളിൽ, ശരാശരി ഒരു ടേണിൽ 75% ടോക്കണുകളും ചുറ്റുമുള്ള കോഡും ഡോക്യുമെന്റേഷനും വായിച്ചെടുക്കുന്നതിനായി ഉപയോഗിക്കുന്നു, എന്നാൽ വെറും 25% മാത്രമാണ് പുതിയ വരികൾ നിർമ്മിക്കുന്നതിനായി ഉപയോഗിക്കുന്നത്. മിക്ക AI സേവനദാതാക്കളും ഇൻപുട്ട്, ഔട്ട്പുട്ട് ടോക്കണുകൾക്ക് ഒരേ നിരക്കിലാണ് ചാർജ് ചെയ്യുന്നത് എന്നതിനാൽ, ഈ ഇടപാടുകളിലെ "വായിക്കുന്ന" ഭാഗമാണ് ഭൂരിഭാഗം ചിലവിനും കാരണമാകുന്നത്.

എന്തുകൊണ്ടാണ് വായനയ്ക്കുള്ള ചിലവ് പ്രധാനമാകുന്നത്

ഒപ്റ്റിമൈസേഷൻ തന്ത്രം

ഓരോ തവണ കോഡ് നിർമ്മിക്കുമ്പോഴും കുറച്ച് സെക്കൻഡുകൾ ലാഭിക്കാമെന്ന പ്രതീക്ഷയിൽ പല ടീമുകളും വേഗതയേറിയതോ വലിയതോ ആയ മോഡലുകൾക്കായി വിഭവങ്ങൾ ചെലവഴിക്കുന്നു. ജോലിയുടെ മുക്കാൽ ഭാഗവും കോൺടെക്സ്റ്റ് ഉൾക്കൊള്ളുന്നതിനായി മാത്രമാണെങ്കിൽ, വേഗതയേറിയ ഒരു മോഡൽ ആകെ സമയത്തിന്റെ ഒരു ചെറിയ ഭാഗം മാത്രമേ ലാഭിക്കൂ. ഓരോ ടേണിലും മോഡലിന് എത്രത്തോളം കോൺടെക്സ്റ്റ് പ്രോസസ്സ് ചെയ്യേണ്ടതുണ്ട് എന്നതാണ് യഥാർത്ഥത്തിൽ ശ്രദ്ധിക്കേണ്ട കാര്യം.

ചിലവ് നിയന്ത്രണം

ഒരു AI അസിസ്റ്റന്റ് ഓരോ അഭ്യർത്ഥനയിലും ഒരേ റെപ്പോസിറ്ററി സ്റ്റേറ്റ് വീണ്ടും വീണ്ടും വായിക്കുമ്പോൾ, ഇൻപുട്ട് ടോക്കണുകൾ കുതിച്ചുയരുന്നു. വലിയ കോൺടെക്സ്റ്റ് വിൻഡോകളുള്ള പ്രോജക്റ്റുകളിൽ, നിർമ്മിക്കുന്ന കോഡിന്റെ അളവ് കുറവാണെങ്കിൽ പോലും ബില്ലുകൾ ഗണ്യമായി വർദ്ധിച്ചേക്കാം.

എഞ്ചിനീയറിംഗ് ശ്രദ്ധ

പ്രോംപ്റ്റുകൾ എങ്ങനെ നിർമ്മിക്കുന്നു എന്നതിനെ അവഗണിച്ച് ടൂൾ നിർമ്മാതാക്കൾ പലപ്പോഴും ഉയർന്ന മോഡൽ ഗുണനിലവാരത്തിന് പിന്നാലെ പോകുന്നു. മോഡലിന് നൽകുന്ന കോഡ് കുറയ്ക്കുക (trimming), കാഷെ ചെയ്യുക (caching), സംഗ്രഹിക്കുക (summarizing) തുടങ്ങിയ "കോൺടെക്സ്റ്റ് എഞ്ചിനീയറിംഗ്" (context engineering) രീതികൾ മോഡലുകൾ അപ്‌ഗ്രേഡ് ചെയ്യുന്നതിനേക്കാൾ മികച്ച ROI നൽകുമെന്ന് ഈ വിശകലനം സൂചിപ്പിക്കുന്നു.

വായനയ്ക്കുള്ള അധിക ചിലവ് കുറയ്ക്കാൻ പ്രായോഗികമായ നടപടികൾ

  • അനാവശ്യ ഫയലുകൾ ഒഴിവാക്കുക (Prune irrelevant files) – നിലവിലെ ടാസ്കിന് ആവശ്യമില്ലാത്ത ഫയലുകൾ പ്രോംപ്റ്റിൽ നിന്ന് നീക്കം ചെയ്യുക. ചെറിയ പ്രോംപ്റ്റുകൾ എന്നാൽ കുറഞ്ഞ ഇൻപുട്ട് ടോക്കണുകൾ എന്നാണ് അർത്ഥം.
  • ആവർത്തിച്ചുള്ള വായനകൾ കാഷെ ചെയ്യുക (Cache repeated reads) – കോഡ്‌ബേസിലെ സ്ഥിരമായ ഭാഗങ്ങളെക്കുറിച്ചുള്ള മോഡലിന്റെ വ്യാഖ്യാനം സൂക്ഷിച്ചുവെക്കുകയും, ഒരേ ടെക്സ്റ്റ് വീണ്ടും അയക്കുന്നതിന് പകരം അത് ഉപയോഗിക്കുകയും ചെയ്യുക.
  • ടൂൾ ഔട്ട്‌പുട്ടുകൾ കംപ്രസ്സ് ചെയ്യുക (Compress tool outputs) – ബാഹ്യ ടൂളുകൾ വലിയ വിവരങ്ങൾ (ഉദാഹരണത്തിന്, lint റിപ്പോർട്ടുകൾ) നൽകുന്നുണ്ടെങ്കിൽ, അവ തിരികെ Claude-ന് നൽകുന്നതിന് മുമ്പ് സംഗ്രഹിക്കുക.
  • ഇൻക്രിമെന്റൽ ഡിഫുകൾ ഉപയോഗിക്കുക (Use incremental diffs) – മുഴുവൻ ഫയൽ ഉള്ളടക്കവും അയക്കുന്നതിന് പകരം അവസാന ടേണിന് ശേഷം വന്ന മാറ്റങ്ങൾ മാത്രം അയക്കുക.

ഈ തന്ത്രങ്ങൾ ഓരോ തവണയും ഒരേ റെപ്പോസിറ്ററി സ്നാപ്പ്ഷോട്ട് വീണ്ടും വീണ്ടും വായിക്കുന്നത് തടയാനും, അതുവഴി ലേറ്റൻസിയും (latency) ചിലവും കുറയ്ക്കാനും ലക്ഷ്യമിടുന്നു.

എതിർവാദം: വേഗത ഇപ്പോഴും പ്രധാനമാണ്

ചില ഡെവലപ്പർമാർ വാദിക്കുന്നത്, നിർമ്മിക്കപ്പെടുന്ന 25% ടോക്കണുകളുടെ ലേറ്റൻസി കുറയ്ക്കുന്നതിനാൽ വേഗതയേറിയ മോഡലുകൾ ഇപ്പോഴും പ്രസക്തമാണ് എന്നാണ്. ഇൻസ്റ്റന്റ് ആയി പ്രതികരിക്കേണ്ട IDE പ്ലഗിനുകൾ പോലുള്ള ലേറ്റൻസിക്ക് പ്രാധാന്യമുള്ള സാഹചര്യങ്ങളിൽ, ഓരോ മില്ലിസെക്കൻഡും വിലപ്പെട്ടതാണ്. വായനയ്ക്ക് മുൻഗണന നൽകുന്ന ഈ രീതി വേഗതയേറിയ മോഡലിന്റെ ഗുണത്തെ ഇല്ലാതാക്കുന്നില്ല; മറിച്ച് അതിന്റെ ആപേക്ഷിക സ്വാധീനം കുറയ്ക്കുക മാത്രമാണ് ചെയ്യുന്നത്.

ഇനി ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങൾ

Red Hat-ന്റെ പഠനം പരിമിതമായ സെഷനുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, അതിനാൽ കൂടുതൽ വിശാലമായ പഠനങ്ങൾ മറ്റ് ഭാഷകൾക്കോ പ്രോജക്റ്റ് വലുപ്പങ്ങൾക്കോ വേണ്ടി വ്യത്യസ്ത ടോക്കൺ വിതരണങ്ങൾ വെളിപ്പെടുത്തിയേക്കാം. ഭാവിയിലെ ഡാറ്റ ഈ 75% വായന എന്ന കണക്ക് സ്ഥിരീകരിച്ചാൽ, കോൺടെക്സ്റ്റ് സ്വയമേവ കുറയ്ക്കുകയും കാഷെ ചെയ്യുകയും ചെയ്യുന്ന ടൂളുകളിലേക്കോ അല്ലെങ്കിൽ വേഗത്തിൽ കോൺടെക്സ്റ്റ് ഉൾക്കൊള്ളാൻ രൂപകൽപ്പന ചെയ്ത മോഡൽ ആർക്കിടെക്ചറുകളിലേക്കോ ഒരു മാറ്റം നമുക്ക് കാണാൻ കഴിഞ്ഞേക്കും.

ചുരുക്കത്തിൽ: AI അധിഷ്ഠിത കോഡിംഗിൽ, മോഡലിനെ വേഗത്തിൽ എഴുതാൻ പ്രേരിപ്പിക്കുന്നതിനേക്കാൾ കുറഞ്ഞ വിവരങ്ങൾ നൽകുന്നതിലൂടെയാണ് ഏറ്റവും കുറഞ്ഞ ചിലവിൽ മികച്ച പ്രകടനം നേടാൻ കഴിയുന്നത്. Red Hat-ന്റെ കണക്കുകൾ വ്യക്തമായ ഒരു കാര്യം പറയുന്നു: നിങ്ങളുടെ പ്രോംപ്റ്റുകൾ കുറയ്ക്കുക, കാഷെ ചെയ്യുക, സംഗ്രഹിക്കുക; അപ്പോൾ സമയം കൊണ്ടും പണം കൊണ്ടും നിങ്ങൾക്ക് വലിയ ലാഭം കാണാൻ കഴിയും.