Claude Code का उपयोग कैसे करें: चरण-दर-चरण ट्यूटोरियल

परिचय: Claude Code क्या है?

अगर आपने कभी किसी AI कोडिंग असिस्टेंट को अपने रोज़मर्रा के टर्मिनल वर्कफ़्लो में लाने की कोशिश की है, तो शायद आप भी उसी दीवार से टकराए होंगे: आपको पता है कि आपको क्या करवाना है, लेकिन यह समझ नहीं आता कि चीज़ों को सुरक्षित तरीके से कैसे सेट अप करें, बार-बार आने वाली रुकावटों से कैसे बचें, और जो बदलाव हो रहे हैं उन पर कैसे भरोसा करें।

इस गाइड में, आप सीखेंगे कि Claude Code को एक व्यावहारिक और दोहराने योग्य तरीके से कमांड लाइन टूल के रूप में असली डेवलपमेंट कार्यों के लिए कैसे उपयोग करें। आप एक सुरक्षित इंस्टॉल से शुरुआत करेंगे, फिर रीड-ओनली प्लानिंग पर आएंगे, और उसके बाद सैंडबॉक्स्ड एडिट्स और टेस्ट रन की ओर बढ़ेंगे। वहाँ से, आप पुन: उपयोग योग्य Skills बनाएंगे, MCP के साथ बाहरी टूल्स कनेक्ट करेंगे, और Hooks से सुरक्षा गार्डरेल्स ऑटोमेट करेंगे—यह सब अपने कोडबेस पर नियंत्रण खोए बिना।

यह वॉकथ्रू उन डेवलपर्स के लिए है (चाहे अकेले हों या टीम में) जो टर्मिनल में सहज हैं और असली कोडबेस के लिए पर्याप्त सुरक्षित AI कोडिंग वर्कफ़्लो चाहते हैं। अगर आप इसे किसी संगठन में सेट अप कर रहे हैं, तो यह जानना भी मददगार है कि क्रेडेंशियल्स कहाँ स्टोर होते हैं, उदाहरण के लिए macOS पर एन्क्रिप्टेड macOS Keychain।

चलिए एक्सेस सेट अप करके शुरू करते हैं ताकि आपका पहला सेशन बिना किसी रुकावट के हो।

एक्सेस प्राप्त करें, Claude Code इंस्टॉल करें, और साइन इन करें

इससे पहले कि आप असली डेव कार्य Claude Code को सौंपना शुरू करें, आपको एक साफ़-सुथरे इंस्टॉल और एक ऐसी ऑथेंटिकेशन विधि की ज़रूरत है जो आपके उपयोग के तरीके से मेल खाती हो।

Claude Code इंस्टॉल करने और ऑथेंटिकेशन की पुष्टि करने के लिए इन चरणों का पालन करें:

1. node -v चलाकर और यह जाँचकर कि यह v18 या उससे अधिक रिपोर्ट करता है, पुष्टि करें कि आपके पास Node.js 18+ इंस्टॉल है।
2. Claude Code को ग्लोबली इंस्टॉल करें: npm install -g @anthropic-ai/claude-code।
3. claude चलाकर एक इंटरैक्टिव सेशन शुरू करें, फिर /login दर्ज करके और अपने Claude.ai (अनुशंसित) या Console अकाउंट के लिए ब्राउज़र-आधारित फ़्लो पूरा करके साइन इन करें।
4. अगर आप स्क्रिप्ट्स या नॉन-इंटरैक्टिव उपयोग के लिए की-बेस्ड ऑथ पसंद करते हैं, तो अपने शेल एनवायरनमेंट में ANTHROPIC_API_KEY सेट करें। अगर आपका संगठन क्लाउड प्रोवाइडर्स का उपयोग करता है, तो पुष्टि करें कि क्या आपको Bedrock/Vertex के माध्यम से ऑथेंटिकेट करना चाहिए ताकि आप गलत क्रेडेंशियल टाइप सेट अप न करें।

कुछ बातें जिनका ध्यान रखना चाहिए:

