स्लैश कमांड (Slash Commands): एक / जो Claude के सभी शॉर्टकट एक्शन को ट्रिगर करता है

📚 सीरीज़ नेविगेशन: पिछला लेख 35 नियंत्रण और मोड ने आपको सिखाया कि कैसे Claude की लगाम को कसें या ढीला करें (अनुमति मोड, /model, /effort जैसे स्विच)। यह लेख आपको उस प्रवेश द्वार पर वापस लाता है जिसे आप हर दिन टाइप करते हैं, लेकिन शायद पूरी तरह से नहीं समझते हैं — स्लैश कमांड। बस एक / टाइप करने से लेकर मॉडल बदलने, कॉन्टेक्स्ट साफ़ करने, या यहां तक कि आपके स्वयं के कस्टम एक-क्लिक वर्कफ़्लो तक, सब कुछ इसी एक मेनू में है। मैं आपको बिल्ट-इन (built-in) कमांड से परिचित कराऊंगा और फिर आपको सिखाऊंगा कि अपने स्वयं के कस्टम कमांड कैसे बनाएं।

बहुत से लोग जब पहली बार Claude Code का उपयोग करना शुरू करते हैं, तो वे एक मूर्खतापूर्ण काम करते हैं।

हर बार जब वे बातचीत साफ़ करना चाहते हैं और फिर से शुरू करना चाहते हैं, तो वे ईमानदारी से यह करते हैं: पहले claude से बाहर निकलने के लिए Ctrl+C दबाते हैं, फिर टर्मिनल में फिर से claude टाइप करते हैं, प्रोजेक्ट को फिर से लोड होने और CLAUDE.md को पढ़ने का इंतज़ार करते हैं — जिसमें लगभग दस सेकंड लगते हैं। वे इसे एक या दो सप्ताह तक लगातार करते हैं, और अपने मन में सोचते हैं, "खैर, इसे रीस्टार्ट करने का यही तरीका होना चाहिए।" जब तक कि वे आधिकारिक दस्तावेज़ों में /clear कमांड नहीं देखते, जिसमें एक वाक्य लिखा होता है, "खाली कॉन्टेक्स्ट के साथ एक नई बातचीत शुरू करें।" तब उन्हें पता चलता है: अरे, मुझे केवल बातचीत में तीन अक्षर टाइप करने थे, रीस्टार्ट करने में बिताए गए वे दो सप्ताह पूरी तरह से समय की बर्बादी थे।

उससे भी अधिक शर्मनाक बात बाद में आती है। /compact लंबी बातचीत को संक्षिप्त कर सकता है ताकि आप चैट करना जारी रख सकें, /model बिना रीस्टार्ट किए मॉडल बदल सकता है, /init एक-क्लिक के साथ CLAUDE.md जनरेट कर सकता है... ये सभी काम या तो पहले मैन्युअल रूप से किए गए थे या उन्हें पता ही नहीं था कि वे किए जा सकते हैं। ये कमांड हमेशा उस / मेनू में रहे हैं, बस एक स्लैश टाइप करने से वे सभी लिस्ट हो जाते हैं, लेकिन उन्होंने कभी उन पर ध्यान नहीं दिया।

मैं यह शर्मनाक कहानी इसलिए बता रहा हूं ताकि आप उसी जाल में न फँसें: स्लैश कमांड कोई 'एडवांस फीचर' नहीं है, यह Claude Code का सबसे बेसिक कंट्रोल पैनल है। ज़्यादातर "मेटा-ऑपरेशन्स" (meta-operations) जो आप किसी सेशन में करना चाहते हैं — इसे कोड लिखने के लिए नहीं, बल्कि खुद इसे एडजस्ट करने के लिए — जैसे मॉडल बदलना, कॉन्टेक्स्ट साफ़ करना, वर्कफ़्लो चलाना, या पैनल खोलना, इन सबका प्रवेश द्वार यही एक / है। यह लेख पहले आपको बिल्ट-इन कमांड से परिचित कराएगा, और फिर आपको सिखाएगा कि कैसे उन प्रॉम्प्ट्स को जिन्हें आप हर रोज़ टाइप करते हैं, अपने स्वयं के एक-क्लिक कमांड में बदलें।

इस लेख को पढ़ने के बाद, आपको मिलेगा:

• एक वाक्य में स्पष्टीकरण कि स्लैश कमांड क्या है और यह केवल संदेश के शुरुआत में ही क्यों काम करता है
• "उपयोग के परिदृश्य (usage scenario)" द्वारा समूहीकृत बिल्ट-इन कमांड की एक सूची (/help, /clear, /compact, /init, /model, /agents, /mcp, /memory, आदि), जिन्हें आपको याद रखने की आवश्यकता नहीं है, बस आवश्यकता पड़ने पर जांचें
• अपना स्वयं का स्लैश कमांड बनाने का पूरा चरण: .claude/commands/ में एक मार्कडाउन फ़ाइल छोड़ें, फ्रंटमैटर (frontmatter) जोड़ें, और पैरामीटर पास करने के लिए $ARGUMENTS का उपयोग करें
• एक उन्नत तरकीब (advanced trick): कमांड को Claude को भेजने से पहले git diff जैसे "लाइव डेटा" को स्वचालित रूप से भरने दें
• नेमस्पेस (namespaces) क्या हैं और प्लगइन (plugin) से जुड़े कमांड कभी भी आपके कमांड के साथ नाम से क्यों नहीं टकराएंगे
• स्लैश कमांड और Skill के बीच क्या संबंध है (संक्षेप में: स्लैश कमांड Skill का "सक्रिय रूप से कॉल किया गया" (actively called) संस्करण है, विवरण के लिए लेख 26 देखें)
• एक व्यावहारिक उदाहरण जिसका आप पालन कर सकते हैं, अपेक्षित आउटपुट के साथ: 5 मिनट में पैरामीटर के साथ /explain कमांड बनाएं और सत्यापित करें

---

01 पहले समझें: स्लैश कमांड आखिर क्या है, और यह केवल शुरुआत में ही क्यों काम करता है

सीधे निष्कर्ष पर आते हैं: स्लैश कमांड वह "कंट्रोल निर्देश (control instructions)" है जिसे आप Claude सेशन में टाइप करते हैं — यह Claude को काम करने के लिए कहने के लिए नहीं है, बल्कि सीधे Claude Code प्रोग्राम को ही आदेश देने के लिए है: मॉडल बदलें, कॉन्टेक्स्ट साफ़ करें, वर्कफ़्लो चलाएं, या मेनू खोलें।

पिछले तीस या अधिक लेखों के बारे में सोचें; Claude के साथ आपकी बातचीत हमेशा दो प्रकार की रही है। एक वास्तविक आवश्यकता है: "कृपया इस फ़ंक्शन को रिफ़ैक्टर (refactor) करने में मेरी मदद करें," "इस एरर का क्या मतलब है?" — यह वह है जो आप मॉडल (model) से कहते हैं। दूसरा मेटा-ऑपरेशन है: "बातचीत साफ़ करें और पुनः आरंभ करें," "अधिक किफ़ायती (economical) मॉडल पर स्विच करें," "प्रोजेक्ट का विवरण जनरेट करें" — इन चीज़ों को मॉडल के साथ "चैट" करके हल नहीं किया जाना चाहिए, बल्कि इनके लिए एक प्रत्यक्ष स्विच (direct switch) होना चाहिए। स्लैश कमांड इन स्विच का एकीकृत (unified) प्रवेश द्वार है।

समानता (Analogy): आपके टीवी रिमोट कंट्रोल पर प्रिंट किए गए बटनों की पंक्ति। जब आप टीवी देखते हैं, तो आप चैनल बदलते हैं, वॉल्यूम एडजस्ट करते हैं, स्रोत (source) बदलते हैं, मेनू खोलते हैं — आप टीवी पर यह नहीं चिल्लाते, "कृपया वॉल्यूम बढ़ा दें," आप रिमोट पर संबंधित बटन दबाते हैं। प्रत्येक बटन एक विशिष्ट कार्य करता है, और इसे दबाते ही वह तुरंत प्रभावी हो जाता है, बिना किसी स्पष्टीकरण की आवश्यकता के और बिना गलत समझे जाने के जोखिम के। स्लैश कमांड Claude Code के बटनों की इस पंक्ति की तरह हैं: /clear क्लियर-स्क्रीन बटन है, /model स्रोत-स्विच बटन है, /help मेनू बटन है — जब आप उन्हें टाइप करते हैं, तो वे प्रोग्राम में हार्ड-कोड किए गए फिक्स्ड एक्शन करते हैं, जो "मॉडल से मदद मांगने" से बिल्कुल अलग है।

आधिकारिक दस्तावेज़ में इसकी भूमिका स्पष्ट रूप से बताई गई है:

Commands एक सेशन के भीतर से Claude Code को नियंत्रित करते हैं। वे मॉडल स्विच करने, अनुमतियों को मैनेज करने, कॉन्टेक्स्ट साफ़ करने, वर्कफ़्लो चलाने आदि का एक त्वरित तरीका प्रदान करते हैं।

यहाँ एक बिंदु है जहाँ शुरुआती लोग सबसे अधिक गलती करते हैं, और आधिकारिक दस्तावेज़ विशेष रूप से इस पर जोर देता है — स्लैश कमांड केवल संदेश की शुरुआत में पहचाने जाते हैं:

Commands केवल एक संदेश की शुरुआत में पहचाने जाते हैं। कमांड नाम के बाद का टेक्स्ट इसे पैरामीटर (argument) के रूप में पास किया जाता है।

सरल शब्दों में: आपको इस संदेश का पहला कैरेक्टर / बनाना होगा, तभी इसे एक कमांड माना जाएगा। यदि आप लिखते हैं "कृपया मुझे बताएं कि /clear क्या करता है," तो /clear वाक्य के बीच में है, यह निष्पादित (executed) नहीं होगा, इसे केवल सामान्य टेक्स्ट के रूप में Claude को भेजा जाएगा। इस डिज़ाइन का एक अच्छा कारण है — अन्यथा, जब भी आप कमांड के बारे में Claude के साथ चर्चा करते हैं और /clear का उल्लेख करते हैं, तो बातचीत साफ़ हो जाएगी, जो एक आपदा होगी। याद रखें: कमांड हमेशा पहले आता है, और इसके बाद जो कुछ भी होता है वह पैरामीटर होता है।

आइए कुछ वास्तविक जीवन के क्षणों को देखें जहां आप बटनों की इस "पंक्ति" का उपयोग करेंगे:

• चैट करते समय, आपको पता चलता है कि मॉडल पर्याप्त शक्तिशाली नहीं है — बाहर निकलने और पुनः आरंभ करने की कोई आवश्यकता नहीं है, बस /model टाइप करें और बातचीत को जारी रखते हुए अधिक शक्तिशाली मॉडल पर स्विच करें।
• एक कार्य पूरा हो गया है, और आप एक नया कार्य शुरू करना चाहते हैं — बोर्ड को साफ़ करने के लिए /clear टाइप करें, और पुरानी बातचीत को अभी भी /resume का उपयोग करके पुनर्प्राप्त (recovered) किया जा सकता है।
• अभी एक अपरिचित प्रोजेक्ट को क्लोन (clone) किया है, और चाहते हैं कि Claude पहले इसे समझे — /init टाइप करें, यह कोड को पढ़ेगा और आपके लिए एक CLAUDE.md थूकेगा (spit out)।

इन चीज़ों में क्या समानता है: वे "Claude से कोड लिखवाने" के बारे में नहीं हैं, बल्कि "Claude Code को ही एडजस्ट करने" के बारे में हैं — और यहीं स्लैश कमांड चमकते हैं।

तो आपको कैसे पता चलेगा कि कौन से कमांड उपलब्ध हैं? सबसे आसान तरीका — सेशन में / टाइप करें, और मेनू तुरंत पॉप अप हो जाएगा, जिसमें वे सभी कमांड होंगे जिनका आप वर्तमान में उपयोग कर सकते हैं; फिर कुछ और अक्षर टाइप करें, और यह इसे रीयल-टाइम में फ़िल्टर करेगा। आधिकारिक शब्द:

अपने लिए उपलब्ध प्रत्येक कमांड को देखने के लिए / टाइप करें, या फ़िल्टर करने के लिए / के बाद अक्षर टाइप करें।

💡 सारांश: स्लैश कमांड Claude Code के "कंट्रोल बटन" हैं — वे प्रोग्राम को ही मैनेज करते हैं (मॉडल बदलना, कॉन्टेक्स्ट साफ़ करना, वर्कफ़्लो चलाना), मॉडल को कार्य सौंपना नहीं; वे केवल संदेश के शुरुआत में काम करते हैं, और आप सभी उपलब्ध कमांड देखने के लिए बस / टाइप कर सकते हैं।

---

02 बिल्ट-इन कमांड की सूची: इन्हें याद न करें, बस आप जो कर रहे हैं उसके आधार पर देखें

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

पहले एक बात स्पष्ट कर दें: इन दर्जनों कमांड में से, अधिकांश "बिल्ट-इन कमांड (built-in commands)" हैं (इनका व्यवहार CLI में हार्डकोड किया गया है, और दबाए जाने पर ये एक निश्चित लॉजिक निष्पादित करते हैं), और कुछ को दस्तावेज़ों में Skill के रूप में चिह्नित किया गया है — वे "बंडल की गई स्किल्स (bundled Skills)" हैं, जो अनिवार्य रूप से Claude के लिए एक प्रॉम्प्ट हैं, इसे कार्य पूरा करने के लिए अपने स्वयं के टूल्स को व्यवस्थित करने के लिए कहते हैं (उदाहरण के लिए, /code-review, /debug)। और भी कम कमांड हैं जिन्हें Workflow के रूप में चिह्नित किया गया है — वे समानांतर में चलने वाले कई सब-एजेंट्स (subagents) के साथ गतिशील प्रक्रियाएं (dynamic processes) हैं (उदाहरण के लिए, /batch, /deep-research), कॉलिंग अनुभव समान है, लेकिन अंतर्निहित कार्यान्वयन (underlying implementation) अधिक जटिल है; बस इतना जान लें कि उनका अस्तित्व है। आप इन तीनों को नाम के बाद / का उपयोग करके कॉल कर सकते हैं, उपयोग में कोई अंतर नहीं है, अंतर केवल इस बात में है कि उन्हें कैसे कार्यान्वित (implemented) किया जाता है — लेख 26 में Skills पर चर्चा करते समय इस विवरण को तोड़ा गया था, इसलिए हम यहाँ विस्तार से नहीं बताएँगे।

समूह 1: एक नया प्रोजेक्ट शुरू करते समय स्टेज सेट करना

कमांड	यह क्या करता है	आप इसका कब उपयोग करते हैं
/init	प्रोजेक्ट के लिए एक प्रारंभिक CLAUDE.md जनरेट करता है	जब आप किसी रिपॉजिटरी में पहली बार काम शुरू करते हैं (विवरण के लिए लेख 12 देखें)
/memory	CLAUDE.md मेमोरी फ़ाइल को एडिट करता है और ऑटो-मेमोरी को मैनेज करता है	/init के बाद जब आप उस निर्देश को फाइन-ट्यून (fine-tune) करना चाहते हैं (विवरण के लिए लेख 25 देखें)
/mcp	MCP सर्वर कनेक्शन और प्राधिकरण (authorization) को मैनेज करता है	जब आपको बाहरी सेवाओं से जुड़ने की आवश्यकता होती है (विवरण के लिए लेख 22 देखें)
/agents	सब-एजेंट (subagent) कॉन्फ़िगरेशन को मैनेज करता है	जब आपको विशिष्ट सब-एजेंट कॉन्फ़िगर करने की आवश्यकता होती है (विवरण के लिए लेख 23 देखें)
/permissions	"अनुमति दें (allow) / पूछें (ask) / अस्वीकार करें (deny)" अनुमति नियमों को मैनेज करता है	जब आप यह तय करना चाहते हैं कि यह कार्य करने से पहले आपसे पूछे या नहीं (विवरण के लिए लेख 20 देखें)

यह समूह किसी नए प्रोजेक्ट में प्रवेश करते समय अनिवार्य रूप से निश्चित दिनचर्या (fixed routine) है: पहले /init ताकि यह कोड को पढ़ सके और एक CLAUDE.md ड्राफ्ट निकाल सके, फिर /memory में जाकर उन कुछ चीज़ों को ठीक कर सके जिनका इसने गलत अनुमान लगाया है। यह आपको स्क्रैच से उन निर्देशों को लिखने से बचाता है — जब आप पहली बार इस वर्कफ़्लो का उपयोग करते हैं, तो यह वास्तव में काफी आश्चर्यजनक होता है।

समूह 2: काम के दौरान स्थिति को एडजस्ट करना

कमांड	यह क्या करता है	आप इसका कब उपयोग करते हैं
/model	मॉडल को स्विच करता है, और इसे नए सेशन के लिए डिफ़ॉल्ट के रूप में सहेजता है	जब आप अधिक शक्तिशाली या अधिक किफायती (economical) मॉडल पर स्विच करना चाहते हैं
/clear	खाली कॉन्टेक्स्ट के साथ एक नई बातचीत शुरू करता है (पुरानी बातचीत को अभी भी /resume के माध्यम से पुनर्प्राप्त किया जा सकता है)	जब आप पूरी तरह से नया कार्य शुरू करना चाहते हैं और बोर्ड को साफ़ करना चाहते हैं
/compact	वर्तमान बातचीत को एक सारांश (summary) में संकुचित (compresses) करता है, ताकि आप चैट करना जारी रख सकें	जब बातचीत बहुत लंबी हो जाती है और कार्यक्षेत्र लगभग भर जाता है (विवरण के लिए लेख 19 देखें)
/context	एक रंगीन ग्रिड (colored grid) के रूप में वर्तमान कॉन्टेक्स्ट के उपयोग को ड्रा करता है	जब आप देखना चाहते हैं "मेरे कार्यक्षेत्र (workspace) पर किसका कब्ज़ा है"
/plan	सीधे योजना मोड (plan mode) में प्रवेश करता है	प्रमुख बदलाव करने से पहले इसे बिना छुए एक योजना बनाने देने के लिए

