बेहतर प्रदर्शन के लिए Claude Code के 12 टिप्स

वही Claude Code अलग-अलग लोगों के इस्तेमाल करने पर बिल्कुल अलग नतीजे देता है।

कुछ लोग अपनी 5 घंटे की लिमिट जल्दी खत्म कर देते हैं, जबकि कुछ को यह काफी लगती है।

--> फर्क सिर्फ सेटिंग्स और आदतों का है।

⭐️ ये रहे Claude Code के 12 सही टिप्स। ⭐️

सभी कमांड्स और प्रॉम्प्ट्स यहाँ दिए गए हैं ताकि आप उन्हें सीधे कॉपी-पेस्ट कर सकें।

--> एक बार में पूरा पढ़ने के लिए यह थोड़ा लंबा है... क्यों न पहले इसे बुकमार्क कर लें???

⚠️ शुरू करने से पहले.. अपना वर्ज़न चेक करें ⚠️

इस आर्टिकल में बताए गए ज़्यादातर फीचर्स पिछले कुछ महीनों में रिलीज़ हुए हैं। अगर आपका वर्ज़न पुराना है, तो कमांड्स काम नहीं करेंगे।

टर्मिनल में claude --version से चेक करें, और अगर वर्ज़न पुराना है तो बस claude update चला दें।

इस आर्टिकल के कमांड्स 18 अक्टूबर तक के v2.1.302 पर आधारित हैं।

1. हर Sub-agent के लिए अलग Effort सेट करें

Effort तय करता है कि Claude जवाब देने से पहले कितनी गहराई से सोचेगा। विकल्पों में low, medium, high, xhigh और max शामिल हैं, हालाँकि उपलब्ध स्टेप्स मॉडल के हिसाब से थोड़े अलग हो सकते हैं।

कई लोग बिना सोचे-समझे इसे Max या XHigh पर सेट कर देते हैं, यह मानकर कि जितना ज़्यादा उतना बेहतर।

लेकिन यह हमेशा सच नहीं होता।

तुलना के लिए जब वही ऐप बनाया गया, तो Max में 79 मिनट लगे, जबकि दूसरे efforts में सिर्फ 16 मिनट।

नतीजे लगभग एक जैसे थे। आप बस ज़्यादा समय और tokens खर्च कर रहे हैं।

मेरे अनुभव से मैंने जो निष्कर्ष निकाला है, वो ये है:

--> (मुख्य बात) 🔥 अगर आप विस्तृत (detailed) प्रॉम्प्ट्स लिख सकते हैं, तो low या max किसी का भी इस्तेमाल करें, अंतिम नतीजा अक्सर एक जैसा ही होता है। 🔥

--> ब्रेनस्टॉर्मिंग के लिए, low या medium असल में बेहतर काम करते हैं।

हालाँकि, मुश्किल डिज़ाइन, पेचीदा bugs और ज़रूरी reviews के लिए कभी-कभी ज़्यादा effort की ज़रूरत पड़ती है।

असली बात "हमेशा low रखना" नहीं है।

7 अक्टूबर से.. sub-agents को कॉल करते समय effort तय करें!

7 अक्टूबर के अपडेट (v2.1.292) से, मुख्य Claude Code अब sub-agents को कॉल करते समय effort तय कर सकता है।

अब आप इस तरह निर्देश दे सकते हैं:

मौजूदा टास्क को तीन चरणों में बाँटो और sub-agents के साथ आगे बढ़ो।

1. low effort के साथ फाइल लोकेशन ढूँढना और डेटा व्यवस्थित करना

2. medium effort के साथ बदलाव की दिशा के फायदे/नुकसान की समीक्षा करना

3. high effort के साथ अंतिम कोड की bug-finding समीक्षा करना

दिखाओ कि वास्तव में हर sub-agent को कौन सा effort दिया गया था,

और मुख्य agent के पास सिर्फ निष्कर्ष और सबूत वाली फाइल पाथ लेकर आओ।

अगर हर बार यह बताना झंझट लगता है, तो agents को फाइल के रूप में सेव कर लें।

--> उदाहरण के लिए, प्रोजेक्ट के .claude/agents/ फोल्डर में light-research.md के नाम से सेव करें।

name: light-research

