Claude Code के 4 token टूल टेस्ट किए, एक ने बिल बढ़ा दिया

जुलाई 2026 में JetBrains ने करीब $320 का API क्रेडिट खर्च किया — 425 बिल किए गए ट्रायल — rtk को परखने के लिए, वह shell proxy जिसे हज़ारों डेवलपर Claude Code में token बचाने के लिए इंस्टॉल करते हैं। नतीजा: सेशन प्रति टास्क 7.6% महँगे निकले। दो हफ़्ते पहले उसी टीम ने caveman को मापा था, वह skill जो 65% token काटने का दावा करती है, और 8.5% मिला। मेरी अपनी मशीन पर rtk gain 25,599 कमांड पर 11.6 मिलियन token बचत दिखाता है।

दोनों आँकड़े सही हैं। बस वे एक ही चीज़ नहीं नापते: एक पूरी हुई टास्क की लागत है, दूसरा bash आउटपुट के bytes।

आँकड़ा	यह क्या नापता है	स्रोत
+7.6% प्रति टास्क (p=0.004)	rtk इंस्टॉल होने पर एक टास्क की एंड-टू-एंड लागत	JetBrains, 425 ट्रायल, ~$320
आउटपुट token का 8.5%	एजेंटिक काम में caveman की मापी गई बचत	JetBrains, 82 युग्मित टास्क
65%	caveman की घोषित बचत	caveman README
11.6M बचत (41.6%)	rtk द्वारा संपीड़ित bash आउटपुट bytes	rtk gain, 25,599 कमांड

यह रही चार टूल की स्टैक: graphify, rtk, Superpowers और caveman — 2026-09-02 को इनके कुल 575,612 GitHub स्टार। हर एक बिल के अलग हिस्से को छूता है।

टूल	स्टार (2026-09-02)	भाषा	लाइसेंस
Superpowers	280,792	Markdown skills	MIT
graphify	113,946	Python	Apache-2.0
caveman	102,548	Go	MIT (skill)
rtk	78,326	Rust	Apache-2.0

Claude Code के बिल के दो पहलू हैं। इनपुट token वह सब है जो मॉडल पढ़ता है: हर shell कमांड का आउटपुट, आपका prompt, सिस्टम prompt, और हर कॉल पर दोबारा भेजा गया पूरा बातचीत का इतिहास। आउटपुट token वह सब है जो मॉडल लिखता है।

rtk का अपना दस्तावेज़ ठीक यही पेड़ बनाता है, और एक वाक्य जोड़ता है जो उसकी लॉन्च पोस्ट में कभी नहीं था: "जो कमांड 90% कम आउटपुट bytes दिखाता है, वह आपके सेशन को 90% सस्ता नहीं बनाता।"

JetBrains ने पढ़ने वाले हिस्से को गिना — 83 बेसलाइन सेशन दोबारा चलाकर, 1.9 मिलियन अक्षर टूल आउटपुट।

मॉडल जो पढ़ता है उसका हिस्सा	अक्षर	अनुपात
shell आउटपुट जिसे rtk संपीड़ित कर सकता है	373,339	19.7%
shell आउटपुट जिसके लिए rtk के पास नियम नहीं	879,326	46.3%
फ़ाइल पढ़ने और खोजने वाले टूल जो rtk से बचकर निकलते हैं	646,613	34.0%

मॉडल जो पढ़ता है उसका सिर्फ़ पाँचवाँ हिस्सा shell proxy से संपीड़ित हो सकता है — Claude Code के बिल्ट-इन Read, Grep और Glob कभी Bash hook से नहीं गुज़रते।

इससे चारों टूल का नक्शा बनता है: graphify घटाता है कि एजेंट क्या पढ़े, rtk घटाता है कि shell क्या लौटाए, Superpowers घटाता है कि हर टास्क कितना इतिहास ढोए और तय करता है कि कौन सा मॉडल उसे ढोए, और caveman घटाता है कि एजेंट क्या कहे। पढ़ना बिल का बड़ा आधा हिस्सा है, तो रैंकिंग वहीं से शुरू होती है।

graphify एक skill है जो किसी codebase को — उसके docs, SQL schema, config और PDF समेत — एक क्वेरी करने योग्य knowledge graph में बदल देती है। आप Claude Code, Cursor, Codex या Gemini CLI में /graphify . टाइप करते हैं, प्रोजेक्ट एक बार मैप हो जाता है, और उसके बाद एजेंट फ़ाइलें grep करने के बजाय graph से पूछता है।