/clear और /compact मिलाने में सबसे आसान हैं, और शुरुआत में जिस नुकसान का उल्लेख किया गया था वह "साफ़ करने" और "संकुचित करने" के बीच अंतर न कर पाने के कारण था। इसे एक वाक्य में संक्षेप में प्रस्तुत करने के लिए: असंबंधित नए कार्य पर स्विच करते समय /clear का उपयोग करें (बोर्ड को साफ़ करें और फिर से शुरू करें), और /compact का उपयोग तब करें जब यह एक ही कार्य हो लेकिन बातचीत बहुत लंबी हो गई हो (अपने ड्राफ्ट पेपर को बुलेट पॉइंट्स के एक पृष्ठ में व्यवस्थित करें और जारी रखें)। लेख 19 ने विशेष रूप से इस जोड़ी को तोड़ा है, इसलिए अभी के लिए, बस याद रखें "कार्यों को बदलने के लिए clear, कार्यों को जारी रखने के लिए compact।"

समूह 3: सौंपने से पहले काम की जाँच करना

कमांड	यह क्या करता है
/diff	एक इंटरैक्टिव diff व्यूअर खोलता है, ताकि बिना कमिट किए गए बदलावों (uncommitted changes) को देखा जा सके
/review	वर्तमान सेशन के भीतर एक PR (Pull Request) की समीक्षा (review) करता है
/security-review	वर्तमान शाखा में बदलावों को विशेष रूप से सुरक्षा कमजोरियों (security vulnerabilities) के लिए स्कैन करता है
/code-review	बग्स और सरलीकरण (simplification) के क्षेत्रों को खोजने के लिए diff की समीक्षा करता है, सीधे ठीक करने के लिए --fix जोड़ सकता है

समूह 4: विविध कमांड जिनका आप अंततः उपयोग करेंगे

कमांड	यह क्या करता है
/help	सहायता और उपलब्ध कमांड दिखाता है
/config	सेटिंग्स इंटरफ़ेस खोलता है, थीम, मॉडल, आउटपुट शैलियाँ आदि एडजस्ट करने के लिए
/doctor	आपके इंस्टॉलेशन और कॉन्फ़िगरेशन की जाँच (health check) करता है, इसे स्वचालित रूप से ठीक करने के लिए f दबाएं
/resume	ID या नाम से पुरानी बातचीत को फिर से शुरू करता है, या एक चयनकर्ता (selector) खोलता है
/skills	वर्तमान में उपलब्ध सभी Skills की सूची बनाता है
/rewind	बातचीत और/या कोड को एक विशिष्ट चेकपॉइंट पर वापस लाता है (अगले लेख का मुख्य विषय)

ध्यान दें: हर कमांड हर किसी को दिखाई नहीं देता है। आधिकारिक दस्तावेज़ स्पष्ट रूप से बताता है — "उपलब्धता आपके प्लेटफॉर्म, योजना (plan), और वातावरण पर निर्भर करती है।" उदाहरण के लिए, /desktop केवल macOS और Windows पर दिखाई देता है, और तभी जब आप Claude सब्सक्रिप्शन के साथ लॉग इन करते हैं; /upgrade केवल Pro और Max योजनाओं पर उपलब्ध है। जो मेनू आप / टाइप करने पर देखते हैं वह आपके लिए उस मशीन पर, उस समय उस खाते के साथ वास्तव में उपलब्ध कमांड का पूरा सेट है — इस पर भरोसा करें, और दूसरे लोगों के स्क्रीनशॉट में मौजूद कमांड को लेकर परेशान न हों।

मैंने इन चार समूहों (आधिकारिक मास्टर सूची में दर्जनों पंक्तियाँ हैं) में सब कुछ शामिल नहीं किया है, लेकिन वे आपके रोज़मर्रा के 90% परिदृश्यों (scenarios) को कवर करते हैं। बाकी के लिए, जब आप कुछ करना चाहते हैं, तो बस / टाइप करें और फ़िल्टर करने के लिए कुछ अक्षर जोड़ें, यह दस्तावेज़ को खंगालने से बहुत अधिक व्यावहारिक है।

💡 सारांश: बिल्ट-इन कमांड को याद न रखें, उन्हें "आप किस चरण में हैं" के आधार पर समूहीकृत करें — स्टेज सेट करना (/init /memory /mcp /agents), काम के दौरान (/model /clear /compact /context), सौंपने से पहले (/diff /review /code-review), और विविध (/help /doctor /resume); मेनू आपके मशीन का वास्तविक पूर्ण सेट है, बस इसे देखने के लिए / टाइप करें।

---

03 अपना खुद का कमांड बनाना: बस .claude/commands/ में एक मार्कडाउन फ़ाइल छोड़ें

बिल्ट-इन कमांड को समझना एक बात है, लेकिन वास्तव में स्लैश कमांड को उपयोगी बनाने वाली चीज़ उन्हें स्वयं बनाने की आपकी क्षमता है।

आपको उन्हें स्वयं क्यों बनाना चाहिए? Claude के साथ अपने रोज़मर्रा के व्यवहार में उन "दोहराए जाने वाले कार्यों (repetitive tasks)" के बारे में सोचें — हर बार जब आप इसे कोड सबमिट (commit) करने के लिए कहते हैं, तो आप इसे समान नियमों की याद दिलाते हैं; हर बार जब आप किसी PR की समीक्षा करते हैं, तो आप वही शुरुआती पैराग्राफ टाइप करते हैं; हर बार जब आप कोड समझाते हैं, तो आप इस बात पर ज़ोर देते हैं कि "साधारण शब्दों में बोलें, जार्गन (jargon) से बचें।" जब आप एक ही प्रॉम्प्ट को पाँचवीं बार टाइप करते हैं, तो यह एक संकेत है: इसे एक कमांड में बदलने का समय आ गया है।

समानता (Analogy): आपके रिमोट कंट्रोल के लिए "लर्निंग बटन" प्रोग्राम करना। एक अच्छे यूनिवर्सल रिमोट में "लर्निंग बटन" होता है — आप आमतौर पर उपयोग किए जाने वाले कार्यों (जैसे टीवी चालू करना → HDMI2 पर स्विच करना → वॉल्यूम को 15 पर सेट करना) को रिकॉर्ड कर सकते हैं, और फिर आप जब भी वह बटन दबाते हैं, तो ऑपरेशन्स की पूरी श्रृंखला स्वचालित रूप से चल जाती है, बिना आपको उन्हें एक-एक करके दबाए। कस्टम स्लैश कमांड यह लर्निंग बटन है: आप एक प्रॉम्प्ट को जिसे आप बार-बार टाइप करते हैं उसे एक कमांड में "रिकॉर्ड" करते हैं, और भविष्य में जब आप कमांड नाम टाइप करते हैं, तो वह प्रॉम्प्ट स्वचालित रूप से भेज दिया जाता है।

आप इसे कैसे बनाते हैं? यह इतना सरल है कि आपको शायद विश्वास न हो — बस .claude/commands/ डायरेक्टरी में एक मार्कडाउन (markdown) फ़ाइल छोड़ दें, और फ़ाइल का नाम कमांड का नाम बन जाएगा। आधिकारिक दस्तावेज़ इसे बहुत स्पष्ट रूप से बताता है:

.claude/commands/deploy.md में एक फ़ाइल... /deploy बनाएगी।

यानी, आप एक .claude/commands/commit.md बनाते हैं और उसमें अपने कमिट नियम लिखते हैं, और यह स्वचालित रूप से /commit कमांड बन जाता है। फ़ाइल का नाम (बिना .md एक्सटेंशन के) वह कमांड नाम है जिसे आप टाइप करते हैं, शून्य कॉन्फ़िगरेशन (zero configuration) के साथ।

आइए एक बहुत ही सरल उदाहरण लेते हैं। आप .claude/commands/review.md बनाते हैं और लिखते हैं:

कृपया मेरे वर्तमान अनकमिट किए गए बदलावों (uncommitted changes) की समीक्षा करें, इन तीन बातों पर ध्यान केंद्रित करें:
1. क्या कोई गायब एरर हैंडलिंग है?
2. क्या कोई हार्डकोड की गई (hardcoded) कॉन्फ़िगरेशन वैल्यू हैं (पोर्ट, कुंजियां, पथ)?
3. क्या कोई ऐसे परीक्षण (tests) हैं जिन्हें जोड़ा जाना चाहिए था लेकिन नहीं जोड़ा गया?

