Claude Code सर्वोत्तम अभ्यास: 'उपयोगी' से 'वास्तव में कारगर' तक

मैं पिछले आधे साल से Claude Code का उपयोग कर रहा हूं, और मैंने कोड की लाइनें लिखने से ज्यादा गलतियां की हैं।

शुरू में, मुझे लगा कि Claude Code सिर्फ एक "अधिक उन्नत Copilot" है—टर्मिनल में टाइप करो, यह कोड लिखता है, और काम खत्म। बाद में, मुझे एहसास हुआ कि इस टूल की क्षमता मेरी कल्पना से कहीं अधिक है, लेकिन तभी जब आप इसे सही तरीके से उपयोग करना जानते हैं।

यह लेख आधिकारिक दस्तावेज़ीकरण और व्यावहारिक अनुभव को मिलाकर उन सबसे महत्वपूर्ण उपयोग युक्तियों को व्यवस्थित करता है जो मेरे अनुसार सबसे महत्वपूर्ण हैं। कुछ सीख कठिन तरीके से मिली हैं, जबकि अन्य छिपी हुई विशेषताएं हैं जो मुझे केवल दस्तावेज़ पढ़ने के बाद पता चलीं।

1. CLAUDE.MD: सबसे अनदेखी की गई सुविधा

अगर आप इस लेख से केवल एक चीज़ याद रखें, तो यह याद रखें: अपना CLAUDE.md अच्छी तरह लिखें।

CLAUDE.md एक निर्देश फ़ाइल है जिसे Claude Code हर बातचीत की शुरुआत में स्वचालित रूप से पढ़ता है। यह एक नए सहकर्मी के लिए आपके द्वारा लिखे गए ऑनबोर्डिंग दस्तावेज़ की तरह है—आप जो कुछ भी उन्हें जानना चाहते हैं, आप वहीं लिखते हैं।

बहुत से लोग CLAUDE.md नहीं लिखते या सिर्फ कुछ पंक्तियाँ लिखते हैं। इसका परिणाम यह होता है कि हर बातचीत में प्रोजेक्ट संरचना, कोडिंग मानकों और टेक स्टैक विकल्पों को फिर से समझाना पड़ता है। यह हर सुबह अपने सहकर्मी को कंपनी से फिर से परिचित कराने जैसा है।

एक अच्छे CLAUDE.md में क्या शामिल होना चाहिए:

1# प्रोजेक्ट का नाम
2
3## बिल्ड और टेस्ट कमांड
4- निर्भरताएं इंस्टॉल करें: npm install
5- टेस्ट चलाएं: npm test
6- एकल टेस्ट: npm test -- --grep "test name"
7- फ़ॉर्मेटिंग: npm run format
8
9## कोडिंग मानक
10- Python: फ़ॉर्मेटिंग के लिए ruff का उपयोग करें, लाइन की चौड़ाई 88
11- टेस्टिंग: pytest का उपयोग करें, प्रति सेवा एक टेस्ट फ़ाइल
12- API रूट्स: बहुवचन फ़ाइल नामों का उपयोग करें: users.py, orders.py
13- कमिट संदेश: अंग्रेज़ी में, प्रारूप: type(scope): description
14
15## आर्किटेक्चर निर्णय
16- CSS Modules के बजाय Tailwind चुनें क्योंकि टीम ने इस पर मानकीकरण किया है
17- उपयोगकर्ता अनुमति जाँच मिडलवेयर में की जाती है; हर रूट में दोहराएँ नहीं
18- Redis कैश कुंजी उपसर्ग: app:v1:
19
20## सामान्य समस्याएं
21- DB कनेक्शन पूल सीमा 20 है; लूप में नए कनेक्शन न खोलें
22- डेटाबेस को मॉक न करें; पिछली बार मॉक पास हुए लेकिन प्रोडक्शन माइग्रेशन विफल रहा

मुख्य सिद्धांत:

पहला, वे चीज़ें लिखें जो Claude कोड से अनुमान नहीं लगा सकता। किसी प्रोजेक्ट का "क्यों" "क्या" से अधिक महत्वपूर्ण है। आपको यह समझाने की ज़रूरत नहीं है कि React का उपयोग कैसे करें, लेकिन आपको यह बताना होगा कि "हमने Tailwind को चुना क्योंकि टीम ने इस पर मानकीकरण किया है।"

दूसरा, इसे 200 पंक्तियों से कम रखें। आधिकारिक दस्तावेज़ स्पष्ट रूप से उल्लेख करते हैं कि अगर CLAUDE.md बहुत लंबा है, तो Claude नियमों को अनदेखा कर सकता है। इसे स्कैन करने योग्य बनाने के लिए Markdown हेडर और सूचियों का उपयोग करें।

तीसरा, बार-बार बदलने वाली सामग्री न डालें। विस्तृत API दस्तावेज़ या फ़ाइल-दर-फ़ाइल विवरण CLAUDE.md में नहीं होने चाहिए। बस लिंक प्रदान करें।

