Red Hat యొక్క 219 రియల్-వరల్డ్ సెషన్ల విశ్లేషణ ప్రకారం, Claude Code తన టోకెన్ బడ్జెట్‌లో మూడు వంతులు కేవలం కోడ్‌బేస్‌ను చదవడానికే ఉపయోగిస్తుంది. AI-ఆధారిత కోడింగ్ ఏజెంట్లు కోడ్ జనరేట్ చేయడంలో సమయాన్ని వృధా చేస్తాయనే సాధారణ అంచనాను ఈ ఫలితం తలకిందులు చేస్తోంది. డెవలపర్లు కేవలం మోడల్ వేగంపైనే కాకుండా, కాంటెక్స్ట్-మేనేజ్‌మెంట్ సమస్యపై దృష్టి పెట్టాలని ఇది సూచిస్తోంది.

ఈ వాదన వెనుక ఉన్న డేటా

Red Hat, Anthropic యొక్క Claude Codeతో జరిగిన 219 ఇంటరాక్షన్లను పరిశీలించి, ప్రతి టర్న్‌కు ఎంత టోకెన్ వినియోగించబడిందో లెక్కించింది. ఈ నమూనాలో, సగటున (median) 75% టోకెన్లు చుట్టుపక్కల ఉన్న కోడ్ మరియు డాక్యుమెంటేషన్‌ను గ్రహించడానికి (ingesting) కేటాయించబడ్డాయి, కేవలం 25% మాత్రమే కొత్త లైన్లను రూపొందించడానికి ఉపయోగించబడ్డాయి. చాలా AI ప్రొవైడర్లు ఇన్‌పుట్ మరియు అవుట్‌పుట్ టోకెన్లకు ఒకే రేటును వసూలు చేస్తారు కాబట్టి, లావాదేవీలో "చదవడం" అనే భాగమే ఎక్కువ ఖర్చుకు కారణమవుతోంది.

చదవడం వల్ల కలిగే ఖర్చు ఎందుకు ముఖ్యం

ఆప్టిమైజేషన్ వ్యూహం

ప్రతి జనరేషన్‌కు కొన్ని సెకన్ల సమయాన్ని ఆదా చేయవచ్చనే ఆశతో, చాలా టీమ్‌లు వేగవంతమైన లేదా పెద్ద మోడళ్ల కోసం వనరులను వెచ్చిస్తాయి. ఒకవేళ పనుల్లో మూడు వంతులు కేవలం కాంటెక్స్ట్‌ను తీసుకోవడానికే అయితే, వేగవంతమైన మోడల్ మొత్తం సమయాన్ని కేవలం కొంత భాగం మాత్రమే ఆదా చేస్తుంది. అసలైన కీలక అంశం ఏమిటంటే, ప్రతి టర్న్‌లో మోడల్ ఎంత కాంటెక్స్ట్‌ను ప్రాసెస్ చేయాల్సి వస్తుంది అనేది.

ఖర్చు నియంత్రణ

ఒక AI అసిస్టెంట్ ప్రతి రిక్వెస్ట్‌పై ఒకే రిపోజిటరీ స్టేట్‌ను మళ్ళీ మళ్ళీ చదివినప్పుడు, ఇన్‌పుట్ టోకెన్లు విపరీతంగా పెరుగుతాయి. జనరేట్ చేయబడిన కోడ్ పరిమాణం తక్కువగా ఉన్నప్పటికీ, పెద్ద కాంటెక్స్ట్ విండోస్ ఉన్న ప్రాజెక్టుల బిల్లులు భారీగా పెరగవచ్చు.

ఇంజనీరింగ్ ఫోకస్

టూల్ బిల్డర్లు తరచుగా ప్రాంప్ట్‌లు ఎలా నిర్మించబడతాయనే అంశాన్ని విస్మరించి, మోడల్ నాణ్యతను పెంచడానికి ప్రయత్నిస్తారు. మోడల్‌కు అందించే కోడ్‌ను తగ్గించడం (trimming), క్యాష్ చేయడం (caching) మరియు సారాంశం చేయడం (summarizing) వంటి "కాంటెక్స్ట్ ఇంజనీరింగ్" అనేది మోడల్ అప్‌గ్రేడ్‌ల కంటే ఎక్కువ ROIని ఇస్తుందని ఈ విశ్లేషణ సూచిస్తోంది.

