Red Hat-ன் 219 நிஜ உலக அமர்வுகளின் (sessions) பகுப்பாய்வின்படி, Claude Code தனது டோக்கன் பட்ஜெட்டில் முக்கால்வாதியை வெறும் கோட்பேஸை (codebase) வாசிப்பதற்கே செலவிடுகிறது. AI-ஆல் இயக்கப்படும் கோடிங் ஏஜெண்டுகள் குறியீட்டை உருவாக்குவதில் நேரத்தை வீணடிக்கின்றன என்ற வழக்கமான கருத்தை இந்த கண்டுபிடிப்பு மாற்றியமைக்கிறது; மேலும் டெவலப்பர்கள் மாடல் வேகத்தை மட்டும் கவனிக்காமல், சூழல் மேலாண்மை (context-management) சிக்கலைத் தீர்க்க வேண்டும் என்பதை இது உணர்த்துகிறது.

இந்த வாதத்திற்குப் பின்னால் உள்ள தரவு

Red Hat, Anthropic-ன் Claude Code உடனான 219 தொடர்புகளை ஆய்வு செய்து, ஒவ்வொரு முறையும் (turn) பயன்படுத்தப்படும் டோக்கன்களைக் கணக்கிட்டது. இந்த மாதிரியில், சராசரியாக 75% டோக்கன்கள் சுற்றியுள்ள குறியீடு மற்றும் ஆவணங்களை உள்வாங்குவதற்கும் (ingesting), வெறும் 25% மட்டுமே புதிய வரிகளை உருவாக்குவதற்கும் பயன்படுத்தப்பட்டன. பெரும்பாலான AI வழங்குநர்கள் உள்ளீடு (input) மற்றும் வெளியீடு (output) டோக்கன்களுக்கு ஒரே விகிதத்தில் கட்டணம் வசூலிப்பதால், இந்த "வாசிப்பு" சார்ந்த பகுதிதான் செலவின் பெரும்பகுதியைத் தீர்மானிக்கிறது.

வாசிப்புச் செலவு ஏன் முக்கியமானது

உகப்பாக்க உத்தி (Optimization strategy)

பல குழுக்கள் வேகமான அல்லது பெரிய மாடல்களுக்காக வளங்களைச் செலவிடுகிறார்கள், இதன் மூலம் ஒவ்வொரு முறை குறியீடு உருவாக்கும் போதும் சில வினாடிகளைக் குறைக்கலாம் என்று நம்புகிறார்கள். ஆனால் வேலையில் முக்கால்வாதி வெறும் சூழலை (context) உள்வாங்குவதற்கே என்றால், வேகமான மாடல் மொத்த நேரத்தில் ஒரு சிறு பகுதியை மட்டுமே மிச்சப்படுத்தும். ஒவ்வொரு முறையும் மாடல் எவ்வளவு சூழலைச் செயலாக்க வேண்டும் என்பதே உண்மையான தீர்வாகும்.

செலவுக் கட்டுப்பாடு

ஒரு AI உதவியாளர் ஒவ்வொரு கோரிக்கையின் போதும் அதே ரெப்போசிட்டரி நிலையை (repository state) மீண்டும் மீண்டும் வாசிக்கும்போது, உள்ளீடு டோக்கன்கள் (input tokens) பெருமளவில் அதிகரிக்கின்றன. பெரிய சூழல் சாளரங்களைக் (context windows) கொண்ட திட்டங்களில், உருவாக்கப்பட்ட குறியீட்டின் அளவு குறைவாக இருந்தாலும், கட்டணங்கள் வியக்கத்தக்க வகையில் அதிகரிக்கக்கூடும்.

பொறியியல் கவனம்

கருவி உருவாக்குபவர்கள் (Tool builders) பெரும்பாலும் மாடலின் தரத்தை மேம்படுத்துவதில் கவனம் செலுத்துகிறார்கள், ஆனால் ப்ராம்ப்ட்கள் (prompts) எவ்வாறு கட்டமைக்கப்படுகின்றன என்பதைக் கவனிக்கத் தவறிவிடுகிறார்கள். மாடலுக்கு வழங்கப்படும் குறியீட்டைத் துண்டாக்குதல் (trimming), சேமித்து வைத்தல் (caching) மற்றும் சுருக்குதல் (summarizing) போன்ற "சூழல் பொறியியல்" (context engineering) முறைகள், மாடல்களை படிப்படியாக மேம்படுத்துவதை விட அதிக லாபத்தைத் (ROI) தரும் என்று இந்த ஆய்வு கூறுகிறது.