CLAUDE.md के चार स्तर

Claude Code CLAUDE.md के चार स्तरों का समर्थन करता है, जो उच्चतम से निम्नतम प्राथमिकता के क्रम में हैं:

अपने वैश्विक CLAUDE.md में, मैं आमतौर पर लिखता हूं:

1- मैं एक फुल-स्टैक इंजीनियर हूं; बुनियादी अवधारणाओं को अधिक समझाने की ज़रूरत नहीं
2- उत्तर संक्षिप्त रखें; अनावश्यक शिष्टाचार छोड़ें
3- कोड बदलने के बाद आपने क्या किया, इसका सारांश न दें; मैं diff देखूंगा
4- सरल समाधानों को प्राथमिकता दें; ओवर-इंजीनियरिंग से बचें

ये चार पंक्तियाँ आपको सैकड़ों दोहराए जाने वाले सुधारों से बचा सकती हैं।

उन्नत: .claude/rules/ के साथ नियमों को व्यवस्थित करें

जैसे-जैसे प्रोजेक्ट बढ़ता है, एक CLAUDE.md फ़ाइल में सब कुछ नहीं आएगा। आधिकारिक समाधान अधिक सुरुचिपूर्ण है: नियमों को .claude/rules/ निर्देशिका में विभाजित करें।

1.claude/rules/
2├── testing.md        # टेस्टिंग मानक
3├── api-style.md      # API लेखन शैली
4└── frontend.md       # फ्रंटएंड परंपराएं

इससे भी अधिक शक्तिशाली, आप नियमों को विशिष्ट फ़ाइलों तक सीमित करने के लिए YAML फ्रंटमैटर का उपयोग कर सकते हैं:

1---
2paths: ["src/api/**/*.ts", "src/routes/**/*.ts"]
3---
4
5API रूट्स में इनपुट सत्यापन और त्रुटि प्रबंधन शामिल होना चाहिए।
6सभी नए एंडपॉइंट्स के लिए tests/api/ में एकीकरण परीक्षण आवश्यक हैं।

इस तरह, नियम तभी लोड होता है जब Claude मिलान वाली फ़ाइलों तक पहुँचता है, जिससे संदर्भ स्थान बचता है।

2. प्रॉम्प्ट की गुणवत्ता आउटपुट की गुणवत्ता निर्धारित करती है

यह एक क्लिच की तरह लगता है, लेकिन मैंने बहुत से लोगों को Claude Code का इस तरह उपयोग करते देखा है:

"मुझे एक लॉगिन सुविधा लिखने में मदद करें"

फिर वे उत्पन्न कोड के एक बड़े हिस्से को लेकर चिंतित होते हैं—यह वह नहीं है जो मैं चाहता था।

एक अच्छे निर्देश में तीन तत्व होने चाहिए: लक्ष्य, बाधाएं और संदर्भ।

खराब निर्देश बनाम अच्छा निर्देश

खराब: "उपयोगकर्ता सूची में एक खोज सुविधा जोड़ें"

अच्छा: "@src/pages/UserList.tsx में तालिका के ऊपर एक खोज बॉक्स जोड़ें। खोज में बैकएंड API /api/users?search=xxx का उपयोग होना चाहिए, कोई फ्रंटएंड फ़िल्टरिंग नहीं। 300ms डिबाउंस का उपयोग करें, और शैली मौजूदा Filter घटक के अनुरूप रखें।"

अंतर? अच्छे निर्देश अस्पष्टता को कम करते हैं। Claude Code को यह अनुमान लगाने की ज़रूरत नहीं है कि आप फ्रंटएंड या बैकएंड खोज चाहते हैं, डिबाउंस समय, या स्टाइलिंग मानक।

आधिकारिक रूप से अनुशंसित प्रॉम्प्टिंग युक्तियाँ

1. विशिष्ट फ़ाइलों को संदर्भित करने के लिए @ का उपयोग करें

Claude Code फ़ाइल सामग्री को सीधे संदर्भ में लाने के लिए @filepath का उपयोग करने का समर्थन करता है। "उस auth-संबंधित कोड" कहने के बजाय, @src/auth/login.ts लिखना अधिक सटीक है। आप लाइन रेंज भी निर्दिष्ट कर सकते हैं: @src/auth/login.ts#5-30।

2. स्क्रीनशॉट और इमेज पेस्ट करें

इमेज को सीधे पेस्ट करने के लिए Ctrl+V का उपयोग करें। UI समस्याओं को डीबग करते समय, "यह अब कैसा दिखता है" बनाम "मैं इसे कैसा चाहता हूं" का स्क्रीनशॉट टेक्स्ट विवरण से दस गुना अधिक प्रभावी होता है।

3. सत्यापन मानदंड प्रदान करें

सिर्फ "इस बग को ठीक करने में मेरी मदद करें" न कहें, बल्कि कहें:

"लॉगिन टाइमआउट के बाद पुन: प्रमाणीकरण विफल होने की समस्या को ठीक करें। ठीक करने के बाद, टोकन समाप्ति के बाद किसी भी बटन पर क्लिक करने से स्वचालित रूप से लॉगिन पेज पर रीडायरेक्ट होना चाहिए। टेस्ट केस @tests/auth.test.ts में हैं; ठीक करने के बाद उन्हें चलाकर पुष्टि करें कि वे पास होते हैं।"

Claude को एक स्व-सत्यापन योग्य मानक दें—टेस्ट केस, स्क्रीनशॉट, अपेक्षित आउटपुट—ताकि वह अपने काम की गुणवत्ता स्वयं जांच सके और आगे-पीछे की बातचीत को कम कर सके।

4. स्पष्ट रहें कि क्या नहीं करना है

Claude Code कभी-कभी अति-उत्साही हो सकता है—आप इसे एक बग ठीक करने के लिए कहते हैं, और यह आसपास के कोड को भी रिफैक्टर कर देता है। स्पष्ट रूप से कहना "केवल इस फ़ंक्शन को बदलें, दूसरे कोड को न छुएं" बहुत सारी परेशानी बचाता है।

जब अस्पष्ट निर्देश उपयोगी होते हैं

हर स्थिति में सटीकता की आवश्यकता नहीं होती। अस्पष्ट निर्देश वास्तव में खोजपूर्ण कार्यों के लिए बेहतर होते हैं:

• "इस फ़ाइल में क्या सुधार किया जा सकता है?"
• "मुझे इस मॉड्यूल की आर्किटेक्चर समझने में मदद करें"
• "क्या इस कोड में कोई संभावित समस्या है?"

लेकिन एक बार जब आप कार्यान्वयन चरण में पहुँच जाते हैं, तो सटीकता मोड पर वापस जाएं।

3. प्लान मोड: कार्य करने से पहले स्पष्ट रूप से सोचें

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

प्लान मोड में कैसे प्रवेश करें

तीन तरीके:

1# सीधे प्लान मोड में शुरू करें
2claude --permission-mode plan
3
4# बातचीत के दौरान स्विच करें (Shift+Tab दो बार दबाएं)
5Shift+Tab Shift+Tab
6
7# प्रॉम्प्ट में कहें
8"अभी कोड न बदलें, मुझे एक योजना बनाने में मदद करें"

प्लान मोड में, Claude Code केवल फ़ाइलें पढ़ सकता है और कोड खोज सकता है; यह कोई संशोधन नहीं कर सकता। यह कोडबेस का पता लगाता है, आपकी आवश्यकताओं का विश्लेषण करता है, और एक विस्तृत कार्यान्वयन योजना प्रदान करता है।

प्लान मोड का सही तरीके से उपयोग करना

मुख्य संचालन: योजना को अपने एडिटर में खोलने और संपादित करने के लिए Ctrl+G दबाएं।

इसका मतलब है कि आप:

1. Claude को एक प्रारंभिक योजना तैयार करने दें
2. Ctrl+G दबाकर योजना खोलें, उन हिस्सों को हटाएं जिनसे आप सहमत नहीं हैं, और अपने विचार जोड़ें
3. सामान्य मोड पर वापस जाएं (Shift+Tab) और Claude को संशोधित योजना के अनुसार निष्पादित करने दें

योजना बदलने में एक वाक्य लगता है; पहले से लिखे कोड को बदलने में दस गुना अधिक समय लगता है।

जटिल कार्यों के लिए अनुशंसित वर्कफ़्लो

आधिकारिक मानक प्रक्रिया चार चरणों की है: एक्सप्लोर करें → योजना बनाएं → कार्यान्वित करें → सत्यापित करें।

11. प्लान मोड में प्रवेश करें
22. Claude को प्रासंगिक कोड पढ़ने दें: "सत्र तर्क समझने के लिए src/auth/ में कोड पढ़ें"
33. एक योजना का अनुरोध करें: "एक OAuth2 माइग्रेशन योजना विकसित करें"
44. योजना की समीक्षा और संपादन के लिए Ctrl+G दबाएं
55. सामान्य मोड पर वापस जाएं
66. "योजना के अनुसार कार्यान्वित करें, लिखने के बाद टेस्ट चलाएं"
77. Claude को आवश्यकताओं के विरुद्ध स्वयं जांच करने दें

जब आपको प्लान मोड की आवश्यकता नहीं है

• एक वेरिएबल नाम बदलना
• एक स्पष्ट टाइपो ठीक करना
• एक लॉग लाइन जोड़ना

मानदंड सरल है: अगर कार्य को लागू करने का केवल एक तरीका है, तो सीधे करें। अगर कई विकल्प हैं, तो पहले योजना बनाएं।

4. सब-एजेंट: Claude Code की मल्टी-टास्किंग शक्ति

सब-एजेंट एक शक्तिशाली तंत्र है—Claude Code कार्यों को समानांतर में संभालने के लिए स्वतंत्र AI प्रक्रियाएं शुरू कर सकता है। प्रत्येक सब-एजेंट का अपना संदर्भ विंडो होता है और यह आपकी मुख्य बातचीत को अव्यवस्थित नहीं करेगा।

