Claude Code Hooks: वर्कफ़्लो ऑटोमेशन के लिए एक व्यावहारिक गाइड

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

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

Claude Code पर और अधिक जानने के लिए हमारा Claude Code सर्वोत्तम प्रथाएँ गाइड और Claude Skills ट्यूटोरियल देखें। यदि आप प्रोजेक्ट‑स्तरीय निर्देश कॉन्फ़िगर करना सीखना चाहते हैं, तो CLAUDE.md लिखने पर हमारा गाइड देखें।

संक्षेप में

• Claude Code Hooks शेल कमांड होते हैं जो Claude Code के लाइफ़साइकल के विशिष्ट बिंदुओं पर अपने‑आप चलते हैं (टूल कॉल से पहले/बाद, सत्र शुरू होने पर, जब Claude रुकता है)

• उन्हें .claude/settings.json (प्रोजेक्ट) या ~/.claude/settings.json (ग्लोबल) में इवेंट्स, मैचर्स और कमांड्स सहित JSON से कॉन्फ़िगर करें

• PreToolUse हुक का उपयोग खतरनाक ऑपरेशंस को होने से पहले ब्लॉक करने के लिए करें (एग्ज़िट कोड 2 = ब्लॉक)

• PostToolUse हुक का उपयोग क्लीनअप कार्यों के लिए करें, जैसे फ़ॉर्मेटिंग, लिंटिंग, या Claude द्वारा कोड लिखने के बाद टेस्ट चलाना

• हुक्स को stdin पर JSON संदर्भ मिलता है और वे परिणाम एग्ज़िट कोड्स, stdout, और stderr के माध्यम से बताते हैं

Claude Code Hooks क्या हैं?

Claude Code Hooks वे शेल कमांड हैं जो आपके AI कोडिंग सत्र के दौरान विशिष्ट इवेंट होने पर अपने‑आप चलते हैं। इन्हें ऐसे ऑटोमेटेड ट्रिगर्स समझें जो ठीक उसी क्षण आपके कस्टम स्क्रिप्ट्स को चलाते हैं—जब Claude कोई फ़ाइल लिखने वाला हो, कोई कमांड चला चुका हो, या आपको नोटिफ़िकेशन भेज रहा हो।

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

यहाँ एक बुनियादी हुक है जो हर बार Claude के किसी Python फ़ाइल लिखने पर कोड फ़ॉर्मैटर चलाता है:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python -m black ."
          }
        ]
      }
    ]
  }
}

इस हुक में तीन भाग हैं: 

• इवेंट: PostToolUse (जब Claude कोई क्रिया पूरी कर ले)

• मैचर: Write (सिर्फ़ फ़ाइल लिखने पर)

• कमांड: python -m black . (वर्तमान डायरेक्टरी में Python फ़ाइलों को फ़ॉर्मेट करें)

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

यदि आप Claude Code ऑटोमेशन में और आगे जाना चाहते हैं, तो हमारा Claude Code Routines ट्यूटोरियल दिखाता है कि क्लाउड में आवर्ती रूप से चलने के लिए हुक्स और एजेंट्स को कैसे शेड्यूल करें।

आइए देखें कि शून्य से हुक कैसे बनाएँ और उन्हें Claude Code में रजिस्टर करें।

पूर्वापेक्षाएँ

शुरू करने से पहले आपको कुछ चीज़ें तैयार रखनी होंगी:

• Claude Code इंस्टॉल और चल रहा हो: आपको बुनियादी कोडिंग कार्यों के लिए Claude Code का उपयोग करने में सहज होना चाहिए

• कमांड लाइन की जानकारी: हुक्स शेल कमांड चलाते हैं, इसलिए आपको अपने ऑपरेटिंग सिस्टम के लिए बेसिक टर्मिनल कमांड लिखना आना चाहिए

• टेक्स्ट एडिटर एक्सेस: आपको अपने हुक्स सेट अप करने के लिए JSON कॉन्फ़िगरेशन फ़ाइलें संपादित करनी होंगी

• प्रोजेक्ट डायरेक्टरी: ऐसा कोडिंग प्रोजेक्ट जहाँ आप महत्वपूर्ण काम को प्रभावित किए बिना हुक्स का सुरक्षित परीक्षण कर सकें

आपको शेल स्क्रिप्टिंग के विशेषज्ञ होने की ज़रूरत नहीं है, लेकिन ls, cd, और बेसिक फ़ाइल ऑपरेशंस जैसे कमांड चलाना समझना उदाहरणों का पालन करने में मदद करेगा। यदि आप bash स्क्रिप्टिंग या टर्मिनल में नए हैं, तो हमारा Introduction to Shell कोर्स लेने की सलाह देता हूँ।

Claude Code Hooks के साथ शुरुआत

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

हुक इवेंट्स को समझना

Claude Code 25 से अधिक हुक इवेंट्स उपलब्ध कराता है। नीचे दी गई तालिका 10 सबसे आम इवेंट्स को कवर करती है। पूरी सूची के लिए आधिकारिक हुक्स संदर्भ देखें।

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

UserPromptSubmit तब ट्रिगर होता है जब आप Claude को कोई प्रॉम्प्ट सबमिट करते हैं, आपके अनुरोध के प्रोसेस होने से पहले। आप इसका उपयोग अपनी बातचीत में संदर्भ जोड़ने या यह जाँचने के लिए कर सकते हैं कि प्रॉम्प्ट कुछ आवश्यकताओं को पूरा करते हैं।

