లక్ష్య పాఠకులు: AI ప్రోగ్రామింగ్ టూల్స్ (Cursor, Windsurf, trae...) ఉపయోగిస్తున్న డెవలపర్లు మరియు AI ఖర్చులపై అవగాహన లేని సాంకేతిక నిర్వాహకులు.

ముఖ్యమైన అంశం: టోకెన్ అనేది సాధారణ బిల్లింగ్ యూనిట్ మాత్రమే కాదు, ఇది ఒక రకమైన 'శ్రద్ధ వనరు' మరియు 'కంప్యూటింగ్ పవర్ కరెన్సీ'. ఏజెంట్ మోడ్‌ను దుర్వినియోగం చేయడం, సందర్భ నిర్వహణను విస్మరించడం అంటే వ్యూహాత్మక సోమరితనాన్ని (స్వంతంగా ఆలోచించకపోవడం) కప్పిపుచ్చడానికి వ్యూహాత్మకంగా కష్టపడటం (AIని గుడ్డిగా తిప్పడం).

మీ 'AI ఖర్చు' మీ జీతం కంటే ఎక్కువ కావచ్చు

కొన్ని రోజుల క్రితం, నేను నా టోకెన్ బిల్లును తనిఖీ చేసాను. ఆ సంఖ్యను చూసినప్పుడు, నేను కొంచెం ఆశ్చర్యపోయాను: 10 మిలియన్ టోకెన్లు. ఇది ఒక నెల వినియోగం కాదని గుర్తుంచుకోండి, ఇది ఒక రోజు.

నేను ఇది చాలా దారుణంగా ఉందని అనుకున్నాను. తరువాత నేను టోకెన్ గణన గురించి ఒక చిన్న వీడియోను పోస్ట్ చేసాను.

ఫలితంగా, వ్యాఖ్యల విభాగం నాకు 'ఆకాశానికి హద్దుల్లేవు' అని చూపించింది.

దిగువ చిత్రం వినియోగదారు 'ఓల్డ్ K డైలీ' యొక్క ఒక రోజు రెండు వందల మిలియన్ టోకెన్ వినియోగ రికార్డ్ స్క్రీన్ షాట్:

మొదట్లో ఇది ఒక ప్రత్యేక సందర్భం అని నేను అనుకున్నాను, కానీ చాలా మంది నెటిజన్లు తాము రోజుకు 100 మిలియన్లు వినియోగిస్తున్నామని చెప్పినప్పుడు, ఇది చాలా సాధారణ దృగ్విషయం అని నాకు అర్థమైంది.

ఒక వంద మిలియన్ టోకెన్లు అంటే ఏమిటి? 'కొన్ని ప్రధాన వాణిజ్య నమూనాల' సాధారణ బిల్లింగ్ స్థాయి ప్రకారం (ఇన్‌పుట్/అవుట్‌పుట్ విడిగా బిల్ చేయబడతాయి, మొత్తంమీద సుమారుగా $10 / మిలియన్ టోకెన్లుగా అంచనా వేయబడుతుంది), ఈ రోజు $1000 కాలిపోయింది. ఒక రోజులో 7000 యువాన్లు కాలిపోతాయి. చాలా మంది జూనియర్ ప్రోగ్రామర్ల నెల జీతం కూడా AI 'ఆలోచించడానికి' సరిపోకపోవచ్చు.

(గమనిక: వివిధ నమూనాలు/సరఫరాదారుల ధరలు చాలా తేడాగా ఉంటాయి మరియు ఇన్‌పుట్ మరియు అవుట్‌పుట్ ధరలు కూడా తరచుగా భిన్నంగా ఉంటాయి. ఇక్కడ ఉద్దేశ్యం దశాంశ స్థానానికి ఖచ్చితంగా లెక్కించడం కాదు, కానీ ముందుగా 'పరిమాణ భావాన్ని' ఏర్పరచడం.)