उन्हें एक-एक करके हिंदी में सूचीबद्ध करें, और इंगित करें कि प्रत्येक किस फ़ाइल में है।

इसे सहेजने के बाद, जब आप सेशन में /review टाइप करते हैं, तो Claude को ऊपर दिया गया पूरा प्रॉम्प्ट प्राप्त होता है — यह वैसा ही है जैसे आपने उस पूरे पैराग्राफ को शब्दशः टाइप किया हो, लेकिन आपने केवल सात कैरेक्टर टाइप किए।

यहां "इसे कहां रखना है" के बारे में एक महत्वपूर्ण भेद (distinction) है, जो MCP और Skills (लेख 26 में कवर किया गया) के समान है:

इसे कहां रखें	कमांड का दायरा (Scope)	क्या यह git में जाता है
प्रोजेक्ट-स्तर (Project-level) .claude/commands/	केवल यह वर्तमान प्रोजेक्ट	हाँ, पूरी टीम इसे पुल (pull) करके उपयोग कर सकती है
व्यक्तिगत-स्तर (Personal-level) ~/.claude/commands/	आपके सभी प्रोजेक्ट्स	नहीं, यह आपका निजी (private) है

लॉजिक ठीक वैसा ही है जैसा Skill के लिए है: यदि कमांड इस प्रोजेक्ट के लिए अनन्य (exclusive) है और आप चाहते हैं कि सहयोगी (collaborators) भी इसका उपयोग करें (जैसे इस प्रोजेक्ट के लिए रिलीज़ प्रक्रिया), तो इसे प्रोजेक्ट स्तर पर रखें और इसे वर्ज़न कंट्रोल (version control) में कमिट करें; यदि यह केवल आपके लिए है और सभी प्रोजेक्ट्स में उपयोग किया जा सकता है (जैसे कोड को समझाने की आपकी व्यक्तिगत आदत), तो इसे व्यक्तिगत स्तर पर ~/.claude/commands/ में रखें। ~/.claude/commands/ में हमेशा कुछ क्रॉस-प्रोजेक्ट कमांड होते हैं जो आप चाहे जिस भी प्रोजेक्ट पर स्विच करें, हमेशा मौजूद रहते हैं, जो प्रत्येक प्रोजेक्ट को फिर से कॉन्फ़िगर करने से कहीं अधिक सुविधाजनक है।

💡 सारांश: कस्टम कमांड का अर्थ है "बार-बार टाइप किए गए प्रॉम्प्ट को एक-क्लिक कमांड में रिकॉर्ड करना" — बस .claude/commands/ में एक मार्कडाउन फ़ाइल छोड़ दें, फ़ाइल का नाम कमांड का नाम है, शून्य कॉन्फ़िगरेशन (zero configuration); प्रोजेक्ट-स्तर पूरी टीम के साथ साझा किया जाता है, व्यक्तिगत स्तर ~/.claude/commands/ सभी प्रोजेक्ट्स के लिए है।

---

04 अपने कमांड को मसाला देना: फ्रंटमैटर (frontmatter) और $ARGUMENTS

आपका /review कमांड पिछले अनुभाग में पहले से ही प्रयोग करने योग्य है, लेकिन इसकी एक स्पष्ट सीमा है: सामग्री हार्डकोड की गई है और आप पैरामीटर (parameters) पास नहीं कर सकते हैं। आप इसे यह नहीं बता सकते कि "केवल इस एक फ़ाइल src/auth.ts की समीक्षा करें" — यह हर बार सभी बदलावों की समीक्षा करेगा। अपने कमांड को लचीला बनाने के लिए, आपको दो चीज़ें जोड़नी होंगी: फ्रंटमैटर (frontmatter) और पैरामीटर प्लेसहोल्डर (parameter placeholders)।

आपके द्वारा पास किए गए मापदंडों (parameters) को पकड़ने के लिए $ARGUMENTS का उपयोग करें

आइए पहले पैरामीटर पास करने की समस्या को हल करें। Claude Code एक प्लेसहोल्डर $ARGUMENTS प्रदान करता है — जो कुछ भी आप कमांड नाम के बाद टाइप करते हैं वह इस प्लेसहोल्डर को बदल देगा। आधिकारिक दस्तावेज़ से उदाहरण सबसे स्पष्ट है:

हमारे कोडिंग मानकों का पालन करते हुए GitHub अंक $ARGUMENTS को ठीक करें।

1. समस्या का विवरण पढ़ें
2. आवश्यकताओं को समझें
3. सुधार (fix) को लागू करें

आधिकारिक दस्तावेज़ इसके प्रभाव को स्पष्ट करता है:

जब आप /fix-issue 123 चलाते हैं, तो Claude को प्राप्त होता है "हमारे कोडिंग मानकों का पालन करते हुए GitHub अंक 123 को ठीक करें..."

क्या आप इसे देखते हैं? जब आप /fix-issue 123 टाइप करते हैं, तो वह 123 $ARGUMENTS की स्थिति में डाल दिया जाता है। एक कमांड टेम्प्लेट (template), आप जैसे चाहें वैसे पैरामीटर बदल सकते हैं — यही वह जगह है जहां कमांड वास्तव में उपयोगी हो जाते हैं।

एक विचारशील फ़ॉलबैक (fallback) भी है: आधिकारिक दस्तावेज़ कहता है, यदि आप पैरामीटर पास करते हैं लेकिन कमांड में $ARGUMENTS नहीं लिखते हैं, तो Claude Code स्वचालित रूप से कमांड सामग्री के अंत में ARGUMENTS: <your input> जोड़ देगा, "ताकि Claude अभी भी वह देख सके जो आपने टाइप किया है।" इसलिए भले ही आप प्लेसहोल्डर लिखना भूल जाएं, पैरामीटर हवा में गायब नहीं होंगे।

क्या आप कई पैरामीटर पास करना चाहते हैं? उन्हें स्थिति (position) के अनुसार प्राप्त करने के लिए $0 $1 का उपयोग करें

क्या होगा यदि कमांड को कई पैरामीटर की आवश्यकता हो? उदाहरण के लिए, "SearchBar घटक (component) को React से Vue में माइग्रेट (migrate) करें", यहाँ तीन स्वतंत्र मान (independent values) हैं। आधिकारिक दस्तावेज़ स्थिति के अनुसार पैरामीटर प्राप्त करने का एक तरीका प्रदान करता है — $ARGUMENTS[N], या छोटा संस्करण $N (दोनों 0 से गिनना शुरू करते हैं):

$0 घटक को $1 से $2 में माइग्रेट करें।
सभी मौजूदा व्यवहार और परीक्षणों को सुरक्षित रखें।

आप /migrate-component SearchBar React Vue चलाते हैं, $0 SearchBar है, $1 React है, और $2 Vue है। एक बात का ध्यान रखें: आधिकारिक दस्तावेज़ कहता है कि स्थिति (position) के अनुसार प्राप्त किए गए ये पैरामीटर "शेल-स्टाइल कोटिंग (shell-style quoting)" का पालन करते हैं — इसलिए यदि किसी मान में कई शब्द हैं, तो उसे एक पैरामीटर माने जाने के लिए कोट्स (quotes) में लपेटा जाना चाहिए। उदाहरण के लिए, /my-cmd "hello world" second, $0 पूरा hello world होगा, अन्यथा यह स्पेस से अलग हो जाएगा। (हालाँकि, $ARGUMENTS प्रभावित नहीं होता है, यह हमेशा आपके द्वारा टाइप की गई पूरी मूल स्ट्रिंग (original string) होती है।)

कमांड के व्यवहार को नियंत्रित करने के लिए फ्रंटमैटर (frontmatter) का उपयोग करें

केवल पैरामीटर पास करने में सक्षम होना पर्याप्त नहीं है। आपके /deploy और /commit कमांड के साइड इफेक्ट्स (side effects) होते हैं — आप निश्चित रूप से नहीं चाहते कि Claude "यह सोचकर कि आपका कोड तैयार लग रहा है", इसे अपने आप डिप्लॉय (deploy) करने का निर्णय ले ले। यहीं फ्रंटमैटर काम आता है।

फ्रंटमैटर (frontmatter) फ़ाइल की शुरुआत में दो --- के बीच लिखा गया YAML कॉन्फ़िगरेशन का एक ब्लॉक है (यह अवधारणा लेख 26 में SKILL.md पर चर्चा करते समय देखी गई थी, कस्टम कमांड फ़ाइलें बिल्कुल समान फ्रंटमैटर का समर्थन करती हैं)। जानने के लिए दो सबसे महत्वपूर्ण फ़ील्ड (fields):