Notification तब चलता है जब Claude आपको अलर्ट भेजता है, जैसे कमांड चलाने की अनुमति माँगना या इनपुट की आवश्यकता होना। PermissionRequest तब ट्रिगर होता है जब Claude Code अनुमति डायलॉग दिखाता है, जिससे आप उपयोगकर्ता की ओर से अपने‑आप अनुरोध को मंज़ूर या अस्वीकार कर सकते हैं।

Stop और SubagentStop तब ट्रिगर होते हैं जब Claude जवाब देना समाप्त करता है, जो अंतिम जाँच या रिपोर्ट बनाने के लिए उपयोगी है। दोनों में अंतर यह है कि Stop तब फायर होता है जब Claude अपना समग्र उत्तर समाप्त करता है, जबकि SubagentStop तब जब किसी टूल द्वारा स्पॉन किया गया हेल्पर (“सबएजेंट”) अपना काम पूरा करता है।

शेष इवेंट्स, PreCompact, SessionStart, और SessionEnd, लाइफ़साइकल‑विशिष्ट स्थितियों को संभालते हैं। PreCompact ठीक उस समय चलता है जब Claude बातचीत इतिहास को छोटा करने वाला होता है। ‘SessionStart’ नए सत्र की शुरुआत में डिफॉल्ट सेट करने के लिए फायर होता है, और SessionEnd सत्र बंद होने पर ट्रिगर होता है, जिससे क्लीनअप या अंतिम रपोर्टिंग संभव होती है।

मैचर्स को समझना

मैचर्स वे फ़िल्टर हैं जो तय करते हैं कि Claude Code की कौन‑सी क्रियाएँ किसी हुक को ट्रिगर करेंगी। तकनीकी रूप से, ये रेगुलर एक्सप्रेशन के रूप में व्याख्यायित स्ट्रिंग्स हैं, इसलिए आप सटीक मिलान या अधिक लचीले पैटर्न दोनों का उपयोग कर सकते हैं. 

सबसे प्रासंगिक मैचर्स सरल होते हैं, जैसे Write (जब Claude फ़ाइल लिखता है) या Edit (जब सामग्री संपादित होती है), और Edit|Write जैसे कॉम्बिनेशन जो कई कार्रवाइयों को कवर करते हैं. 

आप Notebook.* जैसे प्रीफ़िक्स पैटर्न का उपयोग करके उन सभी टूल्स से मेल खा सकते हैं जो “Notebook” से शुरू होते हैं। यदि आप चाहते हैं कि हुक हर कार्रवाई पर चले, तो यूनिवर्सल रेगेक्स .*, खाली स्ट्रिंग ("") या matcher खाली छोड़ दें।

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

Claude Code में अपना पहला हुक बनाना

Claude Code हुक सेट करने के दो तरीके देता है: इंटरैक्टिव /hooks कमांड से या सीधे कॉन्फ़िगरेशन फ़ाइलें संपादित करके। चलिए इंटरैक्टिव तरीके से शुरू करते हैं क्योंकि यह शुरुआती लोगों के लिए अधिक अनुकूल है।

/hooks कमांड का उपयोग करते हुए:

1. Claude Code खोलें और चैट इंटरफ़ेस में /hooks टाइप करें

2. अपना ट्रिगर इवेंट चुनें (इस उदाहरण के लिए PostToolUse चुनें)

3. मेनू से "Add new hook" चुनें

4. अपना मैचर पैटर्न सेट करें (Write दर्ज करें ताकि फ़ाइल लिखने को टार्गेट किया जाए)

5. अपना कमांड दर्ज करें:

• Mac: say "Task complete"

• Windows: powershell -c [console]::beep()

• Linux: spd-say "Task complete"

6. कॉन्फ़िगरेशन सहेजें और Esc तीन बार दबाकर Claude Code पर लौट आएँ

/hooks कमांड अपने‑आप आपकी सेटिंग्स फ़ाइल अपडेट करेगा और कॉन्फ़िगरेशन रीलोड करेगा। आप मौजूदा हुक देखने या बदलाव करने के लिए कभी भी /hooks चला सकते हैं।

यदि आप सीधे कॉन्फ़िगरेशन फ़ाइलें संपादित करना पसंद करते हैं, तो हुक्स ~/.claude/settings.json (ग्लोबल सेटिंग्स) में, .claude/settings.json (आपकी प्रोजेक्ट डायरेक्टरी के भीतर — टीम‑शेयर्ड हुक्स के लिए इसे रेपो में कमिट करें), या .claude/settings.local.json (पर्सनल हुक्स, जो डिफ़ॉल्ट रूप से gitignored होते हैं) में रहते हैं। हमारे ऊपर के उदाहरण के लिए, यह इस तरह दिखेगा:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "say 'Task complete'"
          }
        ]
      }
    ]
  }
}

फ़ाइल को मैन्युअल रूप से संपादित करने के बाद, Claude Code को रीस्टार्ट करें या /hooks कमांड का उपयोग करके अपना कॉन्फ़िगरेशन रीलोड करें। अब हर बार जब Claude कोई फ़ाइल लिखेगा, तो आपको ऑडियो नोटिफ़िकेशन सुनाई देगा।

अपने हुक का परीक्षण

आगे बढ़ने से पहले, सुनिश्चित करें कि आपका हुक वास्तव में काम करता है:

1. Claude से कोई भी Python फ़ाइल लिखने को कहें (जैसे, "एक hello.py फ़ाइल बनाएँ जो hello world प्रिंट करे")

2. जब Claude राइट ऑपरेशन पूरा करेगा, तो आपको ऑडियो नोटिफ़िकेशन सुनाई देना चाहिए

3. यदि कुछ सुनाई नहीं देता, तो कोई त्रुटि संदेश देखने के लिए Ctrl-O दबाकर Claude Code का ट्रांसक्रिप्ट जाँचें

4. आम समस्याओं में हुक कमांड न मिलना, गलत फ़ाइल अनुमतियाँ, या आपकी कॉन्फ़िगरेशन फ़ाइल में सिंटैक्स त्रुटियाँ शामिल हैं

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

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

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

हुक इनपुट्स के साथ काम करना

जब Claude Code कोई हुक ट्रिगर करता है, तो वह मानक इनपुट (stdin) के ज़रिये अभी‑अभी क्या हुआ इसकी जानकारी भेजता है, जो आपकी कमांड के चलते ही सीधे उसमें प्रवाहित होने वाली डेटा स्ट्रीम है। यही डेटा हुक्स को शक्तिशाली बनाता है—सिर्फ़ मनमाने समय पर चलने वाली स्क्रिप्ट्स नहीं. 

Claude Code इस जानकारी को JSON के रूप में पैकेज करता है और आपके द्वारा कॉन्फ़िगर की गई किसी भी कमांड—चाहे वह साधारण टर्मिनल कमांड हो या कस्टम स्क्रिप्ट—को फीड करता है।

हुक इनपुट्स की बनावट

हर हुक को मौजूदा सत्र के बारे में बेसिक फ़ील्ड्स वाला एक JSON ऑब्जेक्ट मिलता है:

{
  "session_id": "abc123",
  "transcript_path": "/Users/you/.claude/projects/my-project/conversation.jsonl", 
  "cwd": "/Users/you/my-project",
  "hook_event_name": "PostToolUse"
}

आइए हर घटक को समझें:

• session_id: आपके मौजूदा संवाद की पहचान करता है

• transcript_path: बातचीत के इतिहास की ओर इशारा करता है

• cwd: वर्किंग डायरेक्टरी दिखाता है

• hook_event_name: बताता है कि कौन‑सा इवेंट फायर हुआ

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

इवेंट‑आधारित इनपुट वैरिएशन

PreToolUse और PostToolUse जैसे टूल इवेंट्स में कार्रवाई के बारे में अतिरिक्त विवरण शामिल होते हैं, और यहीं से हुक्स ऑटोमेशन के लिए वाकई उपयोगी बनते हैं। PreToolUse में tool_input दिया होता है, और PostToolUse में इसके अलावा tool_response भी होता है:

{
  "session_id": "abc123",
  "hook_event_name": "PostToolUse",
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.py",
    "content": "print('Hello world')"
  },
  "tool_response": {
    "filePath": "/path/to/file.py", 
    "success": true
  }
}

हुक इनपुट में, file_path उस फ़ाइल का पथ दिखाता है जिसे लिखा या संपादित किया जा रहा है, जबकि content वह सटीक टेक्स्ट देता है जिसे टूल लिखने वाला है। निष्पादन के बाद, टूल की प्रतिक्रिया अंतिम filePath (ध्यान दें, यह camelCase है) को प्रतिध्वनित करती है ताकि यह पक्का हो सके कि वास्तव में कौन‑सी फ़ाइल प्रभावित हुई, साथ ही success फ़्लैग बताता है कि ऑपरेशन सही ढंग से पूरा हुआ या नहीं. 

यह विस्तृत जानकारी आपके हुक्स को वास्तव में जो हुआ उसके आधार पर अलग‑अलग प्रतिक्रिया देने देती है। आप केवल Python फ़ाइलों को फ़ॉर्मेट कर सकते हैं, सिर्फ़ महत्वपूर्ण डायरेक्टरीज़ का बैकअप ले सकते हैं, या केवल कुछ फ़ाइल प्रकार बदले जाने पर नोटिफ़िकेशन भेज सकते हैं।

UserPromptSubmit जैसे इवेंट्स सरल होते हैं क्योंकि इनमें टूल शामिल नहीं होते:

{
  "session_id": "abc123",
  "hook_event_name": "UserPromptSubmit", 
  "prompt": "Write a function to calculate factorial"
}

ध्यान दें कि UserPromptSubmit हुक्स अपनी कॉन्फ़िगरेशन में मैचर्स का उपयोग नहीं करते। वे सभी प्रॉम्प्ट्स पर ट्रिगर होते हैं, न कि टूल ऑपरेशंस पर। यह उन्हें बातचीत लॉग करने, प्रोजेक्ट संदर्भ अपने‑आप जोड़ने, या Claude द्वारा प्रोसेस करने से पहले प्रॉम्प्ट्स का वैलिडेशन करने के लिए उपयुक्त बनाता है।

व्यवहार में हुक इनपुट पढ़ना

आइए एक हुक बनाएँ जो हर उपयोगकर्ता प्रॉम्प्ट को लॉग करे। यह समस्या हल करता है कि आप Claude से क्या माँग रहे थे, यह ट्रैक से बाहर न हो—खासकर लंबी कोडिंग सत्रों में। पहले, हुक कॉन्फ़िगरेशन:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/log_prompts.py"
          }
        ]
      }
    ]
  }
}