• अगर आप WSL पर हैं और इंस्टॉलर OS डिटेक्शन या Windows npm/Node मिसमैच के कारण विफल होता है, तो WSL फ़िक्स दृष्टिकोण का उपयोग करें (जिसमें दस्तावेज़ित --force --no-os-check इंस्टॉल विकल्प शामिल है) और sudo के उपयोग से बचें, जिसके बारे में डॉक्स स्पष्ट रूप से चेतावनी देते हैं।
• अगर आप Free/Pro/Max अकाउंट से साइन इन कर रहे हैं, तो अपने डेटा कंट्रोल्स की समीक्षा करें: 28 अगस्त 2025 से, कंज़्यूमर उपयोगकर्ता चुन सकते हैं कि कोडिंग सेशन का उपयोग भविष्य के Claude मॉडल्स को बेहतर बनाने के लिए किया जाए या नहीं।

इस चरण के बाद, claude बिना एरर के लॉन्च होना चाहिए, और /login के बाद आप एक छोटा प्रॉम्प्ट भेजकर रिस्पॉन्स प्राप्त कर पाएंगे।

मुख्य बातें:

• आपने Claude Code इंस्टॉल किया और अपने एनवायरनमेंट के लिए एक कार्यशील साइन-इन विधि स्थापित की।
• असली वर्कफ़्लो आज़माने से पहले आपको क्रेडेंशियल पथ (इंटरैक्टिव /login बनाम API key बनाम मैनेज्ड प्रोवाइडर) सही करना ज़रूरी है।
• आपको WSL/Node पथ समस्याओं पर नज़र रखनी चाहिए और अपने अकाउंट की डेटा-शेयरिंग सेटिंग की पुष्टि करनी चाहिए ताकि बाद में कोई आश्चर्य न हो।

प्रोजेक्ट खोलें और सुरक्षित रूप से प्लान करें: रीड-ओनली मोड में AI कोडिंग असिस्टेंट

इससे पहले कि आप Claude Code को फ़ाइलें बदलने या कमांड चलाने दें, आप चाहते हैं कि यह आपके कोडबेस को समझे और एक ऐसे मोड में ठोस दृष्टिकोण प्रस्तावित करे जो एक्ज़ीक्यूशन को रोकता है।

अपना रिपो खोलने और एक सुरक्षित प्लानिंग लूप को लागू करने के लिए इन चरणों का पालन करें:

1. cd /path/to/your-repo चलाकर अपने प्रोजेक्ट रूट पर नेविगेट करें (वह फ़ोल्डर चुनें जिसमें आपका package.json, pyproject.toml, या go.mod है)।

2. उस डायरेक्टरी से claude चलाकर Claude Code शुरू करें, फिर पुष्टि करें कि आप इस रिपो से जुड़े इंटरैक्टिव प्रॉम्प्ट में पहुँच गए हैं।

3. /plan टाइप करके Plan Mode में स्विच करें (या Shift+Tab / Alt+M से मोड टॉगल करें)।

4. (वैकल्पिक) अगर आप हर सेशन के लिए प्लान मोड को डिफ़ॉल्ट बनाना चाहते हैं, तो आधिकारिक settings विकल्पों का उपयोग करके .claude/settings.json फ़ाइल बनाएं:

   • "defaultMode": "plan" जोड़ें ताकि नए सेशन डिफ़ॉल्ट रूप से प्लानिंग मोड में खुलें।
   • उन फ़ाइलों के लिए एक permissions.deny लिस्ट जोड़ें जिन्हें आप कभी नहीं चाहते कि Claude Code पढ़े (.env, secrets/, क्रेडेंशियल फ़ाइलें)।

5. कॉन्फ़िग गाइडेंस में अनुशंसित claude config list चलाकर अपने सक्रिय कॉन्फ़िग को सत्यापित करें, फिर पुष्टि करें कि आपकी सेटिंग्स लागू हैं।

6. एक ऐसा प्लान माँगें जो अप्रूव करने के लिए पर्याप्त विशिष्ट हो: "प्लान मोड में, X को ठीक करने के लिए बदलावों का सबसे छोटा सेट बताएं, सटीक फ़ाइलों की सूची दें जिन्हें आप बदलेंगे, और उसे वैलिडेट करने के लिए चलाई जाने वाली कमांड शामिल करें।" पुष्टि करें कि Claude केवल स्टेप्स प्रस्तावित करता है (क्योंकि प्लान मोड में कोई एक्ज़ीक्यूशन नहीं होता है)।

कुछ बातें जिनका ध्यान रखना चाहिए:

