मैंने कैसे Codex टोकन्स को प्रतिदिन 245M से घटाकर 28M किया (समान गति के साथ)

कोडेक्स प्रोमो खत्म होने और वास्तविक कोटा लागू होने के बाद, मैंने अपने दैनिक कोडेक्स बर्न लिमिट को तेज़ी से देखा।

इसलिए मैंने एक सिस्टम ढूंढा जो मेरे द्वारा खर्च किए जाने वाले टोकन की मात्रा को कम करता है, बिना गति को प्रभावित किए।

एक दिन: 245 मिलियन टोकन

अगले दिन, मेरे सिस्टम को लॉक करने के बाद: 28 मिलियन टोकन

यहाँ वास्तव में मैंने क्या बदला:

चरण 1: कच्चा डेटा कभी न खिलाएँ, पहले उसे कम्पैक्ट करें

कोडेक्स को आपके 40MB ट्रेड लॉग, बड़े JSON मार्केट डंप या पूरे रेपो की हर बार ज़रूरत नहीं होती। अब मैं इसे एक बार के हेल्पर स्क्रिप्ट बनाने के लिए कहता हूँ जो "नीडल मैप्स" बनाते हैं:

• compact_logs.py → टाइमस्टैम्प/सिंबल/कीवर्ड के आधार पर फ़िल्टर करता है और केवल शीर्ष N असामान्यताएँ निकालता है
• summarize_data.py → प्रासंगिक कॉलम, पंक्ति गणना, नमूने और मुख्य आँकड़े निकालता है
• repo_map.py → एंट्री पॉइंट्स, कॉन्फ़िग, मुख्य फ़्लो का साफ़ अवलोकन बनाता है (venv, node_modules, builds आदि को छोड़कर)

200-500 टोकन डिस्टिल्ड इनसाइट खिलाएँ, 10k+ शोर के बजाय।

एक बार बनाएँ, हमेशा पुन: उपयोग करें।

चरण 2: हर कमांड आउटपुट को आक्रामक रूप से सीमित करें

डिफ़ॉल्ट आउटपुट घातक है:

• git status
• ls -la
• cat file
• python script.py

तुरंत कॉन्टेक्स्ट को फुला सकता है।

अब मैं हर निर्देश में सीमाएँ बेक करता हूँ:

1head -n 50, tail -n 50, grep "ERROR" | head -n 30
2
3पूर्ण परिणाम अस्थायी फ़ाइलों में लिखें और केवल रेंज का निरीक्षण करें
4
5हर जगह --limit 100 फ़्लैग जोड़ें

चरण 3: एक लिविंग हैंडऑफ़ फ़ाइल बनाएँ (आपका प्रोजेक्ट ब्रेन)

एजेंटों को हर सत्र में सब कुछ फिर से खोजने न दें।

मैं एक टाइट HANDOFF.md (1k टोकन से कम) रखता हूँ जिसमें होता है:

• वर्तमान लक्ष्य + सफलता मीट्रिक्स
• प्रमुख फ़ाइलें और हाल के निर्णय
• पहले से चलाए गए कमांड + परिणाम
• ज्ञात समस्याएँ और "दोबारा न पढ़ें" सूची
• अगले कदम

हर सत्र को इससे समाप्त करें: "वर्तमान निष्कर्षों को HANDOFF.md में कॉम्पैक्ट करें, डेड एंड्स हटाएँ, केवल एक्शनेबल तथ्य रखें।"

चरण 4: स्पष्ट "न करें" निर्देश बड़ी मात्रा में टोकन बचाते हैं

एजेंट भटकना पसंद करते हैं, इसलिए मैं सख्त सीमाएँ निर्धारित करता हूँ:

• "node_modules, .venv, dist, logs/archive, generated files और किसी भी cache dir को छोड़ें"
• "कोई भी नई फ़ाइल खोलने से पहले सारांश बनाएँ"
• "पूरा सोर्स कभी पेस्ट न करें जब तक कि मैं स्पष्ट रूप से न कहूँ"
• "केवल इस कार्य के लिए आवश्यक फ़ाइलों का निरीक्षण करें"

इन्हें अपने AGENTS.md में एक बार डालें और देखें कि री-रीड्स कैसे गिरते हैं।

चरण 5: सारांश, डिफ और स्निपेट की माँग करें

खराब प्रॉम्प्ट:

1इस फ़ाइल को पढ़ें और समझाएँ।

अच्छा प्रॉम्प्ट:

1रिस्क इंजन के पोज़िशन साइज़िंग लॉजिक का पता लगाएँ। केवल वह फ़ंक्शन + उसके ऊपर/नीचे 3 लाइनें दिखाएँ। एज केस को एक पैराग्राफ में समझाएँ।

या