अगला, ~/.claude/log_prompts.py पर निम्न सामग्री के साथ Python स्क्रिप्ट बनाएँ:

#!/usr/bin/env python3
import json
import sys
from datetime import datetime

# Read JSON data from stdin
input_data = json.load(sys.stdin)

# Extract information
session_id = input_data.get("session_id", "unknown")
prompt = input_data.get("prompt", "")
timestamp = datetime.now().isoformat()

# Log the prompt
log_entry = f"{timestamp} | Session: {session_id[:8]} | {prompt}\n"
with open("prompt_history.txt", "a") as f:
    f.write(log_entry)

स्क्रिप्ट Claude Code द्वारा भेजा गया JSON डेटा पढ़ती है और सत्र संदर्भ के साथ प्रॉम्प्ट को लॉग करती है। यह आपकी बातचीत का खोजने‑योग्य इतिहास बनाती है, जो हफ़्तों बाद किसी समस्या का हल याद करने में अमूल्य साबित होता है।

हुक आउटपुट्स के साथ काम करना

आपका हुक कमांड चलने के बाद, उसे Claude Code को बताना होता है कि क्या हुआ और आगे सामान्य रूप से जारी रखना है या नहीं। यही नियंत्रण तंत्र हुक्स को साधारण लॉगिंग टूल्स से शक्तिशाली वर्कफ़्लो ऑटोमेशन में बदल देता है, जो Claude के व्यवहार को निर्देशित कर सकता है। यह तीन चैनलों से होता है: स्टैंडर्ड आउटपुट (stdout), स्टैंडर्ड एरर (stderr), और एग्ज़िट कोड्स।

आउटपुट चैनल्स और एग्ज़िट कोड्स

स्टैंडर्ड आउटपुट (stdout) सामान्य आउटपुट के लिए होता है। उदाहरण के लिए, यदि आप कुछ प्रिंट करते हैं, तो वह stdout में जाता है। अधिकांश हुक्स के लिए, यह Claude Code के ट्रांसक्रिप्ट में तब दिखाई देता है जब आप Ctrl-O दबाते हैं, जिससे आपको यह रिकॉर्ड मिलता है कि आपके ऑटोमेशन ने क्या किया, बिना मुख्य बातचीत को अव्यवस्थित किए।

स्टैंडर्ड एरर (stderr) त्रुटि संदेशों के लिए होता है। आप stderr पर लिख सकते हैं 

• Python: print("message", file=sys.stderr) या

• कमांड लाइन: echo "message" >&2

मुख्य अंतर यह है कि stderr सीधे Claude को स्वतः प्रोसेसिंग के लिए भेजा जा सकता है, जिससे वह आपके हुक्स द्वारा पाई गई समस्याओं पर प्रतिक्रिया दे सके।

एग्ज़िट कोड Claude Code को बताते हैं कि आगे क्या करना है:

• एग्ज़िट कोड 0: सफलता (उपयोगकर्ता को stdout दिखाता है)

• एग्ज़िट कोड 2: ब्लॉकिंग त्रुटि (stderr Claude को भेजता है)

• अन्य कोड्स: नॉन‑ब्लॉकिंग त्रुटि (उपयोगकर्ता को stderr दिखाता है, लेकिन आगे जारी रहता है)

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

एग्ज़िट कोड 0: सामान्य संचालन

ज़्यादातर हुक्स एग्ज़िट कोड 0 का उपयोग करते हैं यह संकेत देने के लिए कि सब ठीक रहा। यहाँ एक पूरा हुक है जो फ़ाइल ऑपरेशंस को लॉग करता है और उपयोगकर्ता को सूचित करता है:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import datetime; open('activity.log','a').write('File written: ' + datetime.datetime.now().isoformat() + '\\n'); print('Logged file operation')\""
          }
        ]
      }
    ]
  }
}

यह हुक दो काम करता है: फ़ाइल में लॉगिंग, फिर ट्रांसक्रिप्ट में मैसेज प्रिंट करना। ऐसा करने के कई तरीके हैं, लेकिन यह तरीका क्रॉस‑प्लेटफ़ॉर्म है और कमांड‑लाइन विशिष्टताओं पर निर्भर नहीं करता।

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

एग्ज़िट कोड 2: फीडबैक के साथ ब्लॉक करना

एग्ज़िट कोड 2 आपका एरर संदेश सीधे Claude को भेजता है, जिससे वह अपने‑आप प्रतिक्रिया दे सके। यहीं हुक्स सुरक्षा तंत्र बन जाते हैं, सिर्फ़ ऑटोमेशन नहीं। यहाँ एक हुक है जो खतरनाक फ़ाइल ऑपरेशंस को ब्लॉक करता है:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/security_check.py"
          }
        ]
      }
    ]
  }
}

आपको ~/.claude/security_check.py पर सिक्योरिटी चेक स्क्रिप्ट बनानी होगी:

#!/usr/bin/env python3
import json
import sys

# Read hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Check for dangerous patterns
dangerous_paths = ["/etc/", "/usr/", "production.conf"]
is_dangerous = any(pattern in file_path for pattern in dangerous_paths)

if is_dangerous:
    # Block the operation and tell Claude why
    print(f"Blocked modification of {file_path} - this appears to be a system or production file", file=sys.stderr)
    sys.exit(2)  # Sends stderr message to Claude
else:
    # Allow the operation
    print(f"Approved modification of {file_path}")
    sys.exit(0)  # Shows stdout in transcript