---
description: वर्तमान बदलावों (changes) को स्टेज (stage) और कमिट (commit) करें
disable-model-invocation: true
---

वर्तमान बदलावों को कमिट करें, कमिट संदेश में हिंदी का उपयोग करें, और feat/fix/docs के अनुसार उपसर्ग (prefix) जोड़ें:

1. पहले टेस्ट सूट चलाएं
2. बदलावों को git add करें
3. सबमिट करने के लिए एक मानकीकृत (standardized) हिंदी संदेश का उपयोग करें

• description: यह कमांड क्या करता है, इसका एक-वाक्य का स्पष्टीकरण। Claude इसका उपयोग यह तय करने के लिए करता है कि "क्या इस कमांड का स्वचालित रूप से उपयोग करना है", इसलिए इसे हमेशा शामिल करने की अनुशंसा की जाती है।
• disable-model-invocation: true: इसे true पर सेट करने का मतलब है कि यह कमांड केवल आपके द्वारा मैन्युअल रूप से कॉल किया जा सकता है, Claude इसे स्वचालित रूप से ट्रिगर नहीं करेगा। साइड इफेक्ट्स वाले कमांड (डिप्लॉयमेंट, कमिटमेंट, संदेश भेजना) जिन्हें आप मैन्युअल रूप से नियंत्रित करना चाहते हैं, उनमें यह शामिल होना चाहिए।

यह एक ऐसी अवधारणा (concept) की ओर ले जाता है जिसे आपको समझना चाहिए, ताकि यह आपको अपने "अनधिकृत (unauthorized) कार्यों" से डराए नहीं — आपके कस्टम कमांड डिफ़ॉल्ट रूप से "आपके और Claude दोनों द्वारा कॉल करने योग्य (callable)" होते हैं। जब आप /commit टाइप करते हैं, तो आप इसे मैन्युअल रूप से कॉल कर रहे होते हैं; लेकिन क्योंकि आपने एक description लिखा है, Claude इसे स्वयं भी कॉल कर सकता है जब उसे लगता है कि यह मेल खाता है। यह इस बात का प्रतिबिंब है कि स्लैश कमांड और Skills "एक ही चीज़" हैं (विवरण के लिए लेख 26 देखें) — यदि आप डरते हैं कि यह स्वचालित रूप से कार्य करेगा, तो इसे केवल मैन्युअल (manual-only) के रूप में लॉक करने के लिए disable-model-invocation: true जोड़ें। /commit जैसे कमांड में यह पहली चीज़ होनी चाहिए, अन्यथा, यह वास्तव में आपके अनरीड बदलावों (unread changes) को सबमिट कर सकता है।

आप क्या प्रभाव चाहते हैं	क्या फ्रंटमैटर जोड़ें
कमांड के साइड इफेक्ट्स हैं, केवल मुझे इसे मैन्युअल रूप से कॉल करने की अनुमति है	disable-model-invocation: true
Claude को बताएं कि इस कमांड का उपयोग कब करना है	एक अच्छा description लिखें
सक्रिय (active) होने पर इसके द्वारा उपयोग किए जा सकने वाले टूल को सीमित करें ताकि यह हर बार न पूछे	allowed-tools: Bash(git add *) Bash(git commit *)

💡 सारांश: कमांड नाम के बाद सभी इनपुट को पकड़ने के लिए $ARGUMENTS, स्थिति (position) के अनुसार पैरामीटर प्राप्त करने के लिए $0/$1 (बहु-शब्द (multi-word) मानों के लिए कोट्स की आवश्यकता होती है); फ्रंटमैटर में description Claude को बताता है कि इसका उपयोग कब करना है, और disable-model-invocation: true इसे केवल मैन्युअल उपयोग के लिए लॉक करता है — साइड इफेक्ट्स वाले कमांड में हमेशा बाद वाला होना चाहिए।

---

05 उन्नत तरकीब (Advanced trick): कमांड को अपना खुद का "लाइव डेटा (live data)" लाने दें

यहाँ तक कि आपका कमांड पैरामीटर पास कर सकता है, लेकिन एक और भी ज़्यादा शक्तिशाली तरकीब है — कमांड को Claude के पास भेजने से पहले, उसे अपने आप लाइव डेटा (live data) भरने दें। इसे डायनेमिक कॉन्टेक्स्ट इंजेक्शन (dynamic context injection) कहा जाता है, और यह कस्टम कमांड फ़ाइलों की सबसे कम आंकी गई (underestimated) क्षमता है।

आइए पहले बात करते हैं कि यह क्या हल करता है। आपका /review कमांड कहता है "कृपया मेरे वर्तमान अनकमिट किए गए बदलावों (uncommitted changes) की समीक्षा करें" — लेकिन जब Claude को यह वाक्य मिलता है, तो उसे यह जानने के लिए कि आपने क्या बदला है, git diff स्वयं चलाना पड़ता है। क्या कमांड के पढ़े जाने से पहले diff को सीधे डालना संभव है? हाँ।

सिंटैक्स (syntax) कमांड में !`command` लिखना है — एक विस्मयादिबोधक चिह्न (exclamation mark) के साथ बैकटिक्स (backticks) में एक शेल कमांड। आधिकारिक दस्तावेज़ इसे बहुत स्पष्ट रूप से समझाता है:

!`<command>` सिंटैक्स Claude को कंटेंट भेजने से पहले एक शेल कमांड चलाता है। कमांड आउटपुट प्लेसहोल्डर को बदल देता है, इसलिए Claude कमांड के बजाय वास्तविक डेटा प्राप्त करता है।

आइए एक उदाहरण देखें और /review को अपग्रेड करें। आप अपने .claude/commands/review.md में यह लिखते हैं:

## वर्तमान बदलाव (Current Changes)

!`git diff HEAD`

## निर्देश (Instructions)

उपरोक्त बदलावों की समीक्षा करें, गायब एरर हैंडलिंग, हार्डकोड की गई (hardcoded) कॉन्फ़िगरेशन वैल्यू, और ऐसे परीक्षणों (tests) पर ध्यान केंद्रित करें जिन्हें जोड़ा जाना चाहिए था। उन्हें एक-एक करके हिंदी में सूचीबद्ध करें।

उस !`git diff HEAD` लाइन का क्या होगा? आधिकारिक निष्पादन अनुक्रम (execution sequence) इस प्रकार है:

1. Claude Code पहले git diff HEAD चलाता है
2. यह उस कमांड के आउटपुट (output) के साथ लाइन को बदल देता है
3. Claude जो देखता है वह पूरा प्रॉम्प्ट है जो आपके वास्तविक diff से भरा हुआ है

दूसरे शब्दों में, Claude को जो मिलता है वह "diff चलाओ" नहीं है, बल्कि "यहाँ उपयोगकर्ता के बदलाव हैं: ... (वास्तविक सामग्री), कृपया समीक्षा करें" है। यह एक प्री-प्रोसेसिंग (pre-processing) चरण है, यह ऐसा कुछ नहीं है जिसे Claude स्वयं निष्पादित करता है — यह केवल अंतिम भरा हुआ परिणाम देखता है। इस लाइन को /review में जोड़ने के बाद, आप स्पष्ट रूप से महसूस करेंगे कि यह "तुरंत काम पर लग जाता है" बजाय इसके कि पहले बदलावों की जांच करने के लिए चारों ओर चक्कर लगाए।

कुछ विवरण जिन्हें आपको उपयोग करने से पहले जानना चाहिए, ताकि आप गड्ढों में न गिरें:

• विस्मयादिबोधक चिह्न (exclamation mark) लाइन के आरंभ में, या सीधे खाली स्थान (whitespace) के बाद होना चाहिए ताकि यह काम कर सके। यदि आप KEY=!cmd`` जैसी कोई चीज़ लिखते हैं, जो अन्य कैरेक्टर्स के ठीक बगल में है, तो इसे सामान्य टेक्स्ट के रूप में माना जाएगा और कमांड नहीं चलेगा।
• मल्टी-लाइन (Multi-line) कमांड को इनलाइन (inline) नहीं लिखा जाना चाहिए, इसके बजाय ```! से शुरू होने वाले फेंस्ड कोड ब्लॉक्स (fenced code blocks) का उपयोग करें (अंदर प्रति पंक्ति एक कमांड)।
• यह क्षमता बंद (disabled) की जा सकती है: सेटिंग्स में एक disableSkillShellExecution विकल्प है, यदि इसे true पर सेट किया जाता है, तो ये कमांड निष्पादित (executed) नहीं होंगे और अंग्रेजी प्रॉम्प्ट [shell command execution disabled by policy] से बदल दिए जाएंगे। यह टीम की होस्ट की गई सेटिंग्स में सबसे उपयोगी है — किसी को साझा रिपॉजिटरी के कमांड में एक शेल कमांड डालने से रोकने के लिए जो बेतरतीब ढंग से चलता है।

ऑटो-कम्प्लीशन (auto-completion) के लिए एक त्वरित टिप: फ्रंटमैटर में एक argument-hint पंक्ति जोड़ें (उदाहरण के लिए argument-hint: [issue-number]), और जब आप कमांड नाम टाइप करते हैं, तो ऑटो-कम्प्लीशन प्रॉम्प्ट करेगा कि "इस कमांड को कौन से पैरामीटर पास किए जाने चाहिए।" जब आपके पास बहुत सारे कमांड हों, तो यह टिप आपको दस्तावेज़ खंगालने से बचा सकती है।

💡 सारांश: !`command` स्लैश कमांड को Claude को भेजने से पहले लाइव डेटा (जैसे git diff) से भरने की अनुमति देता है, इसलिए Claude को "कमांड चलाने के लिए" जाने के बजाय वास्तविक डेटा प्राप्त होता है; विस्मयादिबोधक चिह्न लाइन के आरंभ में होना चाहिए, मल्टी-लाइन के लिए ```! ब्लॉक का उपयोग करें, और टीमें इसे disableSkillShellExecution के साथ एक-क्लिक में अक्षम (disable) कर सकती हैं।