कोड tree-sitter AST से लोकल पार्स होता है, करीब 40 भाषाओं में: नियतात्मक, कोई LLM कॉल नहीं, कुछ भी मशीन से बाहर नहीं जाता। बिल्ड की LLM क्रेडिट लागत शून्य है। यह तीन फ़ाइलें बनाती है: क्लिक करके देखने लायक graph.html, GRAPH_REPORT.md, और graph.json — graph खुद, जिसे आपकी फ़ाइलें दोबारा पढ़े बिना क्वेरी किया जा सकता है। हर नोड एक कॉन्सेप्ट है (एक फ़ाइल, एक फ़ंक्शन, एक क्लास), और हर edge पर टैग है — EXTRACTED जब वह सोर्स में स्पष्ट था, INFERRED जब graphify ने उसे हल किया। नोड्स Leiden एल्गोरिदम से सब-सिस्टम में समूहित होते हैं।

अपने ही एक प्रोजेक्ट पर चलाया गया बिल्ट-इन बेंचमार्क:

मापदंड	मान
नोड्स	34,031
Edges	56,865
पहचानी गई कम्युनिटी	967
Edge की उत्पत्ति	76% EXTRACTED · 24% INFERRED
पूरे corpus की सीधी पढ़ाई	1,701,550 शब्द ≈ 2,268,733 token
औसत graph क्वेरी	~24,702 token
कमी	प्रति क्वेरी 91.8× कम token

सवाल-दर-सवाल फ़र्क बड़ा है: "what is the main entry point" पर 679.1×, "what connects the data layer to the api" पर 34.0×।

दो सीमाएँ। यह तुलना "सब कुछ पढ़ने" से है, और grep-आधारित सेशन कभी इतना महँगा था ही नहीं, इसलिए असली फ़ायदा कम है। और graph पुराना पड़ जाता है — graphify update <path>, --watch या git hooks से ताज़ा रखें — जबकि docs, PDF और images पर semantic पास सचमुच मॉडल को कॉल करता है और सचमुच token खर्च करता है।

इंस्टॉल: uv tool install graphifyy (पैकेज नाम में दो y हैं), फिर graphify install।

rtk Claude Code और आपके shell के बीच एक CLI proxy है। ls, cat या git status जैसे सामान्य कमांड बहुत शोर लौटाते हैं जिसे एजेंट को इनपुट token के रूप में पढ़ना पड़ता है: फ़ाइल परमिशन, प्रोग्रेस बार, सौ पास होते टेस्ट। rtk वही कमांड चलाता है और एक संक्षिप्त संस्करण लौटाता है: एक Rust बाइनरी, 100+ समर्थित कमांड, 10 ms से कम ओवरहेड। एक PreToolUse hook हर योग्य Bash कॉल को चलने से पहले फिर से लिखता है (git status → rtk git status), इसलिए एजेंट को याद रखने की ज़रूरत ही नहीं।

लेखक की लॉन्च पोस्ट में दो हफ़्तों में 10.2M token बचत, 89.2% का दावा था, और उदाहरण जैसे cargo test का 155 लाइन से 3 लाइन हो जाना। 25,599 कमांड के बाद हमारा अपना डैशबोर्ड:

कमांड	कॉल	बचे token	दर
rtk find	354	2.2M	46.6%
rtk read	3,504	2.2M	10.4%
rtk grep	2,760	1.9M	47.7%
rtk ps aux	24	1.1M	98.0%
rtk diff	39	541.1K	92.2%
कुल	25,599	11.6M	41.6%

अब मुकदमा। JetBrains ने rtk को जैसा वह आता है वैसा ही इंस्टॉल किया और claude-sonnet-5 पर 86 टास्क दो बार चलाए।

JetBrains का निष्कर्ष	मान
shell कमांड जिन्हें rtk दोबारा लिख सकता है	1,056 में से 349 (3 में 1)
कुल बचत की अधिकतम सीमा	बिल का ~3%
प्रति टास्क लागत, कम reasoning effort	+7.6% (p=0.004)
प्रति टास्क turns	+13.8% (p=0.03)
प्रति टास्क लागत, उच्च effort	±0%
टास्क की गुणवत्ता	अपरिवर्तित

rtk का README अब साफ़ कहता है: bash आउटपुट का 90% तक, "जो आपके बिल को 90% काटने जैसा नहीं है", और उसके अपने आँकड़े bytes / 4 से अनुमानित हैं।

फ़ैसला: यह मुफ़्त है, संपीड़न असली है और JetBrains के शब्दों में "अक्सर सुरुचिपूर्ण"। bash-भारी सेशन के लिए रखें; बिल हिलाने की उम्मीद न करें।

Superpowers Jesse Vincent का Claude Code plugin है — 280,792 स्टार, चौदह skills, एक ही इंस्टॉल कमांड (/plugin install superpowers@claude-plugins-official)। यह कुछ भी संपीड़ित किए बिना token बचाता है।