जब यह हुक खतरनाक पथ का पता लगाता है, तो यह कोड 2 के साथ बाहर निकलता है। Claude Code stderr संदेश Claude को भेजता है, जो फिर आपको समझा सकता है कि ऑपरेशन क्यों ब्लॉक किया गया और विकल्प सुझा सकता है। यह सिस्टम फ़ाइलों को आकस्मिक नुकसान से बचाता है, साथ ही Claude को आपकी सुरक्षा नीतियों के बारे में सूचित रखता है।

Claude Code के लिए स्मार्ट नोटिफ़िकेशन हुक बनाना

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

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/smart_notify.py"
          }
        ]
      }
    ]
  }
}

~/.claude/smart_notify.py पर नोटिफ़िकेशन स्क्रिप्ट बनाएँ:

#!/usr/bin/env python3
import json
import sys
import os
import subprocess

# Read the hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Categorize file importance
important_extensions = [".py", ".js", ".ts", ".java", ".cpp"]
config_files = ["Dockerfile", "requirements.txt", "package.json"]

is_code = any(file_path.endswith(ext) for ext in important_extensions)
is_config = any(filename in file_path for filename in config_files)

if is_code:
    # Important: notify and log
    print(f"Code file modified: {os.path.basename(file_path)}")
    subprocess.run(["say", "Code updated"], check=False)  # Mac
    sys.exit(0)  # Show message in transcript
elif is_config:
    # Very important: louder notification
    print(f"Configuration file changed: {os.path.basename(file_path)}")
    subprocess.run(["say", "Configuration updated - review changes"], check=False)
    sys.exit(0)
else:
    # Not important: silent success
    sys.exit(0)

यह हुक इनपुट को पढ़कर समझता है कि कौन‑सी फ़ाइल बदली, फ़ाइल प्रकार के आधार पर नोटिफ़िकेशन की महत्ता तय करता है, stdout का उपयोग करके महत्वपूर्ण बदलावों को ट्रांसक्रिप्ट में लॉग करता है, फ़ाइल प्रकार के आधार पर अलग‑अलग ऑडियो अलर्ट ट्रिगर करता है, और हमेशा कोड 0 के साथ बाहर निकलता है क्योंकि ये जानकारी देने वाले कार्य हैं, ब्लॉक करने वाले नहीं।

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

कृपया ध्यान दें कि इस उदाहरण में say कमांड का उपयोग किया गया है, जो macOS पर उपलब्ध है। Linux पर आप notify-send का प्रयोग कर सकते हैं, और Windows पर समान नोटिफ़िकेशन के लिए PowerShell कमांड इस्तेमाल कर सकते हैं।

Claude Code Hooks के साथ आम परेशानियाँ

पहले हफ्ते में अधिकांश लोगों को कुछ बातें उलझन में डालती हैं:

शेल प्रोफ़ाइल के echo स्टेटमेंट हुक्स तोड़ देते हैं। हुक्स नॉन‑इंटरैक्टिव शेल्स में चलते हैं जो आपका ~/.zshrc या ~/.bashrc सोर्स करते हैं। यदि आपकी प्रोफ़ाइल में बिना शर्त echo स्टेटमेंट्स हैं, तो वे हुक stdout के आगे टेक्स्ट जोड़ देते हैं और JSON पार्सिंग बिगाड़ देते हैं। इन्हें इंटरैक्टिव‑शेल चेक में लपेटें:

if [[ $- == *i* ]]; then
  echo "Welcome back"
fi

Stop हुक्स अनंत लूप में जा सकते हैं। Stop हुक जो कोड 2 के साथ बाहर निकलता है, Claude को काम जारी रखने पर मजबूर करता है। यदि आपकी स्क्रिप्ट इनपुट JSON के stop_hook_active को जाँचकर उसके true होने पर साफ़ तरह से बाहर नहीं निकलती, तो आप टाइमआउट तक घूमते रहेंगे। हमेशा एक प्रारंभिक गार्ड शामिल करें।

मैचर्स केस‑सेंसिटिव होते हैं। bash Bash से मेल नहीं खाता। Claude Code में दिखने वाले सटीक टूल नाम का उपयोग करें।

आउटपुट 10,000 कैरेक्टर पर कैप्ड है। यदि आपका हुक इससे अधिक जनरेट करता है, तो Claude के संदर्भ में इंजेक्ट होने से पहले यह ट्रंकेट हो जाएगा। stdout को संक्षिप्त रखें और केवल वही सतह पर लाएँ जिसकी मॉडल को कार्रवाई के लिए ज़रूरत है।

टीम‑स्तरीय और पर्सनल हुक्स में भ्रम। .claude/settings.json में हुक्स टीम के साथ साझा होते हैं (उन्हें रेपो में कमिट करें)। निजी हुक्स जिन्हें आप साझा नहीं करना चाहते, उनके लिए .claude/settings.local.json का उपयोग करें, जो डिफ़ॉल्ट रूप से gitignored है।

हुक्स बनाम स्किल्स: कब क्या उपयोग करें

हुक्स और Claude Skills अलग‑अलग उद्देश्य पूरा करते हैं और साथ मिलकर सबसे अच्छा काम करते हैं। कोई स्किल एक मार्कडाउन फ़ाइल होती है जो Claude को कुछ करना सिखाती है (प्रक्रियाएँ, परंपराएँ, टेम्पलेट्स)। एक हुक एक शेल कमांड होता है जो कोई नियम निर्धारक तरीके से लागू करता है, भले ही Claude कुछ भी निर्णय ले।