• अपने पहले प्रॉम्प्ट को संकीर्ण रखें: एक ऐसा प्लान जो फ़ाइलों, फ़ंक्शन्स, और कमांड्स का नाम लेता है, उसे अप्रूव करना एक उच्च-स्तरीय रीराइट से कहीं आसान है।
• अगर प्लान पसंद आने के बाद आप जल्दी करने का मन करे, तो acceptEdits को एक जानबूझकर "इम्प्लीमेंटेशन फ़ेज़" सेटिंग मानें, न कि कुछ ऐसा जो आप अभी भी एक्सप्लोर करते समय चालू कर दें।
• अगर claude config list आपके बदलावों को नहीं दर्शाता, तो दोबारा जाँचें कि आपने .claude/settings.json उसी रिपो में बनाया है जहाँ से आपने Claude Code लॉन्च किया था।

आपको पता चल जाएगा कि यह चरण सफल रहा जब Claude एक संरचित प्लान (बदलने-वाली-फ़ाइलें + वैलिडेशन कमांड्स) के साथ जवाब दे और जब तक आप Plan Mode में हैं, टूल्स एक्ज़ीक्यूट करने या फ़ाइलें बदलने का प्रयास न करे।

मुख्य बातें:

• आपने Claude Code को सही प्रोजेक्ट कॉन्टेक्स्ट में खोला और किसी भी एक्ज़ीक्यूशन से पहले प्लान-फ़र्स्ट वर्कफ़्लो लागू किया।
• मल्टी-स्टेप कार्य माँगने से पहले आपको Plan Mode और अपने .claude/settings.json स्कोप कंट्रोल्स को सही जगह पर रखना ज़रूरी है।
• आपको कॉन्फ़िग मिसमैच (गलत रिपो, गलत फ़ाइल पथ) पर नज़र रखनी चाहिए और ठोस प्लान अप्रूव करने के बाद ही तेज़ परमिशन मोड्स पर स्विच करना चाहिए।

बदलाव लागू करें, टेस्ट चलाएं, और AI कोड जनरेशन के लिए सैंडबॉक्सिंग सक्षम करें

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

प्लान लागू करने, वैलिडेशन चलाने, और जोखिम कम करने के लिए इन चरणों का पालन करें:

1. जब आपका प्लान तैयार हो, तो Claude Code आपसे "आप कैसे आगे बढ़ना चाहेंगे?" पूछेगा और "हाँ, और एडिट्स ऑटो-स्वीकार करें" या "हाँ, मैन्युअली एडिट्स अप्रूव करें" जैसे विकल्प देगा—इम्प्लीमेंट करना शुरू करने के लिए एक चुनें।
2. फ़ाइल एडिट्स को एक-एक बैच करके अप्रूव करें, फिर एक अलग टर्मिनल पेन में git diff चलाकर तुरंत समीक्षा करें कि क्या बदला।
3. /sandbox कमांड चलाकर और अपने वर्कफ़्लो के अनुकूल सैंडबॉक्स विकल्प चुनकर सैंडबॉक्स्ड कमांड एक्ज़ीक्यूशन सक्षम करें।
4. रूटीन कार्यों के लिए सैंडबॉक्स ऑटो-एक्ज़ीक्यूशन को प्राथमिकता दें Auto-allow mode चुनकर ताकि Claude बार-बार अप्रूवल के लिए रुके बिना सामान्य टेस्ट और लिंट कमांड चला सके।
5. रिपो रूट से अपने प्रोजेक्ट का टेस्ट कमांड चलाएं, जैसे npm run test या pytest && coverage report जैसा कि bash tool उदाहरणों में दिखाया गया है।
6. सैंडबॉक्स-असंगत कमांड्स को जानबूझकर हैंडल करें: अगर Claude Code सैंडबॉक्स के बाहर कुछ चलाने के लिए एस्केप हैच ऑफ़र करता है, तो रुकें और अनुमति देने से पहले कमांड की सुरक्षा सत्यापित करें।

कुछ बातें जिनका ध्यान रखना चाहिए:

• "एडिट फ़ेज़" और "वेरिफ़ाई फ़ेज़" को अलग रखें: पहले डिफ़ की समीक्षा करें, फिर टेस्ट चलाएं।
• कमांड एक्ज़ीक्यूशन को अधिक जोखिमपूर्ण मानें क्योंकि यह सीधा सिस्टम एक्सेस हो सकता है; जब संदेह हो, कमांड खुद चलाएं या सैंडबॉक्स में रखें।
• अगर टेस्ट फ़ेल होते हैं, तो दायरा न बढ़ाएं; Claude से कहें कि केवल फ़ेल हो रहे टेस्ट या फ़ेल्योर से जुड़े न्यूनतम कोड पथ को ठीक करे, फिर दोबारा चलाएं।