अंतर्निहित सब-एजेंट प्रकार

सब-एजेंट का सबसे बड़ा मूल्य: संदर्भ पृथक्करण

जब आप Claude को टेस्ट चलाने, लॉग विश्लेषण करने, या कई फ़ाइलों को खोजने के लिए कहते हैं, तो ये संचालन भारी आउटपुट उत्पन्न करते हैं जो आपके संदर्भ विंडो को भर देता है। इन कार्यों के लिए सब-एजेंट का उपयोग करें; आउटपुट सब-एजेंट के संदर्भ में रहता है, और केवल एक सारांश आपको वापस मिलता है।

उदाहरण के लिए:

"सभी टेस्ट चलाने और विफल मामलों को सूचीबद्ध करने के लिए एक सब-एजेंट का उपयोग करें"

"डिप्रीकेटेड API का उपयोग करने वाली सभी फ़ाइलों को खोजने के लिए एक सब-एजेंट का उपयोग करें"

पृष्ठभूमि में चलाना: Ctrl+B

एक सब-एजेंट को पृष्ठभूमि में रखने के लिए Ctrl+B दबाएं। आप Claude के साथ अन्य चीजों के बारे में बातचीत जारी रख सकते हैं, और जब पृष्ठभूमि कार्य पूरा हो जाएगा तो आपको सूचित किया जाएगा।

इसके लिए उपयुक्त:

• टेस्ट सूट चलाना (आमतौर पर मिनट लगते हैं)
• बड़े पैमाने पर कोड खोज
• गैर-जरूरी कोड समीक्षा

कस्टम सब-एजेंट

आप .claude/agents/ निर्देशिका में कस्टम एजेंट बना सकते हैं:

1---
2name: code-reviewer
3description: कोड समीक्षा विशेषज्ञ। कोड बदलने के बाद स्वचालित रूप से ट्रिगर होता है।
4tools: Read, Grep, Glob, Bash
5model: sonnet
6---
7
8आप एक वरिष्ठ कोड समीक्षक हैं। निम्नलिखित आयामों की जांच करें:
9- कोड स्पष्टता और पठनीयता
10- त्रुटि प्रबंधन की पूर्णता
11- संवेदनशील जानकारी का प्रदर्शन
12- इनपुट सत्यापन
13- प्रदर्शन संबंधी समस्याएं

फिर बातचीत में @"code-reviewer (agent)" का उपयोग करके इसे कॉल करें।

5. संदर्भ प्रबंधन: सबसे अनदेखी की गई कुंजी

जबकि Claude Code का संदर्भ विंडो बड़ा है (1M टोकन तक), यह अनंत नहीं है, और संदर्भ प्रबंधन सीधे आउटपुट गुणवत्ता निर्धारित करता है।

संदर्भ में क्या है?

• आपका बातचीत इतिहास
• Claude द्वारा पढ़ी गई सभी फ़ाइल सामग्री
• कमांड निष्पादन आउटपुट
• CLAUDE.md फ़ाइल (हर बार लोड होती है)
• मेमोरी फ़ाइल (पहली 200 पंक्तियाँ)
• लोड की गई स्किल और MCP टूल परिभाषाएं

पांच व्यावहारिक रणनीतियां

1. /clear: जब कोई कार्य पूरा हो जाए तो साफ़ करें

एक ही बातचीत में बग ठीक न करें, सुविधाएं न जोड़ें और रिफैक्टर न करें। /clear संदर्भ को खाली करता है लेकिन CLAUDE.md को रखता है, जो एक मुफ्त रीस्टार्ट की तरह काम करता है।

2. /compact: मैन्युअल रूप से संदर्भ संपीड़ित करें

जब बातचीत लंबी हो जाए, तो Claude को पिछली बातचीत को स्वचालित रूप से सारांशित और संपीड़ित करने देने के लिए /compact का उपयोग करें। एक बेहतर तरीका है संपीड़न में एक फोकस जोड़ना:

/compact focus on API changes and test results

इस तरह, Claude संपीड़न के दौरान उस सामग्री को रखने को प्राथमिकता देता है जिसकी आपको परवाह है।

3. /context: देखें कि आपका संदर्भ क्या खा रहा है

वर्तमान उपयोग देखने के लिए /context टाइप करें—कौन सी फ़ाइलें कितने टोकन लेती हैं और MCP टूल परिभाषाएं कितनी जगह लेती हैं। मुझे अक्सर बेकार MCP सर्वर मिलते हैं जो भारी मात्रा में जगह लेते हैं।

4. शोर को अलग करने के लिए सब-एजेंट का उपयोग करें

टेस्ट चलाने और लॉग विश्लेषण करने से बहुत सारा आउटपुट उत्पन्न होता है। मुख्य बातचीत के संदर्भ को साफ रखने के लिए सब-एजेंट को यह करने दें।