description: केवल संबंधित फाइलें और सबूतों की जगह ढूँढने के लिए हल्की रिसर्च

model: haiku

effort: low

दोनों तरीके—हर कॉल पर तय करना (ऊपर वाला प्रॉम्प्ट) और फाइल के ज़रिए फिक्स करना—काम करते हैं!

2. Context मैनेजमेंट और Token की बर्बादी रोकना

🤪 Claude Code अचानक बेवकूफ जैसा बर्ताव इसलिए करता है, उसकी मुख्य वजह context है।

Context वह वर्कस्पेस है जिसे Claude एक बार में याद रखता है। बातचीत, पढ़ी गई फाइलें और कमांड के नतीजे सब यहीं जमा होते हैं।

--> आजकल Claude Code में 'डिफ़ॉल्ट' रूप से 1M (10 लाख tokens) context होता है।

समस्या तब आती है जब यह 1M पूरी तरह भर जाता है।

यह सिर्फ Claude की बात नहीं है; Codex जैसे सभी LLMs की यही आम सीमा है।

⭐️ टिप: autocompact को 500~700k पर सेट करें ⭐️

इसलिए मैं auto-compaction की सीमा को पहले खींच लेता हूँ।

/autocompact 600k

इससे auto-compaction के लिए इस्तेमाल होने वाली विंडो का आकार घटकर 600k tokens हो जाता है।

1M भरने से पहले ही, Claude बातचीत को संक्षेप में समेट लेता है और अपने आप जगह खाली कर देता है।

(डिफ़ॉल्ट पर वापस जाने के लिए `/autocompact auto` टाइप करें।)

⚠️ दूसरी बात जिसका ध्यान रखना है: Cache का खत्म होना ⚠️

अगर आप एक session को लंबे समय तक इस्तेमाल करते हैं, तो इसे ज़रूर चेक करें।

Claude Code हर रिक्वेस्ट के साथ पिछली पूरी बातचीत दोबारा भेजता है। यह तेज़ और सस्ता इसलिए है क्योंकि caching होती है—पहले से प्रोसेस किए गए हिस्सों की दोबारा गणना नहीं होती।

लेकिन यह cache हमेशा के लिए नहीं रहता।

Pro या Max सब्सक्रिप्शन (प्लान के अंदर उपयोग): मुख्य बातचीत का cache 1 घंटा
API key या अतिरिक्त usage credits: 5 मिनट
Sub-agents: सब्सक्रिप्शन होने पर भी 5 मिनट

मैंने एक बार अपनी स्क्रीन पर ~852k uncached देखा था। इस हालत में, सिर्फ एक लाइन "continue" भेजने के लिए बिना cache के ~850k tokens को फिर से प्रोसेस करना पड़ता है। Usage एकदम से बहुत तेज़ी से गिर सकता है।

आम स्थितियाँ जिनमें cache टूट जाता है:

लंबे ब्रेक के बाद कोई भारी-भरकम session फिर से शुरू करना
Session के बीच में मॉडल बदलना (cache हर मॉडल के लिए अलग होता है)
कनेक्टेड MCP tool कॉन्फ़िगरेशन बदलना

इसके उपाय आसान हैं:

काम छोड़ने से पहले सफाई करें। जब तक cache ज़िंदा है `/compact` का इस्तेमाल करें, या `/clear` से नई शुरुआत करें।
लेटेस्ट वर्ज़न पर अपडेट करें। v2.1.299 से, 200k tokens से ज़्यादा की बातचीत ~54 मिनट बेकार रहने पर, 1 घंटे का cache खत्म होने से पहले अपने आप कंप्रेस हो जाती है। आप इसे /config में Idle compaction के तहत बंद कर सकते हैं।)

3. /doctor prompt-audit से पुरानी गाइडलाइन्स की सफाई करें

पुरानी सलाह से कॉपी किया गया CLAUDE.md। हर बार गलती होने पर एक-एक करके जोड़े गए नियम।

इनमें से ज़्यादातर पुराने मॉडल्स के लिए लिखे गए थे।

नए मॉडल पुरानों की तुलना में निर्देशों को बहुत बेहतर तरीके से मानते हैं।