మీరు మీరే తిరిగి లెక్కించాలనుకుంటే, సాధారణంగా ఇది ఒక సూత్రం (కాష్/డిస్కౌంట్ వంటి ప్రత్యేక నియమాలను విస్మరించండి): ఖర్చు ≈ (ఇన్‌పుట్ టోకెన్ / 1,000,000) × ధర_ఇన్ + (అవుట్‌పుట్ టోకెన్ / 1,000,000) × ధర_అవుట్

ఇది చాలా విరుద్ధంగా ఉంది. AI చౌకగా ఉందని మేము ఎప్పుడూ అనుకుంటాము, OpenAI ధరలను కూడా తగ్గించాలనుకుంటోంది. కానీ వాస్తవ ఇంజనీరింగ్‌లో, టోకెన్ వినియోగం ఘాతాంకంగా ఎందుకు పేలుతుంది?

ఈ రోజు, ఈ 'టోకెన్ బ్లాక్ హోల్' వెనుక ఉన్న తర్కాన్ని ఎలా విడదీయాలో మరియు నష్టాన్ని ఎలా ఆపాలో నేను మీకు చూపిస్తాను.

I. టోకెన్లు 'ఘాతాంకంగా' ఎందుకు పేలుతాయి?

చాలా మంది సోదరులకు టోకెన్ పరిమాణం గురించి పూర్తిగా తెలియదు. వారు ఇలా అనుకుంటారు: "ఓహ్, ఇది కొన్ని కోడ్‌లను పంపడం మాత్రమే కదా? ఎంత ఉంటుంది?"

1. ఒక స్పష్టమైన ఖాతాను లెక్కించండి

మొదట, మనం ఇంజనీరింగ్‌లో ఉపయోగపడే పరిమాణాత్మక అవగాహనను ఏర్పరచుకుందాం. ముందుగా, ఒక విషయాన్ని ఖచ్చితంగా చెప్పండి: టోకెన్ అనేది పదాల సంఖ్య కాదు, అక్షరాల సంఖ్య కూడా కాదు. ఇది మోడల్ టెక్స్ట్‌ను విభజించిన తరువాత వచ్చే 'ఎన్‌కోడింగ్ ఫ్రాగ్మెంట్', విభిన్న మోడల్‌లు వేర్వేరు టోకనైజర్‌లను ఉపయోగిస్తాయి, కాబట్టి మనం కేవలం పరిధిని మాత్రమే ఇవ్వగలం, 'అందరికీ సరిపోయే' స్థిరాంకాన్ని కాదు.

దిగువ సంఖ్యలను 'అంచనా స్కేల్'గా భావించండి (పరిమాణాన్ని నిర్ణయించడం, ఖర్చులను అంచనా వేయడం మరియు నష్టాన్ని ఆపే నిర్ణయాలు తీసుకోవడం దీని ఉద్దేశ్యం):

• 1 చైనీస్ అక్షరం: సాధారణంగా 1–2 టోకెన్లు (తరచుగా ఉపయోగించే అక్షరాలు 1కి దగ్గరగా ఉంటాయి, అరుదైన అక్షరాలు/కలయికలు 2–3కి చేరుకోవడం సులభం)

• 1 ఆంగ్ల పదం: సాధారణంగా 1.2–1.5 టోకెన్లు (సుమారుగా అంచనా వేయడానికి 1.3ని ఉపయోగించవచ్చు)

• 1 లైన్ కోడ్ ≈ 10–50 టోకెన్లు (ఇండెంటేషన్, వ్యాఖ్యలు, రకం ప్రకటనలతో సహా)

• సంక్షిప్త వ్యాపార తర్కం ≈ 12–20 టోకెన్లు

• రకం ఉల్లేఖనాలు, ఇంటర్‌ఫేస్, JSDoc, 4-స్పేస్ ఇండెంటేషన్‌తో ≈ 20–35 టోకెన్లు

• పెద్ద సంఖ్యలో దిగుమతులు / డెకరేటర్లు / వ్యాఖ్యలతో ≈ 30–50+ టోకెన్లు

• 1 సోర్స్ ఫైల్ (400–600 లైన్లు, ఆధునిక TS/Java ప్రాజెక్ట్) ≈ 4,000–24,000 టోకెన్లు చాలా సాధారణం (మధ్యస్థం ≈ 12,000–18,000)