5. CLAUDE.md में संपीड़न प्रतिधारण निर्देश लिखें

आप Claude को बता सकते हैं कि संपीड़न के दौरान क्या रखा जाना चाहिए:

1# संपीड़न निर्देश
2संदर्भ संपीड़ित करते समय, हमेशा रखें:
3- संशोधित फ़ाइलों की पूरी सूची
4- टेस्ट कमांड और परिणाम
5- मुख्य आर्किटेक्चर निर्णय

मेमोरी बनाम CLAUDE.md

मेमोरी किसके लिए है: आपकी प्राथमिकताएं ("यह व्यक्ति संक्षिप्त उत्तर पसंद करता है"), प्रोजेक्ट परंपराएं ("डिप्लॉयमेंट में एक विशेष चरण है"), ऐतिहासिक निर्णय ("हमने पिछली बार X के कारण विकल्प A चुना था")।

मेमोरी किसके लिए नहीं है: कोड विवरण, Git इतिहास, अस्थायी स्थितियां—ये कोड और Git से अधिक सटीक रूप से प्राप्त किए जाते हैं।

सभी लोड की गई मेमोरी को देखने और प्रबंधित करने के लिए /memory कमांड का उपयोग करें।

6. अनुमति प्रबंधन: सुरक्षा और दक्षता का संतुलन

Claude Code पांच अनुमति मोड प्रदान करता है, जिन्हें बातचीत में Shift+Tab के माध्यम से चक्रित किया जा सकता है:

अनुमति नियम कॉन्फ़िगरेशन

.claude/settings.json में, आप प्रत्येक टूल के लिए अनुमतियों को बारीकी से नियंत्रित कर सकते हैं:

1{
2  "permissions": {
3    "allow": [
4      "Bash(npm run *)",
5      "Bash(git commit *)",
6      "Edit(src/**/*.ts)",
7      "Read(*.md)"
8    ],
9    "deny": [
10      "Bash(rm -rf *)",
11      "Edit(.env)"
12    ]
13  }
14}

नियम प्राथमिकता: deny → ask → allow (deny की सबसे अधिक प्राथमिकता है)।

इसका मतलब है कि आप सामान्य कमांड को साहसपूर्वक अनुमति दे सकते हैं जबकि संवेदनशील फ़ाइलों की सुरक्षा के लिए deny का उपयोग कर सकते हैं। उदाहरण के लिए, .env फ़ाइलों को कभी संपादित नहीं किया जाना चाहिए।

सेटिंग फ़ाइलों का पदानुक्रम

CLAUDE.md के समान, सेटिंग्स के कई स्तर हैं:

1संगठन नीति (सर्वोच्च प्राथमिकता)
2  ↓
3CLI तर्क
4  ↓
5.claude/settings.local.json (स्थानीय, Git में कमिट नहीं किया गया)
6  ↓
7.claude/settings.json (प्रोजेक्ट स्तर, टीम के साथ साझा)
8  ↓
9~/.claude/settings.json (वैश्विक, व्यक्तिगत)
10  ↓
11डिफ़ॉल्ट मान (निम्नतम प्राथमिकता)

मेरी सलाह: टीम-साझा नियमों को .claude/settings.json में रखें, व्यक्तिगत प्राथमिकताओं को ~/.claude/settings.json में, और संवेदनशील कॉन्फ़िगरेशन को .claude/settings.local.json में (याद रखें .gitignore में जोड़ें)।

7. हुक: नियमों को लौह कानूनों में बदलना

CLAUDE.md में निर्देश "सुझाव" हैं—Claude उनका अधिकांश समय पालन करता है लेकिन कभी-कभी भूल जाता है। हुक "लौह कानून" हैं—वे चाहे कुछ भी हो, निष्पादित होते हैं।

हुक शेल कमांड हैं जो विशिष्ट जीवनचक्र घटनाओं द्वारा स्वचालित रूप से ट्रिगर होते हैं, जो settings.json में कॉन्फ़िगर किए जाते हैं।

मुख्य घटना प्रकार

व्यावहारिक उदाहरण

ऑटो-फ़ॉर्मेटिंग—प्रत्येक संपादन के बाद Prettier चलाएं:

1{
2  "hooks": {
3    "PostToolUse": [{
4      "matcher": "Edit|Write",
5      "hooks": [{
6        "type": "command",
7        "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
8      }]
9    }]
10  }
11}

महत्वपूर्ण फ़ाइलों की सुरक्षा—प्रोडक्शन कॉन्फ़िगरेशन को संशोधित करने से रोकें:

1{
2  "hooks": {
3    "PreToolUse": [{
4      "matcher": "Edit|Write",
5      "hooks": [{
6        "type": "command",
7        "command": ".claude/hooks/protect-files.sh"
8      }]
9    }]
10  }
11}

एक हुक कमांड जो एग्जिट कोड 0 लौटाता है, अनुमत का मतलब है; एग्जिट कोड 2 का मतलब अवरुद्ध है। इसका मतलब है कि आप कोई भी जटिल तर्क लिख सकते हैं।