---

06 नेमस्पेस (Namespaces): प्लगइन कमांड कभी भी नाम से क्यों नहीं टकराते

एक बार जब आप अपना खुद का कमांड बना लेते हैं और कुछ प्लगइन्स इंस्टॉल कर लेते हैं (प्रत्येक प्लगइन कमांड के एक सेट के साथ आता है), तो एक वास्तविक समस्या उत्पन्न होती है: क्या वे नाम से टकराएंगे? उदाहरण के लिए, यदि आप /review लिखते हैं, और आपके द्वारा इंस्टॉल किए गए प्लगइन में भी /review है, तो जब आप इसे टाइप करते हैं तो कौन सा चलता है?

आइए पहले बात करते हैं कि कौन सा टकराएगा और कौन सा नहीं, कुंजी इस बात पर निर्भर करती है कि कमांड कहाँ से आता है।

आपके स्वयं के कमांड के बीच: प्राथमिकता (priority) विजेता तय करती है

यदि आपकी अपनी .claude/commands/ फ़ाइल और .claude/skills/ में एक Skill का नाम समान है — आधिकारिक दस्तावेज़ स्पष्ट नियम देता है:

यदि किसी skill और कमांड का नाम समान है, तो skill को प्राथमिकता दी जाती है।

दूसरे शब्दों में, यदि आपके पास .claude/commands/deploy.md है और .claude/skills/deploy/SKILL.md भी है, तो /deploy टाइप करने पर वह Skill चलेगा। बस इस नियम को याद रखें कि "समान नाम वाली Skill जीतती है", और आप शायद ही कभी जानबूझकर एक ही नाम वाले दो कमांड बनाएंगे।

प्लगइन्स के साथ आने वाले कमांड: नेमस्पेस (namespaces) पर निर्भर करते हैं, वे बिल्कुल नहीं टकराएंगे

प्लगइन्स को संभालने का तरीका अधिक गहन (thorough) है — वे आपके नामों के साथ प्रतिस्पर्धा (compete) भी नहीं करते हैं। आधिकारिक शब्द:

प्लगइन skills plugin-name:skill-name नेमस्पेस (namespace) का उपयोग करते हैं, इसलिए वे अन्य स्तरों (levels) के साथ संघर्ष (conflict) नहीं कर सकते हैं।

समानता (Analogy): आपके फ़ोन की पता पुस्तिका (address book) में एक ही नाम वाले लोगों के लिए कंपनी का उपसर्ग (prefix) जोड़ना। यदि आपकी पता पुस्तिका में दो "Rahul" हैं, तो आप उन्हें कैसे सहेजेंगे? संभवतः आप उन पर "Rahul (TCS)" और "Rahul (Infosys)" टिप्पणी (remark) करेंगे — एक उपसर्ग जोड़ने से, वे दोनों कभी नहीं मिलेंगे। नेमस्पेस ठीक यही करता है: प्लगइन my-plugin में वह review कमांड आपके लिए /my-plugin:review कहा जाएगा, प्लगइन नाम वाला अगला भाग "कंपनी उपसर्ग (company prefix)" है। तो भले ही आपका अपना /review हो, एक कमांड में उपसर्ग है और दूसरे में नहीं, वे एक दूसरे में हस्तक्षेप (interfere) नहीं करते हैं।

यही कारण है कि लेख 24 में प्लगइन्स पर चर्चा करते समय यह कहा गया था कि "प्लगइन Skills कभी भी आपके कमांड के साथ नाम से नहीं टकराएंगे" — यह plugin-name:command-name नेमस्पेस पर निर्भर करता है। यदि आप कई प्लगइन्स इंस्टॉल करते हैं, और प्रत्येक में एक review कमांड है, तो वे क्रमशः /plugin-a:review और /plugin-b:review होंगे, प्रत्येक अपने आप में कॉल किया जाएगा।

एक और प्रकार का कमांड है जिसमें "डबल अंडरस्कोर (double underscore)" है जिसका आप सामना कर सकते हैं: MCP सर्वर द्वारा उजागर किए गए (exposed) प्रॉम्प्ट। आधिकारिक दस्तावेज़ कहता है कि वे /mcp__<server>__<prompt> प्रारूप (format) का उपयोग करते हैं, जिसे गतिशील रूप से (dynamically) कनेक्टेड सर्वर से खोजा गया है। यदि आप /mcp__github__xxx देखते हैं, तो भ्रमित न हों — यह किसी MCP सर्वर के साथ आने वाला कमांड है (विवरण के लिए लेख 22 देखें)।

💡 सारांश: जब आपके स्वयं के कमांड का नाम समान होता है, "Skill कमांड पर जीतती है"; प्लगइन कमांड plugin-name:command-name नेमस्पेस पर निर्भर करते हैं, इसलिए वे स्वाभाविक रूप से नहीं टकराते हैं; MCP सर्वर कमांड /mcp__<server>__<prompt> प्रारूप का उपयोग करते हैं — इन तीन स्रोतों (sources) के साथ, जब तक आप उपसर्ग को पहचानते हैं, आप भ्रमित नहीं होंगे।

---

07 स्लैश कमांड और Skill: वास्तव में क्या संबंध है, एक वाक्य में स्पष्ट किया गया

यहाँ तक पहुँचने के बाद, आपको शायद आश्चर्य हो रहा होगा: स्लैश कमांड और Skill, ये दोनों इतने समान क्यों लगते हैं? मैंने अभी .claude/commands/ में जो लिखा है और लेख 26 में .claude/skills/ में SKILL.md में जो लिखा है, उसमें क्या अंतर है?

यह एक अच्छा प्रश्न है, और एक ऐसी गांठ (knot) भी है जिसमें शुरुआती लोग सबसे आसानी से उलझ जाते हैं। यहाँ इसे खोलने के लिए एक वाक्य है:

कस्टम स्लैश कमांड को आधिकारिक तौर पर Skill सिस्टम में मिला (merged) दिया गया है। आपकी .claude/commands/ फ़ाइल अभी भी काम करती है, लेकिन Skill "अपग्रेड किया गया संस्करण (upgraded version)" है — इसमें सहयोगी (supporting) फ़ाइलें शामिल करने, Claude द्वारा स्वचालित रूप से ट्रिगर होने, और उन्नत कॉन्टेक्स्ट (advanced context) का वर्णन करने की क्षमता शामिल है जिसे केवल लंबे दस्तावेज़ों को कॉल किए जाने पर लोड किया जाता है (संपूर्ण दस्तावेज़ को प्री-लोड करने के बजाय)।

आधिकारिक बयान बहुत सीधा है:

कस्टम कमांड्स को skills में मिला (merged) दिया गया है। .claude/commands/deploy.md में एक फ़ाइल और .claude/skills/deploy/SKILL.md में एक skill दोनों /deploy बनाते हैं और उसी तरह काम करते हैं।

इसलिए ये दोनों बिल्कुल भी विरोधी (opposing) अवधारणाएं (concepts) नहीं हैं, बल्कि एक ही क्षमता (capability) को लिखने के दो तरीके हैं। दूसरे दृष्टिकोण से: "स्लैश कमांड" एक "कॉलिंग विधि (calling method)" (आप इसे सक्रिय रूप से कॉल करने के लिए / टाइप करते हैं) की तरह अधिक है, जबकि Skill वास्तविक "इकाई (entity)" है जिसे कॉल किया जाता है। लेख 26 में दी गई तालिका ने पहले ही Skills, स्लैश कमांड, और Subagents की स्थिति (positioning) को स्पष्ट कर दिया है, इसलिए मैं यहाँ केवल एक तुलना जोड़ूंगा "एक ही चीज़ के लिए दो लिखने के तरीकों के बीच चयन कैसे करें":