• 1 మధ్యస్థాయి ప్రాజెక్ట్ (100–200 సోర్స్ ఫైల్స్, src/ మాత్రమే లెక్కించబడుతుంది, node_modules/ / ఉత్పత్తి చేయబడిన కోడ్ కాదు)

• కోర్ సోర్స్ కోడ్‌ను 'ఒకసారి చదవడం' తరచుగా మిలియన్ టోకెన్లతో ప్రారంభమవుతుంది

• మీరు పరీక్షలు, కాన్ఫిగరేషన్‌లు, స్క్రిప్ట్‌లు, డిపెండెన్సీ డిక్లరేషన్‌లు, లాగ్‌లను కూడా కలిపితే, పది మిలియన్ల టోకెన్లు కూడా అసాధారణం కాదు

నేటి ఫ్రంటెండ్ ప్రాజెక్ట్‌లన్నీ TypeScript, సంక్లిష్టమైన ఇంటర్‌ఫేస్ నిర్వచనాలతో నిండి ఉన్నాయి; లేదా Java, తరచుగా డజన్ల కొద్దీ దిగుమతులు ఉంటాయి. ఈ 'బాయిలర్‌ప్లేట్ కోడ్' నిజానికి టోకెన్ కిల్లర్. ఒక మధ్యస్థాయి ప్రాజెక్ట్‌లో 100 ఫైల్స్ ఉంటే, AI 'కోడ్‌ను చదవడానికి' అనుమతించడం ద్వారా నేరుగా 1 మిలియన్ టోకెన్లను తొలగించవచ్చు.

2. టోకెన్ యొక్క 'స్నోబాల్' ప్రభావం

టోకెన్ వినియోగంలో అత్యంత భయంకరమైన విషయం ఒకే సంభాషణ కాదు, బహుళ సంభాషణలలో సందర్భం పేరుకుపోవడం.

LLM యొక్క విధానం స్థితిలేనిది. AI మీరు చివరిసారి ఏమి చెప్పారో గుర్తుంచుకోవడానికి, సిస్టమ్ సాధారణంగా 'సిస్టమ్ ప్రాంప్ట్ + మునుపటి సంభాషణలు + మీరు సూచించిన ఫైల్‌లు/కోడ్ స్నిప్పెట్‌లు + సాధనం కాల్ అవుట్‌పుట్ (శోధన ఫలితాలు, ఎర్రర్ లాగ్‌లు వంటివి)' అన్నీ కలిపి మోడల్‌కు పంపుతుంది. మీరు ఒక ప్రశ్న మాత్రమే అడిగానని అనుకుంటారు, కానీ మీరు 'మొత్తం సందర్భ ప్యాకేజీ' కోసం పదే పదే చెల్లిస్తున్నారు.

• రౌండ్ 1: 10,000 టోకెన్లను పంపండి, AI 1,000కి సమాధానం ఇస్తుంది.

• రౌండ్ 2: (10,000 + 1,000 + కొత్త ప్రశ్న) పంపండి, AI సమాధానం ఇస్తుంది...

• రౌండ్ 10: మీ సందర్భం ఇప్పటికే 200,000 టోకెన్లకు పెరిగి ఉండవచ్చు.

ఈ సమయంలో, మీరు 'వేరియబుల్ పేరును మార్చడానికి నాకు సహాయం చేయండి' అని అడిగినా, మీరు 200,000 టోకెన్ల రుసుమును వినియోగిస్తున్నారు. అందుకే మీరు ఏమీ చేయనప్పటికీ, బిల్లులు ఎందుకు పెరుగుతున్నాయో ఇదిగోండి.