संदर्भ संपीड़न के बाद मुख्य जानकारी पुनः इंजेक्ट करना:

1{
2  "hooks": {
3    "SessionStart": [{
4      "matcher": "compact",
5      "hooks": [{
6        "type": "command",
7        "command": "echo 'Bun का उपयोग करें, npm का नहीं। कमिट करने से पहले bun test चलाएं।'"
8      }]
9    }]
10  }
11}

यह एक सामान्य समस्या का समाधान करता है: जब एक लंबी बातचीत संपीड़ित होती है, तो पहले बताए गए महत्वपूर्ण निर्देश खो सकते हैं। हुक प्रत्येक संपीड़न के बाद स्वचालित रूप से उन्हें पुनः इंजेक्ट कर सकते हैं।

चार प्रकार के हुक

8. GIT वर्कफ़्लो: WORKTREE का अच्छा उपयोग करना

Claude Code Git कमांड निष्पादित कर सकता है, जो एक दोधारी तलवार है। लेकिन आधिकारिक टूल एक बढ़िया सुरक्षा जाल प्रदान करता है: Worktree।

Git Worktree: पृथक कार्यक्षेत्र

1# एक पृथक worktree में Claude शुरू करें
2claude --worktree feature-auth
3claude --worktree bugfix-123
4
5# स्वचालित रूप से एक नाम उत्पन्न करें
6claude --worktree

Worktree .claude/worktrees/ के तहत एक स्वतंत्र Git शाखा प्रतिलिपि बनाता है। Claude अंदर जो कुछ भी करता है, वह आपकी मुख्य शाखा को प्रभावित नहीं करेगा। बाहर निकलने पर:

• अगर कोई बदलाव नहीं → ऑटो-क्लीन
• अगर बदलाव मौजूद हैं → आपको रखने या हटाने के लिए संकेत देता है

यह विशेष रूप से खोजपूर्ण कार्यों के लिए उपयोगी है। पता नहीं कि कोई रिफैक्टरिंग योजना काम करेगी? इसे worktree में आज़माएं; अगर यह विफल होता है, तो इसे शून्य जोखिम के साथ फेंक दें।

कुछ Git लौह कानून

1. Claude Code को कभी भी ऑटो-पुश न करने दें

यह कमिट कर सकता है, लेकिन पुश कार्रवाई आपके द्वारा पुष्टि की जानी चाहिए। एक बार रिमोट पर पुश करने के बाद, वापस रोल करने की लागत काफी बढ़ जाती है।

2. बार-बार कमिट करें

एक छोटी सुविधा पूरी करने के बाद कमिट करें। किसी भी चेकपॉइंट पर वापस जाने के लिए /rewind का उपयोग करें, बशर्ते आपके पास कमिट रिकॉर्ड हों।

3. विनाशकारी संचालन से सावधान रहें

अगर Claude Code git reset --hard, git push --force, या rm -rf निष्पादित करना चाहता है, तो अनुमति देने से पहले परिणामों के बारे में सोचें। इन संचालनों का कोई पूर्ववत नहीं है। आप अनुमति नियमों में इन कमांड को अस्वीकार भी कर सकते हैं।

4. PR से संदर्भ पुनर्स्थापित करें

यह स्वचालित रूप से PR परिवर्तनों और चर्चाओं को संदर्भ के रूप में लोड करता है, जो कोड समीक्षा या किसी और के काम को जारी रखने के लिए एकदम सही है।

1claude --from-pr 123

9. शॉर्टकट और कमांड संदर्भ

मैं इन शॉर्टकट का हर दिन उपयोग करता हूं; मैं अत्यधिक अनुशंसा करता हूं कि आप इन्हें याद करें:

सबसे सामान्य शॉर्टकट

सबसे सामान्य स्लैश कमांड

1/compact [focus]     # संदर्भ संपीड़ित करें, फोकस निर्दिष्ट कर सकते हैं
2/clear              # बातचीत साफ़ करें, फिर से शुरू करें
3/context            # संदर्भ उपयोग देखें
4/memory             # मेमोरी देखें और प्रबंधित करें
5/rewind             # एक चेकपॉइंट पर वापस रोल करें
6/resume [name]       # पिछली बातचीत फिर से शुरू करें
7/model              # मॉडल स्विच करें
8/effort [level]       # तर्क गहराई सेट करें: low/medium/high/max
9/init               # स्वचालित रूप से CLAUDE.md उत्पन्न करें
10/mcp                # MCP सर्वर प्रबंधित करें
11/permissions        # अनुमति नियम देखें
12/cost               # टोकन खपत देखें

/init विशेष रूप से नए प्रोजेक्ट के लिए उपयोगी है—यह स्वचालित रूप से आपके कोडबेस का विश्लेषण करता है और एक मसौदा CLAUDE.md तैयार करने में मदद करता है। जबकि इसे आमतौर पर मैन्युअल समायोजन की आवश्यकता होती है, यह खरोंच से शुरू करने की तुलना में बहुत तेज़ है।