इस बिंदु पर, आपके रिपो में git diff में केवल इच्छित एडिट्स दिखने चाहिए, और आपका टेस्ट कमांड सफलतापूर्वक पूरा होना चाहिए।

मुख्य बातें:

• आपने एक अप्रूव्ड प्लान को लागू किया और कुछ और करने से पहले "एडिट → डिफ़ रिव्यू → टेस्ट रन" के कड़े लूप में आ गए।
• सैंडबॉक्सिंग को जल्दी सक्षम करके और जब भी संभव हो इसके अंदर टेस्ट चलाकर आपको सबसे अधिक सुरक्षा और गति मिलती है।
• आपको सैंडबॉक्स एस्केप हैच उपयोग करने के अनुरोधों पर नज़र रखनी चाहिए और उन्हें रुककर सत्यापित करने का संकेत मानना चाहिए।

अपनी पहली Skill बनाएं: एक Claude Code ट्यूटोरियल

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

एक स्किल एक फ़ोल्डर है जिसमें एक आवश्यक SKILL.md फ़ाइल और वैकल्पिक सहायक डायरेक्टरीज़ होती हैं। Claude एक प्रोग्रेसिव डिस्क्लोज़र मॉडल का उपयोग करता है: यह पहले मेटाडेटा पढ़ता है (खोज के लिए), ट्रिगर होने पर मुख्य निर्देश लोड करता है, और सहायक फ़ाइलें केवल ज़रूरत पड़ने पर खींचता है—जिससे आपका कॉन्टेक्स्ट हल्का रहता है।

यहाँ अनुशंसित फ़ोल्डर स्ट्रक्चर है:

pr-summarizer/
├── SKILL.md          # Required: frontmatter + core instructions
├── references/       # Optional: deep docs, edge cases, API specs
├── examples/         # Optional: sample inputs/outputs
└── scripts/          # Optional: executable helpers (Python/Bash/Node)

अपनी पहली स्किल बनाने और टेस्ट करने के लिए इन चरणों का पालन करें:

1. mkdir -p .claude/skills/pr-summarizer चलाकर अपने प्रोजेक्ट में स्किल फ़ोल्डर बनाएं (प्रोजेक्ट-शेयर्ड स्किल्स के लिए .claude/skills/ का उपयोग करें जो git में कमिट होती हैं, या व्यक्तिगत स्किल्स के लिए ~/.claude/skills/ का)।
2. YAML फ़्रंटमैटर के साथ आवश्यक SKILL.md फ़ाइल बनाएं जिसमें name और description हो—description बहुत महत्वपूर्ण है क्योंकि Claude इसका उपयोग यह तय करने के लिए करता है कि स्किल कब लोड करनी है:

---
name: pr-summarizer
description: Summarize a pull request diff and produce a changelog entry. Use when asked to summarize, review, or create release notes from a PR or diff.
allowed-tools: Read, Grep, Glob, Bash(git diff)
---

When triggered, follow these steps:

1. Read the PR title, body, and diff
2. Extract high-level changes, breaking changes, and impacted modules
3. Return a 3-sentence summary and a one-paragraph changelog entry

Example output format:
**Summary:** Added user authentication flow with OAuth2 support...
**Changelog:** This release introduces OAuth2-based authentication...

1. सहायक सामग्री को सबफ़ोल्डर्स में व्यवस्थित करके SKILL.md को हल्का रखें (लक्ष्य 1,500–2,000 शब्द; 3,000 से कम रहें):

   • references/ — विस्तृत दस्तावेज़ीकरण, स्कीमा, समस्या निवारण गाइड
   • examples/ — नमूना इनपुट/आउटपुट, चलाने योग्य डेमो
   • scripts/ — एक्ज़ीक्यूटेबल हेल्पर्स जो कॉन्टेक्स्ट में लोड किए बिना चलते हैं

2. (वैकल्पिक) एज केसेज़ के लिए एक रेफ़रेंस फ़ाइल जोड़ें। references/EDGE-CASES.md बनाएं:

# Edge Cases for PR Summarizer

## Merge commits
When summarizing merge commits, focus on the merged branch's changes, not the merge commit itself.

## Empty diffs
If the diff is empty, return: "No code changes detected. This may be a metadata-only update."

फिर इसे अपने SKILL.md में रेफ़रेंस करें: "एज केसेज़ के लिए, references/EDGE-CASES.md देखें।"

1. रिपो में Claude Code रीस्टार्ट करें, फिर ऐसा कुछ पूछकर डिस्कवरी टेस्ट करें जो स्किल को ट्रिगर करे (उदाहरण के लिए: "मेरे आखिरी कमिट में बदलावों को चेंजलॉग एंट्री के रूप में सारांशित करें") और पुष्टि करें कि Claude आपकी स्किल के निर्देशों को लोड और फ़ॉलो करता है।
2. अगर Claude अपेक्षित होने पर स्किल ट्रिगर नहीं करता, तो स्पष्ट ट्रिगर कीवर्ड और उदाहरण उपयोगकर्ता वाक्यांश जोड़कर अपने description फ़ील्ड को बेहतर बनाएं, फिर दोबारा टेस्ट करें।

कुछ बातें जिनका ध्यान रखना चाहिए:

• name फ़ील्ड में केवल लोअरकेस अक्षर, संख्याएं, और हाइफ़न होने चाहिए (अधिकतम 64 कैरेक्टर); फ़ोल्डर का नाम मेल खाना चाहिए। description की अधिकतम सीमा ~1,024 कैरेक्टर है।
• SKILL.md या सहायक फ़ाइलों में कभी सीक्रेट्स या API keys हार्डकोड न करें—बाहरी सेवा एक्सेस के लिए MCP कनेक्शन या एनवायरनमेंट वेरिएबल्स का उपयोग करें।
• जिन स्किल्स को आइसोलेटेड एक्ज़ीक्यूशन चाहिए (मुख्य बातचीत को साफ़ रखने के लिए), उनके फ़्रंटमैटर में context: fork जोड़ें; यह स्किल को एक अलग सब-एजेंट कॉन्टेक्स्ट में चलाता है।
• फ़्रंटमैटर में allowed-tools का उपयोग करके यह सीमित करें कि स्किल किन टूल्स तक पहुँच सकती है—केवल वही अनुमति दें जो ज़रूरी हो।

आपको पता चल जाएगा कि यह चरण सफल रहा जब Claude मेल खाने वाले अनुरोध के आधार पर आपकी स्किल को स्वचालित रूप से लोड करे और SKILL.md में आपके द्वारा निर्दिष्ट प्रारूप में आउटपुट तैयार करे।

मुख्य बातें:

• Skills Claude Code में पुन: उपयोग योग्य क्षमताओं को पैकेज करने का आधुनिक, अनुशंसित तरीका है—अधिकांश वर्कफ़्लो के लिए इन्होंने काफ़ी हद तक subagents की जगह ले ली है।
• स्पष्ट ट्रिगर कीवर्ड के साथ एक स्पष्ट description लिखकर और SKILL.md को मुख्य निर्देशों पर केंद्रित रखकर आपको सबसे अच्छी डिस्कवरी मिलती है।
• आपको फ़ोल्डर स्ट्रक्चर (references/, examples/, scripts/) का उपयोग करना चाहिए ताकि आपकी मुख्य स्किल हल्की रहे जबकि ज़रूरत पड़ने पर Claude को गहरा कॉन्टेक्स्ट मिल सके।

MCP के साथ बाहरी AI कोडिंग टूल्स कनेक्ट करें

MCP (Model Context Protocol) एक ओपन स्टैंडर्ड है जो Claude Code को बाहरी सर्वर्स से बात करने देता है जो टूल्स, रिसोर्सेज़, और डेटा एक्सपोज़ करते हैं। इसे एक यूनिवर्सल एडाप्टर समझें: इश्यू विवरण या डेटाबेस रिज़ल्ट्स को अपने प्रॉम्प्ट में पेस्ट करने की बजाय, आप एक MCP सर्वर वायर करते हैं और Claude सीधे उससे क्वेरी करता है।

अपना पहला MCP सर्वर जोड़ने के लिए इन चरणों का पालन करें:

1. तय करें कि आपको रिमोट HTTP सर्वर (Notion, Linear, या होस्टेड APIs जैसी क्लाउड सर्विसेज़ के लिए) या लोकल stdio सर्वर (उन टूल्स के लिए जिन्हें सीधे फ़ाइल सिस्टम एक्सेस चाहिए) की ज़रूरत है; अधिकांश इंटीग्रेशन के लिए HTTP अनुशंसित है।
2. CLI का उपयोग करके रिमोट MCP सर्वर जोड़ें: claude mcp add --transport http notion https://mcp.notion.com/mcp (अपने वास्तविक सर्विस एंडपॉइंट से बदलें)।
3. ऑथेंटिकेशन आवश्यक सर्वर्स के लिए, हेडर फ़्लैग शामिल करें: claude mcp add --transport http linear https://api.linear.app/mcp --header "Authorization: Bearer your-token"।
4. claude mcp list चलाकर सत्यापित करें कि आपका सर्वर जोड़ा गया, फिर claude mcp get <name> से इसका कॉन्फ़िगरेशन जाँचें।
5. Claude से इंटीग्रेशन का उपयोग करने के लिए कहकर कनेक्शन टेस्ट करें (उदाहरण के लिए: "Linear से मेरे खुले इश्यूज़ की सूची दें" या "ऑनबोर्डिंग के बारे में Notion पेज खोजें")।

लोकल सर्वर्स या टीम-शेयर्ड कॉन्फ़िगरेशन के लिए, अपने प्रोजेक्ट रूट पर एक .mcp.json फ़ाइल बनाएं:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-filesystem"],
      "env": {
        "ALLOWED_PATHS": "/Users/me/projects"
      }
    }
  }
}

कुछ बातें जिनका ध्यान रखना चाहिए:

• टोकन स्कोप को न्यूनतम रखें और फ़ाइलसिस्टम सर्वर्स के लिए ALLOWED_PATHS को सीमित करें—न्यूनतम विशेषाधिकार का सिद्धांत यहाँ लागू होता है।
• MCP सर्वर्स में पहले सुरक्षा कमज़ोरियाँ पाई और पैच की गई हैं; अपने सर्वर्स को अपडेट रखें और केवल विश्वसनीय स्रोतों से सर्वर्स का उपयोग करें।
• टूल आउटपुट 10,000 टोकन पर चेतावनी ट्रिगर करता है और डिफ़ॉल्ट रूप से 25,000 टोकन पर कैप होता है; बड़े रिस्पॉन्स के लिए पेजिनेशन या अधिक संकीर्ण स्कोपिंग क्वेरीज़ पर विचार करें।

आपको पता चल जाएगा कि यह चरण सफल रहा जब Claude बिना आपके मैन्युअल रूप से कंटेंट पेस्ट किए किसी बाहरी सिस्टम (जैसे इश्यूज़ लिस्ट करना या डॉक्यूमेंट पढ़ना) पर सफलतापूर्वक क्वेरी या कार्य कर सके।

मुख्य बातें:

• MCP वह तरीका है जिससे आप Claude Code को बाहरी टूल्स और डेटा सोर्सेज़ से कनेक्ट करते हैं—यह कई AI प्लेटफ़ॉर्म्स पर समर्थित एक ओपन प्रोटोकॉल है।
• एक ऐसे इंटीग्रेशन से शुरू करने पर सबसे अधिक मूल्य मिलता है जिसका आप रोज़ाना उपयोग करेंगे (जैसे आपका इश्यू ट्रैकर) और उसके विश्वसनीय रूप से काम करने के बाद ही विस्तार करें।
• आपको अत्यधिक व्यापक परमिशन्स पर नज़र रखनी चाहिए; फ़ाइल पथ और API टोकन को संकीर्ण रूप से स्कोप करें, और MCP सर्वर्स को अपडेट रखें।

Hooks के साथ गार्डरेल्स ऑटोमेट करें

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

अपना पहला हुक जोड़ने के लिए इन चरणों का पालन करें:

1. एक कम-जोखिम वाली ऑटोमेशन से शुरू करने का निर्णय लें, जैसे Claude द्वारा कुछ कमांड्स चलाने पर लॉगिंग या एडिट्स के बाद कोड ऑटो-फ़ॉर्मेटिंग।
2. hooks गाइड का पालन करते हुए अपने प्रोजेक्ट के .claude/settings.json (या यूज़र-स्कोप के लिए ~/.claude/settings.json) में एक हुक जोड़ें। यहाँ एक स्टार्टर है जो Claude द्वारा चलाई गई हर Bash कमांड को लॉग करता है:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"$(date): $(echo $CLAUDE_TOOL_INPUT | jq -r '.command')\" >> ~/.claude/command-log.txt"
          }
        ]
      }
    ]
  }
}

1. अधिक व्यावहारिक हुक के लिए, हर एडिट के बाद TypeScript फ़ाइलों पर Prettier ऑटो-रन करें, एक PostToolUse हुक जोड़कर:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $(echo $CLAUDE_TOOL_INPUT | jq -r '.file_path') 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

1. Claude Code रीस्टार्ट करें और अपने मैचर से मेल खाने वाली कमांड चलाकर हुक को ट्रिगर करें, फिर अपनी लॉग फ़ाइल या फ़ॉर्मेटेड आउटपुट जाँचकर सत्यापित करें कि हुक फ़ायर हुआ।
2. Claude Code के अंदर /hooks चलाकर रजिस्टर्ड हुक्स का निरीक्षण करके हुक्स को डीबग करें, या हुक एक्ज़ीक्यूशन लॉग्स देखने के लिए claude --debug का उपयोग करें।

कुछ बातें जिनका ध्यान रखना चाहिए:

• हुक्स आपके यूज़र के रूप में मनमाने शेल कमांड एक्ज़ीक्यूट करते हैं, इसलिए स्टेट म्यूटेट करने वाली कोई भी चीज़ जोड़ने से पहले रीड-ओनली या लॉगिंग एक्शन्स से शुरू करें।
• हुक्स डिफ़ॉल्ट रूप से 60-सेकंड टाइमआउट के साथ चलते हैं; कमांड्स को तेज़ रखें ताकि वे Claude के वर्कफ़्लो में देरी न करें।
• किसी ऑपरेशन को ब्लॉक करने के लिए एग्ज़िट कोड 2 का उपयोग करें (PreToolUse हुक्स के लिए जिन्हें खतरनाक कमांड्स को अस्वीकार करना चाहिए); अन्य नॉन-ज़ीरो कोड नॉन-ब्लॉकिंग चेतावनियाँ हैं।

आपको पता चल जाएगा कि यह चरण सफल रहा जब आपका हुक विश्वसनीय रूप से फ़ायर हो और अपेक्षित ट्रिगर पॉइंट पर अवलोकन योग्य आउटपुट (एक लॉग एंट्री, फ़ॉर्मेटेड फ़ाइल, या ब्लॉक की गई कमांड) उत्पन्न करे।

मुख्य बातें:

• Hooks हल्की ऑटोमेशन हैं जो Claude Code के लाइफ़साइकल के विशिष्ट बिंदुओं पर शेल कमांड चलाती हैं—इन्हें गार्डरेल्स, फ़ॉर्मेटिंग, और लॉगिंग के लिए उपयोग करें।
• हानिरहित, अवलोकन योग्य हुक्स से शुरू करके और फिर फ़ाइलें संशोधित करने या ऑपरेशन्स ब्लॉक करने वाली किसी भी चीज़ में धीरे-धीरे आगे बढ़कर आपको सबसे अधिक सुरक्षा मिलती है।
• आपको धीमे या अस्थिर हुक्स पर नज़र रखनी चाहिए; उन्हें अलग से टेस्ट करें और समस्या निवारण के लिए /hooks या --debug का उपयोग करें।

DeepStation के साथ तेज़ी से बनाएं

एक गाइड पढ़ना बेहतरीन शुरुआत है—लेकिन असली गति तब आती है जब आपका Claude Code सेटअप प्रोजेक्ट्स में मसल मेमोरी बन जाता है। DeepStation आपको समुदाय की शक्ति के माध्यम से AI शिक्षा और नवाचार को गति देकर ठीक यही करने में मदद करता है—ताकि आप असली वर्कफ़्लो की तुलना कर सकें, अन्य डेवलपर्स से AI कोडिंग टिप्स एक्सप्लोर कर सकें, और "एक बार के प्रॉम्प्ट्स" को एक सुसंगत, सुरक्षित Claude Code प्रोसेस में बदल सकें जिस पर आप भरोसा कर सकते हैं।

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