11-पेज का रेपो मैप बनाएँ: एंट्री पॉइंट्स, कॉन्फ़िग, मुख्य डेटा फ़्लो और बैकटेस्ट कमांड। वेंडर डायरेक्टरीज़ को छोड़ें।

लक्षित अनुरोध = छोटे कॉन्टेक्स्ट विंडो

चरण 6: कोडेक्स को समय-समय पर अपने कॉन्टेक्स्ट को कॉम्पैक्ट करने दें

हर 4-5 बार मैं डालता हूँ:

1हमारी प्रगति को एक टाइट हैंडऑफ़ नोट में सारांशित करें। पुनरावृत्तियों और असफल रास्तों को हटाएँ। केवल वही रखें जो जारी रखने के लिए आवश्यक है।

बातचीत बढ़ने पर भी दुबली बनी रहती है।

चरण 7: वर्बोसिटी को डिफ़ॉल्ट रूप से मारें

1संक्षिप्त रहें। केवल पैच + एक वाक्य कारण आउटपुट करें। योजना को फिर से न बताएं जब तक कि वह बदली न हो। कोई फ़ालतू नहीं।

यह एक नियम अकेले आउटपुट टोकन को काफी कम कर देता है।

उपयोगी कमांड और हेल्पर स्क्रिप्ट जो मैं दैनिक उपयोग करता हूँ

ये सटीक वन-लाइनर्स और स्क्रिप्ट हैं जिन्हें मैं कॉपी-पेस्ट करता हूँ या कोडेक्स से किसी भी प्रोजेक्ट के पहले दिन जनरेट करवाता हूँ।

मुख्य सीमित कमांड जो मैं हर टूल कॉल पर लागू करता हूँ:

1# Safe file inspection
2head -n 80 somefile.py | cat
3tail -n 80 somefile.py | cat
4grep -n "KEYWORD" file.py | head -n 40
5
6# Git without the firehose
7git status --porcelain | head -n 30
8git log --oneline -15
9git diff --name-only | head -n 20
10
11# Data & logs (trading-specific)
12tail -n 200 market_log.json | jq '.[-50:]' | head -n 100
13python -c "import pandas as pd; df = pd.read_csv('trades.csv'); print(df.head(20).to_string())" | head -n 150
14
15# Write-then-inspect pattern
16python analyze_backtest.py > temp_results.txt 2>&1
17head -c 8000 temp_results.txt   # byte cap for safety

**

हेल्पर स्क्रिप्ट जो मैं हमेशा कोडेक्स से पहले बनाने को कहता हूँ (फिर उन्हें खुद चलाता हूँ):**

• compact_logs.py → python compact_logs.py --symbol BTC --hours 24 > summary.txt
• repo_map.py → python repo_map.py > HANDOFF.md (ब्रेन फ़ाइल अपडेट करता है)
• scan_errors.py → python scan_errors.py --limit 30 > errors.txt
• summarize_json.py → python summarize_json.py market_snapshot.json > needle.txt

एक किलर AGENTS.md नियम जो मैं जीता हूँ (अज्ञात सब कुछ बाइट-कैप करें):

1## Command Output Protection
2Any command with unknown or potentially large output MUST be byte-capped.
3Default: COMMAND 2>&1 | head -c 6000
4If more is needed, write to temp file and I will inspect ranges only.

डेटा-हैवी कार्यों के लिए मैं प्रॉम्प्ट टेम्पलेट पुन: उपयोग करता हूँ:

1पहले compact_logs.py या summarize_data.py चलाकर <500-टोकन का नीडल मैप बनाएँ। फिर केवल उसका विश्लेषण करें। कच्ची फ़ाइल को सीधे कभी न पढ़ें।

ये कमांड और स्क्रिप्ट अकेले मेरे दैनिक बर्न को बड़े वर्कफ़्लो बदलावों के ऊपर 30-40% और कम कर देते हैं।

मेरा नया नियम

कोडेक्स को कच्चा डेटा न पढ़ने दें, अगर 50-लाइन का सारांश पर्याप्त हो

पहले सप्ताह में बनाए गए हेल्पर हर घंटे अपनी लागत वसूल कर लेते हैं।

टोकन दक्षता कोई मॉडल समस्या नहीं थी, बल्कि यह एक सिस्टम समस्या है। बस कॉन्टेक्स्ट अनुशासन को पकड़ें और आप उसी कोटा के अंदर 8-10x ज्यादा काम करेंगे।

मैंने www.RedLeads.app भी बनाया है ताकि मैं उन चीज़ों के लिए उपयोगकर्ता ढूंढ सकूँ जो मैं शिप करता हूँ। मेरे साथ $10k MRR तक स्पीडरन में शामिल हों, vibecoding कूल सिस्टम और टूल्स के साथ।

धन्यवाद :)