10. विस्तारित सोच: Claude को गहराई से सोचने दें

जटिल समस्याओं के लिए, आप विस्तारित सोच मोड सक्षम कर सकते हैं, जिससे Claude उत्तर देने से पहले तर्क करने में अधिक समय बिता सके।

इसका उपयोग कैसे करें

1# शॉर्टकट टॉगल
2Option+T (Mac) / Alt+T (Windows/Linux)
3
4# या कमांड के माध्यम से
5/effort high    # गहन तर्क
6/effort max     # अधिकतम तर्क गहराई
7/effort low     # सरल कार्य, टोकन बचाता है

इसका उपयोग कब करें

• जटिल आर्किटेक्चर निर्णय
• मुश्किल डीबगिंग (कई संभावित कारणों को खत्म करना)
• मल्टी-स्टेप रिफैक्टरिंग डिज़ाइन
• कई समाधानों के पक्ष और विपक्ष का मूल्यांकन

जब आपको इसकी आवश्यकता नहीं है

• सरल कोड परिवर्तन
• फ़ॉर्मेटिंग, नाम बदलना
• पहले से ही स्पष्ट बग फिक्स

प्रो-टिप: प्रॉम्प्ट में "ultrathink" लिखने से मैन्युअल रूप से प्रयास सेटिंग्स को समायोजित किए बिना उच्चतम तर्क गहराई को बल मिल सकता है।

11. MCP सर्वर: Claude को बाहरी दुनिया से जोड़ना

MCP (मॉडल संदर्भ प्रोटोकॉल) Claude Code को बाहरी टूल—GitHub, डेटाबेस, Slack, Notion, आदि—से संवाद करने की अनुमति देता है।

त्वरित जोड़

1claude mcp add github -- npx @anthropic-ai/mcp-server-github
2claude mcp add postgres -- npx @anthropic-ai/mcp-server-postgres postgresql://localhost:5432/mydb

कॉन्फ़िगरेशन फ़ाइल

MCP .mcp.json में कॉन्फ़िगर किया गया है:

1{
2  "mcpServers": {
3    "github": {
4      "type": "stdio",
5      "command": "npx",
6      "args": ["@modelcontextprotocol/server-github"],
7      "env": {
8        "GITHUB_TOKEN": "$GITHUB_TOKEN"
9      }
10    }
11  }
12}

संदर्भ ओवरहेड पर ध्यान दें

प्रत्येक MCP सर्वर टूल परिभाषाओं के लिए अतिरिक्त 100-500+ टोकन की खपत करता है। प्रत्येक सर्वर के ओवरहेड की जांच करने और अप्रयुक्त को अक्षम करने के लिए /mcp कमांड का उपयोग करें।

मेरा अनुभव: लालची न बनें। 2-3 सामान्यतः उपयोग किए जाने वाले MCP सर्वर पर्याप्त हैं। बहुत अधिक स्थापित करने से टूल परिभाषाओं के साथ संदर्भ स्थान खत्म हो जाता है, जो वास्तव में कोड विश्लेषण गुणवत्ता को खराब कर सकता है।

12. IDE एकीकरण: सिर्फ एक टर्मिनल से अधिक

VS Code

Claude Code एक्सटेंशन स्थापित करने के बाद, आप टर्मिनल पर स्विच किए बिना सीधे VS Code में Claude का उपयोग कर सकते हैं।

उपयोगी सुविधाएं:

• साइड-बाय-साइड diff व्यू: Claude के परिवर्तन diff के रूप में दिखाए जाते हैं, एक नज़र में स्पष्ट
• Option+K / Alt+K: वर्तमान फ़ाइल में @references शीघ्रता से सम्मिलित करें
• मल्टी-टैब बातचीत: विभिन्न टैब में कई स्वतंत्र बातचीत खोलें
• Cmd+Shift+Esc: एक नया बातचीत टैब शीघ्रता से खोलें

JetBrains

IntelliJ, PyCharm, WebStorm, और अन्य JetBrains IDE में भी एक Claude Code प्लगइन है। बस Plugins मार्केटप्लेस में "Claude Code" खोजें और स्थापित करें।

13. कोड की समीक्षा: भरोसा करें लेकिन सत्यापित करें

Claude Code की कोड गुणवत्ता आम तौर पर अच्छी है, लेकिन आपको आँख बंद करके भरोसा नहीं करना चाहिए।

सामान्य समस्याएं

1. ओवर-इंजीनियरिंग

आप एक सरल उपयोगिता फ़ंक्शन मांगते हैं, और यह आपको जेनेरिक, इंटरफेस और फैक्ट्री पैटर्न के साथ एक पूर्ण अमूर्तता परत देता है। एक छोटी समस्या के लिए बड़ा समाधान।

समाधान: CLAUDE.md में "सरल समाधानों को प्राथमिकता दें" लिखें, या निर्देश में स्पष्ट रूप से कहें "कोई अमूर्तता आवश्यक नहीं"।