⚠️ इसलिए जो नियम पहले "ज़रूर!!" "कभी नहीं!!" जैसे ज़ोर देकर लिखने पड़ते थे, वे अब ज़रूरत से ज़्यादा सक्रिय हो सकते हैं। ⚠️

मौजूदा कोड या आपस में टकराने वाले नियम भी जमा हो गए हैं।

अब आप एक कमांड से यह चेक कर सकते हैं।

markdown

1/doctor prompt-audit

यह फीचर सितंबर के अंत वाले अपडेट (v2.1.283) में जोड़ा गया था।

यह क्या चेक करता है?

प्रोजेक्ट और पैरेंट फोल्डर्स में CLAUDE.md और CLAUDE.local.md, AGENTS.md
~/.claude/CLAUDE.md (मेरी निजी गाइडलाइन्स जो सभी प्रोजेक्ट्स पर लागू होती हैं)
.claude/ के अंदर के नियम, skills, कस्टम कमांड्स, sub-agent परिभाषाएँ, आउटपुट स्टाइल

यह रिपोर्ट तो देता है लेकिन plugin skills और agents के लिए सुधार नहीं सुझाता।

मानदंड आपके द्वारा अभी इस्तेमाल किए जा रहे मॉडल पर आधारित होते हैं। यह उस मॉडल के लिए पुराने प्रॉम्प्ट पैटर्न ढूँढता है और सुधार के सुझावों के साथ एक रिपोर्ट बनाता है।

(यह उन फाइलों को नहीं पढ़ता जिनमें keys हो सकती हैं, जैसे settings फाइलें या .mcp.json।)

4. जब Claude बार-बार गलतियाँ करे तो Work Environment ठीक करें

⛏️ जब AI बार-बार गड़बड़ कर रहा हो। एक ही समस्या से घंटों जूझना पड़ रहा हो। ⛏️

अगर आप तीसरी बार वही चीज़ ठीक कर रहे हैं, तो यह मॉडल की गलती नहीं है। यह work environment की गलती है।

मैं यह तरीका Claude Sonnet 3.7 से एक साल से ज़्यादा समय से इस्तेमाल कर रहा हूँ। मोटे तौर पर समझें तो..

--> AI से उस session का विश्लेषण कराएँ जिसमें वह फेल हुआ, फिर उसके कारणों को प्रोजेक्ट गाइडलाइन्स और जाँच के तरीकों में शामिल करें।

⭐️ ऐसे करें! "Session ID का इस्तेमाल करके गलतियों का विश्लेषण करें" ⭐️

1. जिस session में गलतियाँ दोहराई गईं, वहाँ `/status` टाइप करके Session ID लें। उसे कॉपी करें।

2. एक नया Claude Code session खोलें (Codex भी काम करेगा) और यह पेस्ट करें:

markdown

1"<Session ID>" → ऐसे बिंदु ढूँढो जहाँ यह Claude Code session दो या उससे ज़्यादा बार फेल हुआ।
2
3वे चीज़ें ढूँढो जिन्हें मैंने बताया लेकिन यह बार-बार गलत करता रहा, और bottlenecks भी ढूँढो।
4
5श्रेणीबद्ध करो कि ऐसा क्यों हुआ (गलत मान्यताएँ, context की कमी, कोड स्ट्रक्चर, टेस्ट्स की कमी)
6
7और दोबारा ऐसा न हो इसके लिए सिर्फ CLAUDE.md, .claude/rules, skills,
8hooks, या tests के लिए सबसे छोटा सुधार सुझाओ।

3. सुझावों की समीक्षा करें और सिर्फ अच्छे वाले लागू करें।

4. असर की जाँच करें। पहले फेल हुई रिक्वेस्ट्स दोबारा आज़माएँ और देखें कि क्या अब काम चल रहा है।

⚠️ सब कुछ CLAUDE.md में मत ठूँसिए। ⚠️

यह जितना लंबा होगा, उतना ज़्यादा context खाएगा और नियम आपस में टकराएंगे!!!