सब कुछ brainstorming skill से शुरू होता है, जो एक कड़े गेट से खुलती है: कोई कोड नहीं, कोई scaffolding नहीं, कोई implementation skill नहीं जब तक एक स्पष्ट मंशा मंज़ूर न हो जाए। skill लोड होते ही एजेंट brainstorming साथी बन जाता है, और व्यवहार में कुछ भी बनाने से पहले प्रोजेक्ट के हिस्से दोबारा सोचे जाते हैं। यही सबसे अहम चरण है, क्योंकि सबसे महँगे token वही हैं जो ग़लत चीज़ बनाने में लगते हैं।

skill काम को spike, सीमित बदलाव या आर्किटेक्चरल बदलाव में बाँटती है, और नियम फ़ाइल में लिखा है: "दो रास्तों में संदेह हो तो भारी वाला लो।" वह विफलता का तरीक़ा भी नाम से बताती है — "Too Simple To Need Approval" नाम का anti-pattern सेक्शन। आर्किटेक्चरल रास्ता एक spec देता है जिसे आप मंज़ूर करते हैं, फिर एक implementation plan।

भरोसेमंदी plan से आती है। writing-plans skill काम को एक-एक क्रिया के चरणों में काटती है, 2 से 5 मिनट के: फ़ेल होने वाला टेस्ट लिखो, चलाकर फ़ेल होना पक्का करो, न्यूनतम कोड लिखो जो पास कराए, टेस्ट दोबारा चलाओ, commit करो। plan इस मान्यता पर लिखे जाते हैं कि इंजीनियर के पास शून्य संदर्भ है। इतना छोटा टास्क एक ताज़ा context window में गुंजाइश समेत समा जाता है, इसलिए एजेंट कभी संतृप्त window के साथ टास्क के अंत तक नहीं पहुँचता — और संतृप्त window से ही मनगढ़ंत कोड निकलता है।

सीमा है औपचारिकता। फ़ाइल कहती है कि यह टास्क के साथ घटती-बढ़ती है, पर गेट एक-लाइन के फ़िक्स पर भी चलता है, और वह भी token है।

फिर plan चलता है, और token का गणित बदल जाता है। एक टास्क, एक subagent। हर subagent ताज़ा context से शुरू होता है जिसमें सिर्फ़ उसका टास्क होता है, सेशन का इतिहास कभी नहीं — इसलिए orchestrator की window छोटी रहती है और subagent की साफ़। हर टास्क के बाद orchestrator नतीजा जाँचता है: ठीक है, अगला टास्क; ठीक नहीं, सुधार किसी subagent के पास वापस। प्रति टास्क अधिकतम पाँच राउंड — राउंड 1 से 3 मूल implementer को ही जारी रखते हैं, राउंड 4 काम एक नए implementer को ज़्यादा सक्षम मॉडल पर देता है, राउंड 5 में orchestrator खुद फ़ैसला करता है।

जो नियम सब कुछ चुकाता है वह है मॉडल चयन: "लागत बचाने के लिए हर भूमिका के लिए सबसे कम शक्तिशाली सक्षम मॉडल इस्तेमाल करो।" orchestrator हर टास्क की कठिनाई आँकता है और उसी के हिसाब का मॉडल चुनता है।

टास्क का प्रकार	मॉडल स्तर
यांत्रिक, अच्छी तरह निर्दिष्ट; plan में कोड पहले से मौजूद	सबसे सस्ता / छोटा मॉडल
कई फ़ाइलों का समन्वय, डिबगिंग	मानक मॉडल
आर्किटेक्चर, अंतिम branch समीक्षा	सबसे सक्षम मॉडल
मॉडल न बताया गया हो	सेशन का मॉडल विरासत में लेता है

उसी फ़ाइल की एक बारीकी: "turn की गिनती token की क़ीमत पर भारी पड़ती है।" जो सस्ता मॉडल तीन turn लेता है वह सस्ता नहीं है। व्यवहार में यही Opus और Fable को $20 के Pro प्लान पर इस्तेमाल लायक बनाता है — महँगा मॉडल पूरे सेशन के बजाय मुट्ठी भर टास्क छूता है।

आख़िरी फ़ायदा दस्तावेज़ीकरण है। हर spec और plan एक markdown फ़ाइल है जो docs/superpowers/specs/ और docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md में सहेजी जाती है और काम के अंत में commit होती है। इस चैनल की अपनी pipeline में, हमारे मौजूदा वीडियो इंजन पर migration एक spec और चौदह टास्क का plan है, जिसे आज भी खोला, नए सेशन में हवाला दिया और आगे बढ़ाया जा सकता है। एजेंटों ने जो किया, उसमें से कुछ भी बिना रिकॉर्ड नहीं है।

आख़िरी हिस्सा है कि एजेंट क्या कहता है। एजेंट सुनाते हैं — "ज़रूर", "मदद करके खुशी होगी", "आप जो समस्या देख रहे हैं वह शायद इस वजह से है" — और यह बेकार के आउटपुट token हैं।