अंतर मायने रखता है: स्किल एक सुझाव है जिसे मॉडल दबाव में नज़रअंदाज़ कर सकता है; हुक हर बार फायर होता है। अपनी टीम की माइग्रेशन प्रक्रिया दस्तावेज़ करने के लिए एक स्किल लिखें। Claude द्वारा लिखी हर .sql फ़ाइल पर माइग्रेशन लिंटर चलाने के लिए PostToolUse हुक लिखें। स्किल Claude को दक्ष बनाती है; हुक Claude को जवाबदेह बनाता है।

Claude Code Hooks के लिए उन्नत पैटर्न

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

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

इनमें से हर पैटर्न को आपके विशेष टूल्स और वर्कफ़्लो के लिए कस्टमाइज़ किया जा सकता है। उन चीज़ों से शुरू करें जो आपकी रोज़मर्रा की सबसे बड़ी झुंझलाहटें हल करती हैं, फिर जैसे‑जैसे हुक डेवलपमेंट में सहज हों, अपना ऑटोमेशन बढ़ाएँ।

सुरक्षा और अनुपालन के लिए उन्नत हुक्स

हुक्स सुरक्षा नियमों और अनुपालन मानकों को लागू करने के लिए बेहतरीन हैं। यहाँ चार उपयोग मामले हैं।

API कुंजी स्कैनर

• समस्या: गोपनीय जानकारियों का गलती से वर्शन कंट्रोल में कमिट होना

• ट्रिगर्स: किसी भी फ़ाइल को लिखने से पहले

• समाधान: रेगेक्स पैटर्न से फ़ाइल सामग्री में API कुंजियाँ, टोकन और पासवर्ड स्कैन करना

“एक Python स्क्रिप्ट बनाएँ जो हुक इनपुट JSON पढ़े, फ़ाइल सामग्री निकाले, और api_key=, token:, या password= जैसे आम सीक्रेट फ़ॉर्मैट्स का पता लगाने के लिए रेगेक्स पैटर्न का उपयोग करे। संदिग्ध मिलान के लिए लोकल वैरिफ़िकेशन करें और कभी भी कच्चे सीक्रेट्स बाहरी रूप से न भेजें. 

केवल मास्क किए गए अंश (जैसे, 4 प्रीफ़िक्स/सफ़िक्स कैरेक्टर रखें) या हैश Anthropic API को भेजें ताकि संदिग्ध स्ट्रिंग्स का विश्लेषण कर सकें और तय कर सकें कि वे वास्तविक सीक्रेट हैं या वैरिएबल नाम। एग्ज़िट कोड 2 के साथ बाहर निकलें और पाए गए सीक्रेट्स तथा सुरक्षित विकल्पों के बारे में Claude को फीडबैक दें।”

लाइसेंस हेडर एन्फ़ोर्सर

• समस्या: ओपन सोर्स प्रोजेक्ट्स में नई फ़ाइलों में आवश्यक लाइसेंस हेडर का न होना

• ट्रिगर्स: सोर्स कोड फ़ाइलें लिखने से पहले

• समाधान: नई .py, .js, .java फ़ाइलों में उचित लाइसेंस टेक्स्ट का वैलिडेशन

“हुक इनपुट को पार्स करें ताकि फ़ाइल सामग्री मिले और पहले 10 लाइनों में स्ट्रिंग मैचिंग से लाइसेंस टेक्स्ट जाँचें। अधिक उन्नत वैलिडेशन के लिए, फ़ाइल हेडर को Anthropic API के ज़रिये Claude को भेजें ताकि यह सत्यापित हो सके कि इसमें उचित कॉपीराइट नोटिस और लाइसेंस जानकारी है। हेडर न होने पर एग्ज़िट कोड 2 के साथ फ़ाइल निर्माण ब्लॉक करें, और जोड़ने के लिए सही लाइसेंस टेम्पलेट Claude को दें।”

प्रोडक्शन फ़ाइल गार्ड

• समस्या: महत्वपूर्ण सिस्टम कॉन्फ़िगरेशन फ़ाइलों में गलती से संशोधन

• ट्रिगर्स: संवेदनशील डायरेक्टरीज़ में फ़ाइलें एडिट करने से पहले

• समाधान: /etc/, nginx.conf, database.yml, और अन्य महत्वपूर्ण कॉन्फ़िग्स में बदलाव ब्लॉक करना

“हुक इनपुट JSON से फ़ाइल पथ निकालें और जाँचें कि क्या यह /etc/, production.yml या अन्य महत्वपूर्ण फ़ाइल नामों जैसे पैटर्न से मेल खाता है। Claude के API का उपयोग करके फ़ाइल पथ का विश्लेषण करें और निर्धारित करें कि क्या यह ऐसा कॉन्फ़िगरेशन है जो प्रोडक्शन सिस्टम्स को प्रभावित कर सकता है। खतरनाक पथ का पता चलने पर एग्ज़िट कोड 2 के साथ बाहर निकलें और सुरक्षित डेवलपमेंट प्रथाओं पर विशेष मार्गदर्शन दें।”

इमेज ऑप्टिमाइज़र

• समस्या: बड़ी इमेज फ़ाइलें ऐप्लिकेशन और रेपो को धीमा करती हैं

• ट्रिगर्स: नई इमेज फ़ाइलें जोड़ने के बाद