आपकी आवश्यकता	पुराने-शैली (old-style) के कमांड का उपयोग करें (.claude/commands/xx.md)	Skill का उपयोग करें (.claude/skills/xx/SKILL.md)
बस एक प्रॉम्प्ट, विशुद्ध रूप से मैन्युअल कॉल (manual call)	✅ पर्याप्त है, सबसे आसान	ठीक है, लेकिन एक अतिशयोक्ति (overkill) है
टेम्प्लेट / स्क्रिप्ट / उदाहरण फ़ाइलें लाना चाहते हैं	❌ उन्हें नहीं ला सकता	✅ यह एक डायरेक्टरी है, यह सहयोगी (supporting) फ़ाइलों का एक गुच्छा (bunch) रख सकती है
चाहते हैं कि Claude "उचित होने पर इसे स्वचालित रूप से कॉल करे"	description लिखा हो तो कर सकता है, लेकिन Skill इसके लिए ही डिज़ाइन की गई है	✅ मुख्य उपयोग का मामला
लंबे संदर्भ (reference) दस्तावेज़ों को शामिल करना चाहते हैं लेकिन कॉन्टेक्स्ट नहीं लेना चाहते	❌ सहयोगी फ़ाइलों की डायरेक्टरी का समर्थन नहीं करता	✅ सहयोगी फ़ाइलों की डायरेक्टरी का समर्थन करता है, SKILL.md में आवश्यकतानुसार लंबे दस्तावेज़ों का संदर्भ (reference) लें, कॉल किए जाने पर स्वचालित रूप से पूरी तरह से लोड नहीं होता है

अंगूठे का नियम (Rule of thumb): एक छोटे कार्य के लिए जो सिर्फ एक प्रॉम्प्ट है जिसे आप मैन्युअल रूप से कॉल करते हैं (जैसे कि /review), पुराने शैली का .claude/commands/ मार्कडाउन सबसे आसान है, इसे जटिल न करें; एक बार जब आप पाते हैं कि आप "इसे एक टेम्प्लेट प्रदान करना चाहते हैं," "एक लंबा दस्तावेज़ शामिल करना चाहते हैं लेकिन इसे कॉन्टेक्स्ट नहीं लेने देना चाहते," "इसे स्वयं तय करने देना चाहते हैं कि इसका उपयोग करना है या नहीं" — तो आपको इसे Skill में अपग्रेड करना चाहिए (इसे कैसे लिखना है, इसके लिए लेख 26 और 27 देखें, या यदि आप इसे मैन्युअल रूप से टाइप करने में आलसी हैं तो लेख 28 में skill-creator का उपयोग करें)।

इसे स्पष्ट रूप से कहने के लिए, इस लेख में आपने जो "कस्टम स्लैश कमांड" सीखा है, वह Skill सिस्टम में सबसे हल्का (lightweight) प्रवेश बिंदु है। "एक-क्लिक प्रॉम्प्ट" चीज़ के साथ सहज होने के लिए पहले इसका उपयोग करें, और जब आपको अधिक क्षमताओं की आवश्यकता हो, तो बस सुचारू रूप से (smoothly) Skill में अपग्रेड करें — आधिकारिक दस्तावेज़ स्पष्ट रूप से बताता है कि "आपकी मौजूदा फ़ाइलें काम करना जारी रखेंगी," .claude/commands/ आधिकारिक रूप से समर्थित लेखन विधि है, और इसे अप्रचलित (deprecated) करने का कोई इरादा नहीं है।

💡 सारांश: कस्टम स्लैश कमांड पहले ही Skill सिस्टम में मिला दिए गए हैं — पुराना .claude/commands/ सबसे हल्का प्रवेश बिंदु (केवल एक प्रॉम्प्ट, मैन्युअल रूप से कॉल किया गया) है, जब आपको सहयोगी फ़ाइलों / स्वचालित ट्रिगरिंग / प्रगतिशील प्रकटीकरण (progressive disclosure) की आवश्यकता हो तो Skill में अपग्रेड करें; दोनों एक ही नाम के साथ कमांड बनाते हैं और बिल्कुल उसी तरह काम करते हैं।

---

08 अभ्यास: 5 मिनट में पैरामीटर के साथ /explain कमांड बनाना

बिना अभ्यास के पढ़ना आपको इसे याद रखने में मदद नहीं करेगा। मैं आपको एक ऐसा स्लैश कमांड बनाने की प्रक्रिया के बारे में बताऊँगा जो वास्तव में काम करता है और पैरामीटर भी पास कर सकता है — /explain कमांड जो "साधारण शब्दों में कोड / त्रुटियों (errors) को समझाता है।" यह किसी भी जटिल वातावरण पर निर्भर नहीं करता है और इसे किसी भी खाली डायरेक्टरी में चलाया जा सकता है।

चरण 1: कमांड डायरेक्टरी बनाएं (Mac / Linux)

अपने किसी भी प्रोजेक्ट डायरेक्टरी में (यदि आपके पास एक नहीं है, तो बस एक खाली को mkdir करें), .claude/commands/ फ़ोल्डर बनाएं:

mkdir -p .claude/commands

Windows उपयोगकर्ता: बस अपने प्रोजेक्ट की रूट (root) डायरेक्टरी में मैन्युअल रूप से .claude\commands\ नामक दो-स्तरीय (two-level) फ़ोल्डर बनाएं।

अपेक्षित (Expected): प्रोजेक्ट में अब एक खाली डायरेक्टरी .claude/commands/ है।

चरण 2: कमांड फ़ाइल लिखें

अपने पसंदीदा एडिटर (editor) का उपयोग करके, निम्नलिखित सामग्री को .claude/commands/explain.md के रूप में सहेजें:

---
description: किसी कोड या एरर (error) को साधारण शब्दों में समझाएं। जब उपयोगकर्ता किसी कोड या एरर को समझना चाहता है तो इसका उपयोग करें।
---

कृपया निम्नलिखित को साधारण शब्दों में समझाएं जिसे एक शुरुआती समझ सके:

$ARGUMENTS

आवश्यकताएं (Requirements):
1. सबसे पहले, एक वाक्य में बताएं कि यह कुल मिलाकर क्या करता है
2. फिर इसे लाइन-दर-लाइन / खंड-दर-खंड (section-by-section) स्पष्ट रूप से समझाएं
3. यदि यह एक एरर (error) है, तो सबसे संभावित कारण और इसे कैसे ठीक किया जाए, यह बताएं
4. तकनीकी शब्दों (jargon) का कम उपयोग करें, यदि संभव हो तो रोजमर्रा की उपमाओं (analogies) का उपयोग करें

दो स्थानों पर ध्यान दें: शुरुआत में --- द्वारा संलग्न फ्रंटमैटर (frontmatter) है, वह description Claude को बताता है कि यह कमांड क्या करता है; मुख्य भाग (body) में वह $ARGUMENTS वह है जिसका उपयोग आप उस कोड / त्रुटि (error) को पकड़ने के लिए करेंगे जिसे आप बाद में पास करेंगे।

अपेक्षित: .claude/commands/ में अब एक explain.md है।

चरण 3: Claude प्रारंभ करें, और पुष्टि करें कि कमांड पहचाना गया है

claude

प्रवेश करने के बाद, सबसे पहले एक / टाइप करें (बस स्लैश टाइप करें, एंटर न दबाएं), और पॉप-अप मेनू देखें:

अपेक्षित: आप मेनू में /explain देख सकते हैं, और इसके आगे वह description है जो आपने लिखा है। इसे मेनू में देखने का मतलब है = कमांड सही ढंग से लोड हो गया है। यदि आप इसे नहीं देखते हैं, तो यह शायद गलत जगह पर सहेजा गया है — पुष्टि करें कि यह .claude/commands/explain.md में है, किसी अन्य पथ (path) पर नहीं।

चरण 4: इसे मापदंडों (parameters) के साथ कॉल करें

अब वास्तव में इसका उपयोग करें — कमांड नाम टाइप करें, उसके बाद वह चीज़ जो आप समझाना चाहते हैं (यह स्ट्रिंग $ARGUMENTS में भर दी जाएगी):

/explain print(sum([1,2,3]) / len([1,2,3]))

अपेक्षित: Claude को आपका पूरा प्रॉम्प्ट प्राप्त होता है, जहाँ $ARGUMENTS को print(sum([1,2,3]) / len([1,2,3])) से बदल दिया गया है। यह आपके द्वारा लिखे गए चार चरणों का पालन करेगा — पहले एक वाक्य में (इन तीन संख्याओं की औसत गणना (average calculation) करने के लिए) समग्र व्याख्या दें, फिर इसे अनुभाग (section) दर अनुभाग तोड़ें, कम तकनीकी शब्दों का उपयोग करें, और यदि संभव हो तो उपमाओं (analogies) का उपयोग करें। आपने केवल कमांड नाम और कोड का एक टुकड़ा टाइप किया, और "स्पष्टीकरण आवश्यकताओं (explanation requirements)" का पूरा सेट स्वचालित रूप से लागू हो गया था, यह $ARGUMENTS की शक्ति है।