caveman Julius Brussee की skill है, 102,548 स्टार, जो एजेंट को गुफ़ा-मानव की तरह बुलवाती है: articles, भराव, शिष्टाचार और हिचक हटाओ, और पैटर्न मानो [चीज़] [क्रिया] [कारण]. [अगला क़दम]. कोड, कमांड, फ़ाइल पथ और सटीक एरर संदेश कभी नहीं बदले जाते; सिर्फ़ आसपास का गद्य बदलता है। इसके तीन स्तर हैं (/caveman lite|full|ultra) और एक SessionStart hook जो इसे शुरुआत में ही चालू कर देता है।

इसकी अपनी तालिका, Claude API से दस prompt: बिना skill औसतन 1,214 आउटपुट token, skill के साथ 294 — 65%, सबसे अच्छा मामला 87% और सबसे ख़राब 22%।

README खुद ही हक़ीक़त बता देता है: skill सिर्फ़ आउटपुट छोटा करती है, इनपुट और reasoning token नहीं बदलते, और उसके अपने नियम हर turn पर करीब 1–1.5k इनपुट token लेते हैं। JetBrains ने इसे 82 युग्मित एजेंटिक टास्क पर, करीब $106 के क्रेडिट में मापा।

caveman	घोषित	मापा गया (JetBrains)
आउटपुट token की बचत	65%	8.5% (592k → 542k)
गुणवत्ता पर असर	—	कोई पकड़ में आने वाली गिरावट नहीं (sign test p=0.82)

अंतर संरचनात्मक है: एजेंट का आउटपुट ज़्यादातर कोड और tool कॉल होता है, जिन्हें caveman सही ही छोड़ देती है। JetBrains की सिफ़ारिश: "पसंद हो तो इस्तेमाल करो। यह मज़ेदार है, और गुणवत्ता में मापने लायक कुछ नहीं ले जाती।"

Claude Code v2.1.237 से एक बिल्ट-इन विकल्प है, Concise output style: Claude "नतीजे से शुरू करता है, भूमिका और कथन छोड़ देता है, और जवाब डिफ़ॉल्ट रूप से छोटे रखता है।" इसे /config → Output style में चुनें; यह .claude/settings.local.json में सहेजा जाता है और /clear या नए सेशन के बाद असर करता है। दोनों की एक साझा सीमा: output style सिर्फ़ मुख्य बातचीत पर लागू होते हैं — subagent अपना ही सिस्टम prompt चलाता है।

रैंकिंग इस आधार पर कि हर टूल असल में क्या हिलाता है, और उसकी क़ीमत क्या है।

क्रम	टूल	क्या हिलाता है	मापा गया असर	क़ीमत
1	Superpowers	प्रति टास्क इतिहास + कौन सा मॉडल उसे पढ़े	महँगा मॉडल पूरे सेशन के बजाय मुट्ठी भर टास्क पर	हर टास्क पर गेट, एक-लाइन फ़िक्स पर भी
2	graphify	एजेंट क्या पढ़े	पूरे corpus की सीधी पढ़ाई की तुलना में प्रति क्वेरी 91.8× कम token (हमारा प्रोजेक्ट)	graph पुराना पड़ता है; semantic पास token खर्च करता है
3	rtk	bash आउटपुट bytes	अधिकतम बिल का ~3%; JetBrains टेस्ट में कम effort पर प्रति टास्क +7.6%	3 में सिर्फ़ 1 shell कमांड के लिए नियम है
4	caveman / Concise	एजेंट जो गद्य लिखता है	आउटपुट token का 8.5%, गुणवत्ता में नुक़सान नहीं	हर turn पर ~1–1.5k इनपुट token

Superpowers जीतता है, और किसी संपीड़न की वजह से नहीं: प्रति टास्क ताज़ा context और काम कर सकने वाला सबसे सस्ता मॉडल यह बदल देते हैं कि क्या पढ़ा जाए और कौन पढ़े। graphify दूसरा है क्योंकि कम पढ़ना बिल का बड़ा आधा हिस्सा है। rtk असली, मुफ़्त और हानिरहित है, पर दो-तिहाई shell कमांड और हर फ़ाइल पढ़ाई उससे बचकर निकल जाती है। caveman, या Claude Code में अब आने वाला Concise style, सबसे छोटा हिस्सा छाँटता है।

चारों इंस्टॉल करने के लिए मुफ़्त हैं — graphify और rtk Apache-2.0 पर, Superpowers MIT पर, caveman skill MIT पर। 570,000 से ज़्यादा स्टार कहते हैं कि लोग चमत्कार चाहते हैं। ईमानदार जवाब एक रैंकिंग है।