• समाधान: PNG/JPEG को विज़ुअल क्वॉलिटी बनाए रखते हुए कंप्रेस करना

“हुक इनपुट को पार्स करें ताकि फ़ाइल पथ मिले और एक्सटेंशन मैचिंग से जाँचें कि क्या यह इमेज फ़ाइल है। imageoptim जैसे कंप्रेशन टूल चलाएँ या क्वॉलिटी बनाए रखते हुए TinyPNG API कॉल करें। कंप्रेशन परिणामों को stdout में लॉग करें ताकि Claude के ट्रांसक्रिप्ट में फ़ाइल आकार बचत दिखे।”

वर्ज़न कंट्रोल ऑटोमेशन के लिए उन्नत हुक्स

Git वर्कफ़्लोज़ और डोक्युमेंटेशन ऐसे क्षेत्र हैं जहाँ हुक्स बहुत उपयोगी होते हैं। कुछ विचार देखते हैं।

Git ब्रांच वैलिडेटर

• समस्या: टीम के सदस्य गलती से प्रोटेक्टेड ब्रांचेज़ पर पुश कर देते हैं

• ट्रिगर्स: किसी भी फ़ाइल लिखने या एडिट ऑपरेशन से पहले

• समाधान: मौजूदा Git ब्रांच जाँचना और main/master/production पर ऑपरेशंस ब्लॉक करना

“साधारण bash कमांड git branch --show-current से वर्तमान ब्रांच नाम लें और प्रोटेक्टेड ब्रांचेज़ की सूची से तुलना करें। यदि प्रोटेक्टेड ब्रांच पर हैं, तो एग्ज़िट कोड 2 के साथ बाहर निकलें और ब्रांच प्रोटेक्शन नीतियाँ समझाता हुआ एरर संदेश Claude को भेजें। जटिल नामकरण नियमों के लिए, Claude के API से ब्रांच नामों का विश्लेषण कराएँ और जाँचें कि वे प्रोटेक्शन पैटर्न से मेल खाते हैं या नहीं।”

स्मार्ट ऑटो‑कमिट

• समस्या: परिवर्तनों को कमिट करना भूल जाना या खराब कमिट संदेश लिखना

• ट्रिगर्स: किसी भी फ़ाइल संशोधन के बाद

• समाधान: AI‑जनित वर्णनात्मक संदेशों के साथ बदलावों को अपने‑आप स्टेज और कमिट करना

“हुक इनपुट से संशोधित फ़ाइल पथ पढ़ें, बदलाव पाने के लिए git diff चलाएँ, और Claude के API को एक प्रॉम्प्ट के साथ डिफ़ भेजें जो संक्षिप्त कमिट संदेश माँगता हो। जनरेट किए गए संदेश का उपयोग git add और git commit के साथ करके बदलाव अपने‑आप कमिट करें। API प्रॉम्प्ट में फ़ाइल नाम और बदलाव के प्रकार शामिल करें ताकि कमिट संदेश conventional commits मानकों का पालन करें।”

डॉक्युमेंटेशन जेनरेटर

• समस्या: API डोक्युमेंटेशन का कोड बदलावों के साथ असंगत हो जाना

• ट्रिगर्स: इंटरफ़ेस फ़ाइलें (कंट्रोलर्स, मॉडल्स, APIs) संशोधित करने के बाद

• समाधान: JSDoc, Sphinx, या OpenAPI जेनरेटर जैसे डोक्युमेंटेशन टूल्स अपने‑आप चलाना

“पैटर्न मैचिंग से संशोधित फ़ाइल पथ जाँचें कि क्या यह API एंडपॉइंट, मॉडल, या इंटरफ़ेस फ़ाइल है। Claude के API को फ़ाइल सामग्री भेजें, उससे API बदलाव निकालने और डोक्युमेंटेशन अपडेट जनरेट करने के लिए कहें। उपयुक्त डोक्युमेंटेशन टूल (jsdoc, sphinx-build, आदि) चलाएँ और अपडेटेड डोक्युमेंटेशन अपने‑आप कमिट करें।”

सहयोग और वर्कफ़्लो एकीकरण के लिए उन्नत हुक्स

आख़िर में, हुक्स आपकी टीम के सभी सदस्यों को अपडेटेड रखने में मदद कर सकते हैं।

Slack इंटीग्रेशन

• समस्या: टीम का साझा कोडबेस में महत्वपूर्ण बदलावों से अनजान रहना

• ट्रिगर्स: महत्वपूर्ण ऑपरेशंस के लिए नोटिफ़िकेशन भेजे जाने पर

• समाधान: फ़ाइल नामों और बदलाव सारांशों के साथ टीम चैनलों में फ़ॉर्मैटेड संदेश पोस्ट करना

“हुक इनपुट से फ़ाइल जानकारी निकालें और सोर्स कोड या कॉन्फ़िगरेशन फ़ाइलों जैसे महत्वपूर्ण प्रकारों के लिए फ़िल्टर करें। फ़ाइल नाम और प्रकार के आधार पर क्या बदला इसका मानव‑पठनीय सारांश जनरेट करने के लिए Claude के API का उपयोग करें। फ़ॉर्मैटेड संदेश Slack पर वेबहुक URLs के माध्यम से भेजें और महत्वपूर्ण बदलावों के लिए टीम सदस्यों को मेंशन करें।”

Webhook डिस्पैचर