2. हेलुसिनेटेड API

यह कभी-कभी गैर-मौजूद API या पुराने सिंटैक्स का उपयोग करता है, विशेष रूप से विशिष्ट लाइब्रेरी के नए संस्करणों के लिए।

समाधान: टेस्ट चलाएं। यही कारण है कि निर्देशों में सत्यापन मानक शामिल होने चाहिए।

3. स्कोप क्रीप

आप इसे एक फ़ंक्शन बदलने के लिए कहते हैं, और यह पूरी फ़ाइल को रिफैक्टर कर देता है।

समाधान: स्पष्ट रूप से कहें "केवल X बदलें, दूसरे कोड को न छुएं।" या संपादन दायरे को विशिष्ट निर्देशिकाओं तक सीमित करने के लिए /freeze कमांड का उपयोग करें।

लेखक/समीक्षक मोड

आधिकारिक रूप से अनुशंसित एक उन्नत मोड: "लेखक" और "समीक्षक" की भूमिका निभाने के लिए दो स्वतंत्र सत्रों का उपयोग करें।

दो सत्रों के स्वतंत्र संदर्भ होते हैं; समीक्षक लेखक के तर्क से प्रभावित नहीं होता है और अंध स्थानों को ढूंढ सकता है।

1सत्र A (लेखक): "API दर-सीमित मिडलवेयर लागू करें"
2सत्र B (समीक्षक): "@src/middleware/rateLimiter.ts में दर-सीमित कार्यान्वयन की समीक्षा करें, 
3                     एज केस, रेस स्थितियों और स्थिरता पर ध्यान केंद्रित करें"
4सत्र A: "समीक्षा फीडबैक ठीक करें: [B का आउटपुट पेस्ट करें]"

14. Claude Code के साथ क्या न करें

इतना सब "क्या करें" के बारे में कहने के बाद, अब "क्या न करें" के बारे में बात करते हैं।

1. इसे वे काम न करने दें जिन्हें आप बिल्कुल नहीं समझते

अगर आप Kubernetes के बारे में कुछ नहीं जानते, तो Claude Code को सीधे उपयोग के लिए डिप्लॉयमेंट कॉन्फ़िगरेशन न लिखने दें। आप उस चीज़ की समीक्षा नहीं कर सकते जिसे आप नहीं समझते।

2. इसे संस्करण नियंत्रण के बिना वातावरण में उपयोग न करें

कोई Git नहीं, कोई वापस रोल करने की क्षमता नहीं। Claude Code के परिवर्तन आपकी फ़ाइलों को अधिलेखित कर सकते हैं; संस्करण नियंत्रण के बिना इसका उपयोग करना बिना सुरक्षा जाल के तंग रस्सी पर चलने जैसा है।

3. एक बार में एक बड़ा कार्य न फेंकें

"पूरे प्रोजेक्ट को JavaScript से TypeScript में माइग्रेट करें"

यह निर्देश Claude Code को पूरी छूट देता है, जिससे परिणाम अनियंत्रित हो जाता है। इसे छोटे चरणों में तोड़ें और अगले चरण पर जाने से पहले प्रत्येक चरण की पुष्टि करें।

4. पहले प्रयास में पूर्णता की उम्मीद न करें

पुनरावृत्ति सामान्य है। वापस जाने के लिए /rewind का उपयोग करें और "क्या गलत है" का वर्णन करने के लिए सटीक फीडबैक का उपयोग करें।

सारांश

Claude Code का उपयोग करने का मूल दर्शन सरल है:

यह एक अत्यंत सक्षम सहयोगी है, लेकिन ऑटोपायलट नहीं। स्टीयरिंग व्हील हमेशा आपके हाथों में है।

महत्व के क्रम में, मेरी सलाह है:

1. CLAUDE.md को अच्छे से लिखें — एक बार निवेश करें, हर बातचीत में लाभ उठाएं
2. सटीक निर्देश दें — लक्ष्य + सीमाएं + सत्यापन मानक
3. Plan Mode का उपयोग करें — जटिल कार्यों के लिए पहले योजना बनाएं, फिर कार्य करें
4. संदर्भ प्रबंधित करें — /clear, /compact, Sub-agents
5. अनुमतियों को नियंत्रित करें — खतरनाक संचालन अस्वीकार करें, सामान्य आदेशों की अनुमति दें
6. बार-बार कमिट करें — वापस लौटने की क्षमता बनाए रखें

इन्हें करें, और Claude Code आपकी दक्षता को कई गुना बढ़ा सकता है। इन्हें न करें, और यह केवल तेजी से अव्यवस्था पैदा करने में मदद करेगा।

एक उपकरण का मूल्य हमेशा उसका उपयोग करने वाले व्यक्ति पर निर्भर करता है।

उपरोक्त Claude Code के आधिकारिक दस्तावेज़ीकरण और व्यावहारिक अनुभव का संयोजन है। यदि आपके पास बेहतर अभ्यास हैं, तो साझा करने में संकोच न करें।