మరింత దారుణంగా: ఏజెంట్ మోడ్ 'ఫైల్‌లను చురుకుగా చదువుతుంది'. మీరు 'వినియోగదారు మాడ్యూల్‌ను ఆప్టిమైజ్ చేయడానికి నాకు సహాయం చేయండి' అని చెప్పినప్పుడు, అది మొదట సంబంధిత డైరెక్టరీని స్కాన్ చేస్తుంది, ఆపై డిపెండెన్సీలను ట్రాక్ చేస్తుంది, ఆపై కాన్ఫిగరేషన్‌లను ట్రాక్ చేస్తుంది, ఆపై పరీక్షలను ట్రాక్ చేస్తుంది... ఇది సోమరితనం కాదు, ఇది 'డిఫాల్ట్ వ్యూహాన్ని అనుసరించడానికి బాధ్యత వహిస్తుంది', మరియు డిఫాల్ట్ వ్యూహం తరచుగా ఉంటుంది: ఎక్కువ చదవండి, ఎక్కువ ప్రయత్నించండి, ఎక్కువ పునరావృతం చేయండి.

II. రెండు రకాల 'సోమరితనం' మీ ఇంజనీరింగ్ సామర్థ్యాన్ని నాశనం చేస్తున్నాయి

వ్యాఖ్యల విభాగంలోని 'వంద మిలియన్ల మంది సోదరుల' సమీక్ష తరువాత, టోకెన్ల పెరుగుదల యొక్క మూలం AI వినియోగ విధాన సమస్య మాత్రమే కాదని, ప్రజల సోమరితనంతో కూడా దగ్గరి సంబంధం ఉందని నేను కనుగొన్నాను.

దిగువ రెండు సాధారణ రకాల 'మానసిక సోమరితనం' ఉన్నాయి.

సోమరితనం ఒకటి: హ్యాండ్స్-ఆఫ్ మేనేజర్ రకం

మీకు కూడా ఈ మనస్తత్వం ఉందా?

• "ఈ పాత ప్రాజెక్ట్ చాలా గందరగోళంగా ఉంది, నేను తర్కాన్ని చూడటానికి ఇష్టపడను, దానిని నేరుగా AIకి విసిరేస్తాను."

• "Cursor ఏజెంట్ మోడ్‌ను విడుదల చేసింది, చాలా బాగుంది, దాన్ని స్వయంగా బగ్‌లను పరిష్కరించనివ్వండి."

కాబట్టి, మీరు మొత్తం src ఫోల్డర్‌ను ఏజెంట్‌కు విసిరి, అస్పష్టమైన సూచనను ఇచ్చారు: "వినియోగదారు మాడ్యూల్‌ను ఆప్టిమైజ్ చేయడానికి నాకు సహాయం చేయండి." ఏజెంట్ పని చేయడం ప్రారంభించింది:

• ఇది 50 ఫైల్‌లను చదివింది (500,000 వినియోగించబడ్డాయి).

• ఇది utilsని సూచిస్తుందని కనుగొంది, కాబట్టి ఇది యుటిలిటీ తరగతులను చదవడానికి వెళ్ళింది (200,000 వినియోగించబడ్డాయి).

• ఇది సవరించడానికి ప్రయత్నించింది, లోపం వచ్చింది, లోపం లాగ్‌లను చదివింది (100,000 వినియోగించబడ్డాయి).

• ఇది పరిష్కరించడానికి ప్రయత్నించింది, మళ్ళీ లోపం వచ్చింది...

ఇది ఉన్మాదిగా ప్రయత్నిస్తోంది మరియు తప్పు చేస్తోంది, ఉన్మాదిగా టోకెన్లను వినియోగిస్తోంది. మరి మీరు? మీరు మీ ఫోన్‌ను స్క్రోల్ చేస్తున్నారు మరియు మీరు చాలా సమర్థవంతంగా ఉన్నారని అనుకుంటున్నారు. నిజం ఏమిటంటే: మీరు డబ్బుతో 'నకిలీ సామర్థ్యాన్ని' కొనుగోలు చేస్తున్నారు, మీరు తరువాత నిర్వహించలేని కోడ్‌ను ఉత్పత్తి చేస్తున్నారు.

మరింత వృత్తిపరంగా చెప్పాలంటే, ఇక్కడ రెండు పొరల నష్టం ఉంది:

• ఖర్చు పొర: ఇన్‌పుట్ టోకెన్లు పెద్దవిగా మారతాయి, పునరావృత్తుల సంఖ్య పెరుగుతుంది మరియు ఖర్చులు సరళంగా పెరుగుతాయి