चरण 5: इसे दूसरे पैरामीटर के साथ फिर से आज़माएँ

वही कमांड, लेकिन इस बार एक एरर (error) समझाने के लिए:

/explain ZeroDivisionError: division by zero

अपेक्षित: यह वही /explain ट्रिगर (trigger) करता है, लेकिन इस बार $ARGUMENTS वह एरर बन जाता है, और Claude "सबसे संभावित कारण और इसे कैसे ठीक करें" (शून्य से भाग (division by zero)) पर ध्यान केंद्रित करते हुए आवश्यकता 3 का पालन करेगा। एक टेम्प्लेट, पैरामीटर जैसा आप चाहते हैं बदलें — यही वह जगह है जहाँ कस्टम कमांड प्रॉम्प्ट को मैन्युअल रूप से टाइप करने से बेहतर हैं।

इन पांच चरणों को पूरा करने के बाद, आपने कस्टम स्लैश कमांड की तीन मुख्य चीजों को व्यक्तिगत रूप से सत्यापित (personally verified) कर लिया है — "फ़ाइल नाम कमांड नाम है," "description के साथ फ्रंटमैटर (frontmatter)," और "पैरामीटर पास करने के लिए $ARGUMENTS"। भविष्य में यदि आप कोई भी कमांड बनाना चाहते हैं, तो अनिवार्य रूप से यही प्रक्रिया है, बस एक अलग फ़ाइल नाम, एक अलग प्रॉम्प्ट, और आवश्यकतानुसार फ्रंटमैटर (frontmatter) फ़ील्ड जोड़ें।

💡 सारांश: कमांड बनाने के लिए तीन चरण हैं — .claude/commands/ में एक मार्कडाउन छोड़ें (फ़ाइल नाम कमांड नाम है), description जोड़ें, और पैरामीटर के लिए प्लेसहोल्डर के रूप में $ARGUMENTS का उपयोग करें; यह देखने के लिए / टाइप करें कि क्या यह मेनू में है, और फिर इसे विभिन्न मापदंडों (parameters) के साथ दो बार कॉल करें, व्यक्तिगत रूप से इसे सत्यापित (verify) करना दस दस्तावेज़ों को याद रखने से कहीं बेहतर है।

---

09 सारांश

इस लेख ने स्लैश कमांड को खोला है — "वह प्रवेश द्वार जिसे आप हर दिन टाइप करते हैं लेकिन पूरी तरह से नहीं समझते हैं" — आपके लिए। यह Claude Code का कंट्रोल पैनल है, दर्जनों बिल्ट-इन स्विच से लेकर आपके स्वयं के कस्टम वन-क्लिक वर्कफ़्लो तक, सब कुछ एक / के पीछे है।

आइए मुख्य बिंदुओं की समीक्षा करें:

आप क्या समझना चाहते हैं	उत्तर	मुख्य बिंदु
स्लैश कमांड क्या है	Claude Code के लिए कंट्रोल निर्देश (Control instructions)	प्रोग्राम को ही मैनेज करता है, कार्यों को सौंपने के लिए नहीं; केवल संदेश के शुरुआत में काम करता है
बिल्ट-इन (built-in) कमांड कैसे याद रखें	उपयोग परिदृश्य (usage scenario) द्वारा समूह	स्टेज सेट करना / काम के दौरान / सौंपने से पहले / विविध; इसके वास्तविक पूर्ण सेट को देखने के लिए / टाइप करें
अपना खुद का कमांड कैसे बनाएं	.claude/commands/ में मार्कडाउन छोड़ें	फ़ाइल नाम कमांड नाम है; प्रोजेक्ट-स्तर साझा (shared) / व्यक्तिगत-स्तर क्रॉस-प्रोजेक्ट
कमांड को पैरामीटर (parameters) कैसे पास करें	$ARGUMENTS / $0 $1	कमांड नाम के बाद का इनपुट स्वचालित रूप से बदल दिया जाता है; बहु-शब्द (multi-word) मानों के लिए कोट्स (quotes) की आवश्यकता होती है
कमांड को लाइव डेटा कैसे लाने दें	!`command` डायनामिक इंजेक्शन (dynamic injection)	Claude को भेजने से पहले git diff जैसे वास्तविक आउटपुट से पहले से भरें (Pre-fill)
कमांड के व्यवहार को कैसे नियंत्रित करें	फ्रंटमैटर (Frontmatter)	description बताता है कि कब उपयोग करना है, disable-model-invocation इसे मैन्युअल उपयोग के लिए लॉक करता है
क्या कमांड नाम से टकराएंगे (conflict)	3 स्रोतों के अलग-अलग नियम हैं	Skill कमांड पर जीतती है, प्लगइन्स नेमस्पेस (namespaces) पर निर्भर करते हैं, MCP /mcp__ उपसर्ग (prefix) का उपयोग करता है
Skill के साथ क्या संबंध है	Skill सिस्टम में मिला (Merged) दिया गया है	कमांड सबसे हल्का प्रवेश बिंदु (lightweight entry point) है, जब आपको अधिक क्षमताओं की आवश्यकता हो तो Skill में अपग्रेड करें

अब आप यह करने में सक्षम होने चाहिए: बस / टाइप करके उस मेनू को समझें और बिल्ट-इन कमांड खोजें जिसका उपयोग आपको "आप जिस चरण में हैं" उसके आधार पर करना चाहिए; अपने बार-बार टाइप किए गए प्रॉम्प्ट को .claude/commands/ के अंतर्गत एक कमांड में रिकॉर्ड करें, इसे पैरामीटर (parameters) प्राप्त करने देने के लिए $ARGUMENTS का उपयोग करें, और इसके व्यवहार को नियंत्रित करने के लिए फ्रंटमैटर (frontmatter) का उपयोग करें; समझें कि जब कमांड का नाम समान होता है तो कौन जीतता है, और प्लगइन कमांड नाम से क्यों नहीं टकराते हैं; और समझें कि स्लैश कमांड और Skills वास्तव में एक ही चीज़ हैं — पहला बाद वाले का सबसे हल्का (lightweight) प्रवेश बिंदु है, और एक बार जब आप इसके साथ सहज हो जाते हैं, तो आप किसी भी समय अपग्रेड कर सकते हैं।

शुरुआत में उस दो-सप्ताह की "रीस्टार्ट तकनीक (restart technique)" पर पीछे मुड़कर देखें — यह सब इसलिए था क्योंकि उन्होंने कभी उस / मेनू को नहीं देखा था। इस लेख के बाद, जब भी आप खुद Claude Code के साथ कुछ करना चाहते हैं, तो आपकी पहली प्रतिक्रिया (first reaction) यह होनी चाहिए कि आप स्लैश टाइप करके देखें कि क्या कोई रेडीमेड (readymade) स्विच है; यदि नहीं है, तो एक बनाने में दो मिनट बिताएं। यह छोटी सी आदत आपको बर्बाद हुए समय से बचा सकती है।

---

अगला लेख 37 "चेकपॉइंट्स (Checkpoints)" है — मैंने इस लेख के अंत में /rewind कमांड का संक्षेप में उल्लेख किया है, और अगला लेख इसे विस्तार से तोड़ेगा (break down)। क्या होगा यदि Claude ने कोड में बहुत सारे बदलाव किए हैं, और दिशा गलत हो गई है? आप हर बार मैन्युअल git reset पर भरोसा नहीं कर सकते हैं या बस यूं ही नहीं देख सकते हैं। अगला लेख आपको सिखाएगा कि कोड और बातचीत को वापस एक साफ़ (clean) स्थिति में "रीवाइंड (rewind)" करने के लिए Claude Code के बिल्ट-इन चेकपॉइंट मैकेनिज्म (built-in checkpoint mechanism) का उपयोग कैसे करें, बिल्कुल किसी गेम में सेविंग और लोडिंग (saving and loading) की तरह। जरा सोचिए: यदि प्रत्येक कुछ बदलावों के बाद स्वचालित रूप से एक "सेव पॉइंट (save point)" होता, तो क्या आप प्रयोग करने (experiment) में अधिक साहसी नहीं होते?

---

अनुशंसित पठन (Recommended Reading)

• सुविधाएँ (Features) कैसे चुनें: CLAUDE.md बनाम Skill बनाम Hook बनाम MCP बनाम Subagent
• सुरक्षा और जोखिम सीमाएँ (Security and Risk Boundaries): क्या आपको वास्तव में AI को अपने कोड को छूने देना चाहिए
• प्रोजेक्ट संरचना (Project Structure): Claude Code आपके प्रोजेक्ट में क्या रखता है