• समस्या: मैनुअल CI/CD पाइपलाइन ट्रिगर्स से डिप्लॉयमेंट में देरी

• ट्रिगर्स: जब विशिष्ट इवेंट होते हैं (कॉन्फ़िग परिवर्तन, डिप्लॉयमेंट फ़ाइलें संशोधित)

• समाधान: बिल्ड, डिप्लॉयमेंट या अन्य ऑटोमेटेड प्रक्रियाएँ ट्रिगर करने के लिए बाहरी APIs कॉल करना

“संशोधित फ़ाइल पथ को Dockerfile, package.json या डिप्लॉयमेंट कॉन्फ़िग्स जैसे पैटर्न से मिलाएँ ताकि तय हो सके कि CI/CD ट्रिगर होना चाहिए या नहीं। Python में requests लाइब्रेरी का उपयोग कर ऑथेंटिकेशन हेडर्स और बदलावों के बारे में पेलोड डेटा सहित वेबहुक URLs कॉल करें। वेबहुक पेलोड में फ़ाइल पथ और बदलाव मेटाडेटा शामिल करें ताकि बाहरी सिस्टम यह तय कर सकें कि क्या बिल्ड या डिप्लॉय करना है।”

स्टेटस पेज अपडेटर

• समस्या: ग्राहकों का मेंटेनेंस या डिप्लॉयमेंट गतिविधियों से अनजान रहना

• ट्रिगर्स: जब डिप्लॉयमेंट या इन्फ्रास्ट्रक्चर फ़ाइलें बदली जाती हैं

• समाधान: सेवा स्टेटस पेजों पर मेंटेनेंस नोटिफ़िकेशन अपडेट करना

“Kubernetes मैनिफ़ेस्ट या Terraform कॉन्फ़िग्स जैसे इन्फ्रास्ट्रक्चर फ़ाइल बदलावों के लिए हुक इनपुट को फ़ाइल पथ पैटर्न से पार्स करें। पाए गए इन्फ्रास्ट्रक्चर बदलावों के प्रकार के आधार पर Claude के API से मेंटेनेंस संदेश जनरेट करें। StatusPage.io या PagerDuty जैसी सेवाओं पर उनके REST APIs से उपयुक्त इन्सिडेंट प्रकार और अनुमानित अवधि सहित स्टेटस अपडेट पोस्ट करें।”

टीम स्टेटस नोटिफ़ायर

• समस्या: कई डेवलपर्स का अनजाने में एक ही फीचर पर काम करना और टकराव होना

• ट्रिगर्स: नए Claude Code सत्र की शुरुआत पर

• समाधान: उस प्रोजेक्ट या कंपोनेंट पर काम शुरू करने की सूचना टीम चैनलों को देना

“हुक इनपुट से प्रोजेक्ट डायरेक्टरी पढ़ें और किस प्रकार का काम हो रहा है समझने के लिए हाल की फ़ाइलों या git इतिहास का विश्लेषण करने हेतु Claude के API का उपयोग करें। आपका नाम, प्रोजेक्ट नाम, और फोकस एरिया सहित फ़ॉर्मैटेड संदेश टीम संचार चैनलों पर भेजें। अनुमानित कार्य अवधि शामिल करें और टीम के सदस्यों को आमंत्रित करें कि वे संबंधित फीचर्स पर काम कर रहे हों तो समन्वय करें।”

अंतिम विचार

Claude Code Hooks अनिश्चित AI कोडिंग असिस्टेंट्स को ऐसे ऑटोमेटेड वर्कफ़्लोज़ में बदल देते हैं जो ठीक उसी समय चलते हैं जब आपको उनकी ज़रूरत होती है। इस ट्यूटोरियल में, आपने इंटरैक्टिव /hooks कमांड और मैनुअल कॉन्फ़िगरेशन दोनों का उपयोग करके हुक सेट करना, समझदार ऑटोमेशन को शक्ति देने वाले JSON इनपुट डेटा को समझना, और एग्ज़िट कोड्स तथा स्ट्रक्चर्ड आउटपुट्स के ज़रिये Claude के व्यवहार को नियंत्रित करना सीखा है. 

हमने जिन व्यावहारिक पैटर्न्स को कवर किया, उनमें खतरनाक ऑपरेशंस को ब्लॉक करने वाले सुरक्षा वैलिडेटर और शोर घटाने वाली स्मार्ट नोटिफ़िकेशन शामिल हैं। ये उदाहरण दिखाते हैं कि हुक्स वास्तविक डेवलपमेंट समस्याएँ कैसे हल करते हैं और आपको अपने AI असिस्टेंट पर पूरा नियंत्रण देते हैं। अब जब आप मूल बातें समझते हैं, तो आप अपनी टीम के विशिष्ट वर्कफ़्लो की ज़रूरतों से मेल खाने वाला ऑटोमेशन बना सकते हैं. 

AI टूल्स के साथ काम करना और सीखने के लिए, DataCamp का Understanding Prompt Engineering कोर्स देखें, जो सीधे हुक डेवलपमेंट से जुड़ी प्रॉम्प्टिंग रणनीतियों को कवर करता है। व्यापक AI कोडिंग स्किल्स के लिए हमारा Intermediate ChatGPT कोर्स आज़माएँ, ताकि AI असिस्टेंट्स को आपके डेवलपमेंट वर्कफ़्लो में अधिक भरोसेमंद पार्टनर बनाने वाली स्किल्स विकसित हों।