• ఇంజనీరింగ్ పొర: మీరు సందర్భం మరియు నిర్ణయాధికారాన్ని కోల్పోతారు మరియు చివరికి 'పని చేస్తే చాలు' అనే అనియంత్రిత వ్యవస్థతో మిగిలిపోతారు

సోమరితనం రెండు: ప్రతిదీ కలిపి విసిరేయడం రకం

మీరు బగ్‌ను ఎదుర్కొన్నప్పుడు, మీరు దానిని AIకి ఎలా విసిరేస్తారు? మీరు నేరుగా మొత్తం ఎర్రర్ కన్సోల్‌ను Ctrl+A కాపీ చేస్తారా లేదా AI స్వయంగా కనుగొనడానికి నేరుగా @Codebaseని ఉపయోగిస్తారా?

దీనిని 'ప్రతిదీ కలిపి విసిరేయడం' అంటారు. మీరు సమస్య యొక్క ప్రధాన భాగాన్ని గుర్తించడానికి ఇష్టపడరు మరియు మీరు కీలకమైన కోడ్ స్నిప్పెట్‌లను ఫిల్టర్ చేయడానికి ఇష్టపడరు. మీరు 99% చెల్లని సమాచారాన్ని (శబ్దం) మరియు 1% చెల్లుబాటు అయ్యే సమాచారాన్ని (సిగ్నల్) AIకి విసిరేస్తారు.

AI ఒక యాంప్లిఫైయర్ లాంటిది.

• మీరు అతనికి స్పష్టమైన తర్కాన్ని (సిగ్నల్) ఇస్తే, అది మీ జ్ఞానాన్ని విస్తరిస్తుంది, తక్కువ టోకెన్లు ఉపయోగించబడతాయి మరియు ప్రభావం బాగుంటుంది.

• మీరు అతనికి గందరగోళం మరియు అస్పష్టతను ఇస్తే, అది మీ గందరగోళాన్ని విస్తరిస్తుంది, టోకెన్లు పెరుగుతాయి మరియు చెత్త ఉత్పత్తి అవుతుంది.

III. పరిష్కారం: AIని సమర్థవంతంగా ఎలా ఉపయోగించాలి మరియు టోకెన్ వినియోగాన్ని ఎలా తగ్గించాలి

మీ వాలెట్‌ను రక్షించాలనుకుంటే, మీ ఇంజనీరింగ్ నియంత్రణను రక్షించడం చాలా ముఖ్యం, మనం AIతో సహకరించే విధానాన్ని మార్చాలి.

1. కనీస సందర్భ సూత్రం

ఇది AI ప్రోగ్రామింగ్ యొక్క మొదటి సూత్రం. ప్రస్తుత సమస్యను పరిష్కరించడానికి AIకి ఎల్లప్పుడూ కనీస కోడ్ సెట్‌ను మాత్రమే ఇవ్వండి.

Cursorలో, ఈ ఆపరేటర్‌లను బాగా ఉపయోగించండి:

• @File: మొత్తం ఫోల్డర్‌ను కాకుండా సంబంధిత ఫైల్‌లను మాత్రమే సూచించండి.

• Ctrl+L** కోడ్‌ను ఎంచుకోండి**: మొత్తం ఫైల్‌ను కాకుండా కర్సర్ ఎంచుకున్న 50 లైన్ల కోడ్‌ను మాత్రమే చాట్‌కు పంపండి.

• @Docs: మూడవ పార్టీ లైబ్రరీల కోసం, ఊహించమని చెప్పడానికి బదులుగా డాక్యుమెంటేషన్‌ను సూచించండి.

ఇది నేను తరచుగా ఉపయోగించే నిర్మాణాత్మకమైన, పునర్వినియోగపరచదగిన SOP (మీరు దీన్ని అనుసరిస్తే, టోకెన్లు కంటికి కనిపించే విధంగా తగ్గుతాయి):