வாசிப்புச் சுமையைக் குறைக்க நடைமுறைப் படிகள்

  • தேவையற்ற கோப்புகளை நீக்குதல் (Prune irrelevant files) – தற்போதைய பணிக்குத் தேவையில்லாத கோப்புகளை ப்ராம்ப்டிலிருந்து நீக்கவும். சிறிய ப்ராம்ப்ட்கள் குறைந்த உள்ளீடு டோக்கன்களையே உருவாக்கும்.
  • மீண்டும் மீண்டும் வாசிக்கப்படும் தரவுகளைச் சேமித்தல் (Cache repeated reads) – கோட்பேஸின் நிலையான பகுதிகள் குறித்த மாடலின் விளக்கங்களைச் சேமித்து வைத்து, ஒவ்வொரு முறையும் அதே உரையை மீண்டும் அனுப்புவதற்குப் பதிலாக அதை மீண்டும் பயன்படுத்தவும்.
  • கருவி வெளியீடுகளைச் சுருக்குதல் (Compress tool outputs) – வெளிப்புறக் கருவிகள் பெரிய அளவிலான தரவுகளைத் (உதாரணமாக, lint reports) தரும்போது, அவற்றை Claude-க்குத் திருப்பி அனுப்பும் முன் சுருக்கிவிடவும்.
  • படிப்படியான மாற்றங்களைப் பயன்படுத்துதல் (Use incremental diffs) – முழு கோப்பு உள்ளடக்கத்தையும் அனுப்புவதற்குப் பதிலாக, கடந்த முறைக்குப் பிறகு ஏற்பட்ட மாற்றங்களை (diffs) மட்டும் அனுப்பவும்.

இந்த உத்திகள், ஒவ்வொரு முறையும் அதே ரெப்போசிட்டரி ஸ்னாப்ஷாட்டை (snapshot) AI மீண்டும் மீண்டும் வாசிப்பதைத் தடுத்து, தாமதம் (latency) மற்றும் செலவு இரண்டையும் குறைக்க முயல்கின்றன.

எதிர்வாதம்: வேகம் இன்னும் முக்கியம்

சில டெவலப்பர்கள் வேகமான மாடல் இன்னும் முக்கியமானது என்று வாதிடுகிறார்கள், ஏனெனில் அது உருவாக்கப்படும் 25% டோக்கன்களின் தாமதத்தைக் (latency) குறைக்கிறது. உடனடிப் பதிலளிக்க வேண்டிய IDE பிளகின்கள் போன்ற தாமத உணர்திறன் கொண்ட சூழல்களில், ஒவ்வொரு மில்லிசெகண்டும் முக்கியமானது. வாசிப்பு சார்ந்த இந்தத் தன்மை வேகமான மாடலின் பயனைப் பறிக்காது; அது அதன் ஒப்பீட்டுத் தாக்கத்தை மட்டுமே குறைக்கிறது.

அடுத்து எதைக் கவனிக்க வேண்டும்

Red Hat-ன் ஆய்வு ஒரு குறிப்பிட்ட எண்ணிக்கையிலான அமர்வுகளை மட்டுமே அடிப்படையாகக் கொண்டது, எனவே விரிவான ஆய்வுகள் மற்ற மொழிகள் அல்லது திட்ட அளவுகளுக்கு வேறுபட்ட டோக்கன் விநியோகத்தைக் காட்டலாம். எதிர்காலத் தரவுகள் இந்த 75% வாசிப்பு அளவை உறுதிப்படுத்தினால், சூழலைத் தானாகவே துண்டாக்கும் மற்றும் சேமிக்கும் கருவிகள் அல்லது விரைவான சூழல் உள்வாங்குதலுக்காக வடிவமைக்கப்பட்ட மாடல் கட்டமைப்புகளை நாம் காணக்கூடும்.

சுருக்கம்: AI-ஆல் உதவும் கோடிங்கிற்கு, மாடலை வேகமாக எழுத வைப்பதன் மூலம் கிடைக்கும் செயல்திறனை விட, மாடலுக்குக் குறைவான தரவுகளை வழங்குவதன் மூலம் அதிக செயல்திறனைப் பெற முடியும். Red Hat-ன் புள்ளிவிவரங்கள் ஒரு தெளிவான கருத்தை முன்வைக்கின்றன: உங்கள் ப்ராம்ப்ட்களைத் துண்டாக்கி, சேமித்து வைத்து, சுருக்கிப் பயன்படுத்துங்கள்; அப்போதுதான் நீங்கள் நேரம் மற்றும் பணம் இரண்டிலும் குறிப்பிடத்தக்க சேமிப்பைக் காண்பீர்கள்.