पूरे प्रोजेक्ट के नियम CLAUDE.md में
खास फोल्डर्स/फाइलों के नियम .claude/rules/ में या उस फोल्डर के अंदर CLAUDE.md में
बार-बार होने वाले काम Skills के रूप में
Hooks और permissions के ज़रिए सख्त नियम (टिप #10)
Regression tests के ज़रिए बार-बार आने वाले same bugs

बीच-बीच में टिप #3 `/doctor prompt-audit` से जमा हुए नियमों की सफाई करें। टिप #4 बनाता है, टिप #3 साफ करता है।

5. Claude-Mem से Sessions के बीच Work Memory बनाए रखें

session खत्म होते ही Claude Code बातचीत भूल जाता है।

**"पिछली बार हमने ऐसा क्यों किया था?"

"हमने उस error को कैसे ठीक किया था?"**

हर नए session में आपको सब दोबारा समझाना पड़ता है।

एक साल से लगातार मेरे इस्तेमाल में रहने वाला इकलौता Claude Code plugin इस समस्या को हल करता है।

--> claude-mem।

⭐️ इसे GitHub पर 100k से ज़्यादा stars मिल चुके हैं। ⭐️

यह basic memory से अलग कैसे है?

Claude Code में basic Auto Memory होता है। फर्क ये है:

Basic Auto Memory उन बातों और प्रोजेक्ट से मिली सीख को notes में समेटता है जिन्हें Claude ज़रूरी मानता है। इसे /memory से देखा जा सकता है, कुछ इंस्टॉल करने की ज़रूरत नहीं।

claude-mem अपने आप रिकॉर्ड करता है कि पिछले sessions में कौन से काम हुए, errors कैसे ठीक हुए, और फैसले क्यों लिए गए। यह अगले session में ज़रूरी रिकॉर्ड खुद निकाल लाता है।

मेरी स्क्रीन पर 87% तक tokens की बचत दिखी।

इंस्टॉल करने के लिए टर्मिनल में बस एक लाइन:

markdown

1npx claude-mem install

या Claude Code के अंदर plugin के रूप में इंस्टॉल करें:

markdown

1/plugin marketplace add thedotmack/claude-mem
2/plugin install claude-mem

❌ इन मामलों में इसकी सलाह नहीं ❌

आप मुख्य रूप से Codex इस्तेमाल करते हैं
आपके पास पहले से कोई और memory plugin या कस्टम handover system है

एक जैसे काम करने वाले tools जोड़ने से जटिलता और लागत दोनों बढ़ती है।

अगर आप सिर्फ Claude Code इस्तेमाल करते हैं, तो भी इसकी ज़ोरदार सिफारिश की जाती है।

6. Statusline से Model, Effort, Context और Usage एक नज़र में देखें

Claude Code चलाते समय मन में लगातार ये सवाल आते हैं:

क्या यह session Opus है? Sonnet? Haiku?
कौन सा effort सेट है?
context कितना भरा है?
5 घंटे और साप्ताहिक लिमिट में से कितना बचा है?

🔥 Statusline इन सबको टर्मिनल के नीचे दिखाता रहता है। 🔥

इसे बनाना आसान है। `/statusline` के बाद बताएँ कि आपको कैसा डिज़ाइन चाहिए, और Claude स्क्रिप्ट बनाकर लागू कर देगा।

मेरे शेयर किए गए 5 डिज़ाइन

मैंने पहले 5 कॉपी-पेस्ट statusline प्रॉम्प्ट्स शेयर किए थे।

1. Minimal: Model, effort, project, context सब एक लाइन में

2. Pastel Blocks: डार्क टर्मिनल के लिए उपयुक्त pastel हाइलाइट ब्लॉक्स

3. Nord Powerline: हिस्सों के बीच smooth arrow boundaries

4. Limit Dot Bar: Pro/Max के लिए। 5-घंटे और 7-दिन का usage, रीसेट होने का समय dot bars में

5. Vivid Gauge: Lime badge और diagonal gauge। इसमें context token count भी शामिल है

पूरे प्रॉम्प्ट्स ओरिजिनल पोस्ट्स में हैं। कॉपी-पेस्ट करें और Claude तुरंत इसे बना देगा।

1. Minimal: https://x.com/lucian__03/status/2103173295118098750

2. Pastel Blocks: https://x.com/lucian__03/status/2103173396075065594

3. Nord Powerline: https://x.com/lucian__03/status/2103173518573916178

4. Limit Dot Bar: https://x.com/lucian__03/status/2103173612832444536

5. Vivid Gauge: https://x.com/lucian__03/status/2103173754218258607

7. Claude से नतीजे सीधे Execute और Verify कराएँ

Claude कहता है "Implementation complete!" लेकिन चलाने पर फेल हो जाता है। बटन क्लिक नहीं होते, स्क्रीन टूट जाती है, या कुछ दिखता ही नहीं।

टेस्ट्स पास हो जाते हैं लेकिन ऐप्स उम्मीद से ज़्यादा बार फेल होते हैं।

इसलिए Claude से खुद ऐप लॉन्च कराएँ और उससे interact कराएँ। इसके लिए ये कमांड्स हैं:

/run: असल में प्रोजेक्ट ऐप चलाता है और बदलावों की जाँच के लिए उसे ऑपरेट करता है।
/verify: बदले गए फंक्शन के काम करने की पुष्टि के लिए ऐप बनाता और चलाता है। टेस्ट्स/टाइप चेक से काम नहीं चलाता।
/run-skill-generator: इस प्रोजेक्ट को कैसे चलाना है (कमांड्स, env vars, तैयारी के स्टेप्स) को skill के रूप में सेव करता है। जटिल प्रोजेक्ट्स के लिए पहले यही करें।
/verify जाँचे गए तरीके को दोबारा इस्तेमाल के लिए प्रोजेक्ट skill (.claude/skills/verify/) के रूप में सेव करता है।

इस्तेमाल का तरीका:

1. फीचर लागू करें, पहले tests/build चेक करें

2. /run से ऐप चलाएँ

3. वेब के लिए क्लिक/इनपुट, CLI के लिए सैंपल इनपुट/आउटपुट

4. /verify से दोबारा पुष्टि करें कि लक्ष्य पूरा हुआ

5. फेल होने पर ठीक करें और दोबारा चलाएँ। असली कमांड नतीजे/स्क्रीनशॉट सबूत के तौर पर रखें

8. Coding AI और Reviewing AI को अलग रखें

आपको अपनी लिखी चीज़ों में टाइपो नहीं दिखते। AI के साथ भी ऐसा ही है।

Coding session "यह सही है" वाले पूर्वाग्रह से भरा होता है।

⭐️ इसलिए fresh context वाले reviewer का इस्तेमाल करें। ⭐️

/code-review: बदले गए कोड, PRs, branches, paths में bugs/accuracy issues ढूँढता है।
तीव्रता सेट करें जैसे /code-review high (low से max तक)।

(डिफ़ॉल्ट रूप से सिर्फ रिपोर्ट देता है; auto-correct के लिए --fix जोड़ें।)

/security-review: branch और remote default के बीच के diff में security issues (auth, input validation, info exposure) चेक करता है।
/simplify: डुप्लीकेट/अक्षमताओं/जटिलता को साफ करता है। bugs ढूँढने के लिए नहीं (/code-review वह काम करता है)।

सुझाया गया क्रम:

1. /simplify से कोड साफ करें

2. /verify से कार्यक्षमता जाँचें (टिप #7)

3. /code-review से bugs ढूँढें

4. अगर login/payment/API keys/PII से छेड़छाड़ कर रहे हैं तो /security-review जोड़ें

हर बार चारों चलाने की ज़रूरत नहीं है।

⚠️ छोटे सुधारों के लिए सिर्फ /code-review काफी हो सकता है। ⚠️

गहरी समीक्षा के लिए /code-review ultra इस्तेमाल करें (/ultrareview जैसा ही)।

(Cloud-based deep review; Pro/Max वालों को 3 बार मुफ्त मौका मिलता है।)

9. जटिल Coding से पहले Design और Completion Criteria तय करें

जटिल कामों के लिए, Claude को लंबे coding निर्देश देने के बजाय पहले scope और completion criteria दें।

ऐसा न करने पर, Claude अपनी मर्ज़ी से scope बढ़ा लेता है।

⚠️ यह गैर-ज़रूरी फाइलें बदलता है और बिना माँगे काम करता है। ⚠️

Plan Mode का इस्तेमाल:

Shift+Tab दबाकर plan mode on दिखाएँ, या /plan टाइप करें। /plan fix login bug की तरह task भी जोड़ सकते हैं।

(Plan Mode सिर्फ फाइलें पढ़ता है और योजना बनाता है। मंज़ूरी के बाद ही कोड बदलता है।)

क्रम: Explore → Plan → Approve → Implement → Verify।

टाइपो सुधारने/एक-लाइन वाले बदलावों के लिए planning छोड़ दें। आधिकारिक docs का नियम: अगर बदलाव एक वाक्य में बताया जा सकता है, तो plan छोड़ दें।

10. Hooks से ज़रूरी नियमों को अपने आप लागू करें

भले ही CLAUDE.md में लिखा हो "इस फाइल को मत छुओ," Claude कभी-कभी छू ही देता है।

🔥 CLAUDE.md मार्गदर्शन है; Hooks सख्ती से लागू करना हैं। 🔥

सबसे ज़्यादा इस्तेमाल होने वाले 3:

PreToolUse: फाइल एडिट/कमांड चलने से ठीक पहले। सुरक्षित फाइलों के एडिट/खतरनाक कमांड्स को रोकता है।
PostToolUse: चलने के तुरंत बाद। एडिट की गई फाइलों को auto-format/lint करता है।
Stop: जब Claude काम खत्म करने की कोशिश करे। अगर टेस्ट अधूरे हैं तो रुकने से रोकता है।

उदाहरण: prod config एडिट को रोकना

Claude से hooks बनवाएँ:

--> "एक PreToolUse hook बनाओ जो config/production.env के एडिट को रोके।"

अच्छे उपयोग:

कोड फाइल एडिट होने पर formatter अपने आप चलाना (PostToolUse)
महत्वपूर्ण फोल्डर्स को छूने से पहले पुष्टि माँगना (PreToolUse)
टेस्ट न चले हों तो stop को रोकना (Stop)
खतरनाक कमांड्स को रोकना (PreToolUse + Bash)

11. Git Worktree से एक साथ कई Claude Sessions चलाएँ

अगर एक ही फोल्डर में दो Claude विंडो काम करें तो क्या होगा?

🚫 वे एक ही फाइलें एडिट करने में आपस में टकराएंगे। (बहुत दर्दनाक..) 🚫

Worktree repo को हर टास्क के लिए अलग फोल्डर/branch में बाँट देता है।

Claude Code यह एक कमांड से करता है:

दो टर्मिनल में चलाएँ:

claude --worktree feature-auth
claude --worktree feature-dashboard

छोटा -w भी काम करता है।

यह .claude/worktrees/feature-auth/ बनाता है और worktree-feature-auth branch पर काम करता है।

--> ⭐️ दोनों sessions एक-दूसरे की फाइलों को नहीं छूते। ⭐️

ध्यान रखने योग्य बातें:

नए worktrees मौजूदा branch से नहीं, बल्कि remote default (main) से शुरू होते हैं।

claude --worktree "#1234" की तरह PR number दें तो PR से शुरू होगा।

session खत्म करते समय बचे हुए काम को रखने/मिटाने के लिए पूछता है।

सावधानियाँ:

Worktree सिर्फ फाइलों/branches को अलग करता है। साझा local DB/ports/deploy targets/API accounts टकराव पैदा करेंगे।
एक ही फाइलें एडिट होने पर merge conflicts हो सकते हैं।
आपस में जुड़े कामों के लिए interfaces तय करें या उन्हें क्रम में लगाएँ।
हर session अलग usage खर्च करता है। Parallel चलाने का मतलब tokens की बचत नहीं है।

12. /goal से लक्ष्य पूरा होने तक Verification दोहराएँ

Claude एक turn के बाद रुक जाता है। 3 टेस्ट फेल होने पर भी कह सकता है "mostly fixed"।

Goal Claude को तब तक काम पर लगाए रखता है जब तक completion criteria पूरे न हो जाएँ (v2.1.139 से)।
/goal मौजूदा goal/status दिखाता है।
/goal clear goal हटा देता है/रोक देता है।

यह कैसे काम करता है...

हर turn के बाद, एक छोटा तेज़ मॉडल जाँचता है कि शर्तें पूरी हुईं या नहीं। अगर नहीं, तो Claude अगला turn जारी रखता है।

goal में जाँच का तरीका ज़रूर शामिल करें (जैसे, "test command/results दिखाओ")। Judge model को सबूत चाहिए होता है।