ఈ మాటల అర్థం ఏమిటంటే: AIతో సహకరించేటప్పుడు, సామర్థ్యం మరియు ఖచ్చితత్వంపై శ్రద్ధ వహించండి. నిర్దిష్ట పద్ధతులు క్రింది విధంగా ఉన్నాయి:

• ముందుగా లక్ష్యాన్ని స్పష్టం చేయండి: AI స్వయంగా ఊహించకుండా, ప్రస్తుత సమస్య మరియు కావలసిన ఫలితాన్ని సంక్షిప్తంగా చెప్పండి.

• సమస్య పునరుత్పత్తిని క్రమబద్ధీకరించండి: సమస్యను పునరుత్పత్తి చేయడానికి సులభమైన పద్ధతిని ఉపయోగించగలిగితే, సంక్లిష్టమైన పద్ధతిని ఉపయోగించవద్దు మరియు కనీస మరియు కీలకమైన కోడ్‌ను అతికించండి, సంబంధం లేని కంటెంట్‌ను పేరుకుపోకండి.

• కనీస అవసరమైన సమాచారాన్ని అందించండి: సంబంధిత 1-3 ఫైల్‌లు, కీలకమైన విధులు మరియు ఎర్రర్ స్టాక్ యొక్క మొదటి కొన్ని లైన్‌లను మాత్రమే ఇవ్వండి, పూర్తి సమాచారాన్ని ఇవ్వకండి.

• సవరణ పాయింట్‌లను తిరిగి ఇవ్వమని అభ్యర్థించండి: AI ఎక్కడ మార్చాలి, ఎందుకు మార్చాలి అని మాత్రమే చెప్పమని అడగండి, మొత్తం కోడ్‌ను పెద్ద ఎత్తున తిరిగి వ్రాయమని అడగకండి.

• చివరగా మీరే తనిఖీ చేయండి: మార్పు ఇతర ప్రాంతాలను ప్రభావితం చేయదని నిర్ధారించుకోవడానికి సరళమైన ధ్రువీకరణ చేయండి.

సంక్షిప్తంగా చెప్పాలంటే, AI పని చేయడానికి కనీస మరియు కీలకమైన సమాచారాన్ని ఉపయోగించండి మరియు తుది నియంత్రణ మరియు తీర్పును నిలుపుకోండి.

2. చాలా ముఖ్యమైనది: ప్రాంప్ట్ చేయడానికి ముందు ఆలోచించండి, చర్య తీసుకునే ముందు ప్లాన్ చేయండి

ఎంటర్ నొక్కడానికి ముందు, మిమ్మల్ని మీరు 10 సెకన్ల పాటు ఆపి, మూడు ప్రశ్నలు అడగండి:

• నేను ఏమి పరిష్కరిస్తున్నాను? (సరిహద్దులను నిర్వచించండి)

• ఈ సమస్యలో ఏ కోర్ మాడ్యూల్స్ ఉన్నాయి? (సందర్భాన్ని ఫిల్టర్ చేయండి)

• నేను స్వయంగా వ్రాస్తే, నేను ఎలా వ్రాస్తాను? (ఆలోచనలను అందించండి)

మీరు 1, AI వెనుక 0. 1 నిలబడకపోతే, వెనుక ఉన్న 0లు ఎంత ఎక్కువగా ఉన్నా, అది అర్థంలేని వినియోగం మాత్రమే.

కొన్ని హృదయపూర్వక మాటలు

'రోజుకు ఒక వంద మిలియన్ టోకెన్లు' కథ ప్రతి ఒక్కరి విషయంలో జరగకపోవచ్చు. కానీ టోకెన్లను వృథా చేసే ప్రవర్తనను AI ప్రోగ్రామింగ్‌ను ఉపయోగించే దాదాపు ప్రతి ప్రోగ్రామర్ అనుభవించి ఉంటాడు.

AI ప్రోగ్రామింగ్‌ను సులభతరం చేసినప్పటికీ, ఇప్పటికీ ఒక పరిమితి ఉంది. నిజంగా ఉపయోగించగల వ్యక్తులు మాత్రమే ప్రయోజనం పొందుతారు.

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