రీడింగ్ ఓవర్‌హెడ్‌ను తగ్గించడానికి ఆచరణాత్మక దశలు

  • అనవసరమైన ఫైళ్లను తొలగించండి (Prune irrelevant files) – ప్రస్తుత టాస్క్‌కు అవసరం లేని ఫైళ్లను ప్రాంప్ట్ నుండి తొలగించండి. చిన్న ప్రాంప్ట్‌లు అంటే తక్కువ ఇన్‌పుట్ టోకెన్లు అని అర్థం.
  • పదేపదే చదివే అంశాలను క్యాష్ చేయండి (Cache repeated reads) – కోడ్‌బేస్‌లోని స్థిరమైన భాగాల గురించి మోడల్ చేసిన వివరణను నిల్వ ఉంచుకోండి మరియు ప్రతిసారీ అదే టెక్స్ట్‌ను పంపడానికి బదులుగా దానిని మళ్ళీ ఉపయోగించండి.
  • టూల్ అవుట్‌పుట్‌లను కంప్రెస్ చేయండి (Compress tool outputs) – ఎక్స్‌టర్నల్ టూల్స్ పెద్ద మొత్తంలో డేటాను (ఉదాహరణకు, lint రిపోర్ట్‌లు) తిరిగి ఇచ్చినప్పుడు, వాటిని Claudeకి పంపే ముందు సారాంశం చేయండి.
  • ఇన్‌క్రిమెంటల్ డిఫ్స్‌ను ఉపయోగించండి (Use incremental diffs) – మొత్తం ఫైల్ కంటెంట్‌ను పంపే బదులు, చివరి టర్న్ నుండి జరిగిన మార్పులను మాత్రమే పంపండి.

ఈ వ్యూహాలు ప్రతి ఇంటరాక్షన్‌పై ఒకే రిపోజిటరీ స్నాప్‌షాట్‌ను AI మళ్ళీ మళ్ళీ చదవకుండా ఆపడం ద్వారా, లేటెన్సీ మరియు ఖర్చు రెండింటినీ తగ్గించడమే లక్ష్యంగా పెట్టుకున్నాయి.

ప్రతి వాదన: వేగం ఇప్పటికీ ముఖ్యం

కొందరు డెవలపర్లు వేగవంతమైన మోడల్ ఇప్పటికీ ముఖ్యం అని వాదిస్తారు, ఎందుకంటే అది జనరేట్ చేయబడే 25% టోకెన్ల లేటెన్సీని తగ్గిస్తుంది. తక్షణమే స్పందించాల్సిన IDE ప్లగిన్‌ల వంటి లేటెన్సీ-సెన్సిటివ్ వాతావరణంలో, ప్రతి మిల్లీసెకన్ ముఖ్యం. చదవడం అనేది ప్రధానంగా ఉన్నప్పటికీ, వేగవంతమైన మోడల్ యొక్క ప్రయోజనాన్ని ఇది పూర్తిగా తొలగించదు; ఇది దాని సాపేక్ష ప్రభావాన్ని మాత్రమే తగ్గిస్తుంది.

తదుపరి ఏం గమనించాలి

Red Hat అధ్యయనం పరిమిత సెషన్లపై ఆధారపడి ఉంది, కాబట్టి విస్తృతమైన నమూనా ఇతర భాషలు లేదా ప్రాజెక్ట్ పరిమాణాలకు వేరే టోకెన్ పంపిణీని వెల్లడించవచ్చు. భవిష్యత్తు డేటా 75% రీడింగ్ గణాంకాన్ని ధృవీకరిస్తే, కాంటెక్స్ట్‌ను ఆటోమేటిక్‌గా తగ్గించే మరియు క్యాష్ చేసే టూలింగ్ వైపు లేదా వేగవంతమైన కాంటెక్స్ట్ ఇంజెషన్‌ కోసం రూపొందించబడిన మోడల్ ఆర్కిటెక్చర్‌ల వైపు మార్పును మనం చూడవచ్చు.

ముఖ్య గమనిక: AI-సహాయక కోడింగ్ కోసం, మోడల్‌ను వేగంగా రాయమని చెప్పడం కంటే, దానికి తక్కువ డేటాను అందించడం ద్వారా తక్కువ ఖర్చుతో మెరుగైన పనితీరును పొందవచ్చు. Red Hat గణాంకాలు స్పష్టమైన విషయాన్ని చెబుతున్నాయి: మీ ప్రాంప్ట్‌లను తగ్గించండి, క్యాష్ చేయండి మరియు సారాంశం చేయండి, అప్పుడు మీరు సమయం మరియు డబ్బు రెండింటిలోనూ గణనీయమైన ఆదాను చూస్తారు.