जब मैंने Claude Code का उपयोग शुरू किया, तो मैं इसे एक चैट की तरह मानता था।
मैं कुछ माँगता, वह जवाब देता, और बस इतना ही।
यह काम करता था, लेकिन समय के साथ मैंने देखा कि मैं इसका पूरा लाभ नहीं उठा पा रहा था।
मैं वही प्रॉम्प्ट दोहराता था। मैं वही कमांड चलाता था। मुझे स्पष्ट नहीं था कि इसका पूरा फायदा कैसे उठाया जाए।
इसलिए मैंने रुककर खुद से एक सवाल पूछा:
Claude Code अंदर से वास्तव में कैसे काम करता है?
मैंने डॉक्यूमेंटेशन पढ़ना शुरू किया, प्रयोग करना और परीक्षण करना शुरू किया।
और मैंने जो खोजा वह यह है:
यह कोई जादू नहीं करता। यह ठोस भागों पर बना है, प्रत्येक की एक स्पष्ट भूमिका है। और जब आप उन्हें समझ लेते हैं, तो बाकी सब कुछ समझ में आने लगता है।
→ अगर आप हमेशा वही निर्देश दोहराते हैं, तो उन्हें एक Skill में बदल दें।
→ अगर यह किसी लंबे कार्य में धागा खो देता है, तो किसी SubAgent को सौंप दें।
→ अगर कुछ मैन्युअल चरण हैं जिन्हें आप दोहराते हैं, तो उन्हें Hooks के साथ स्वचालित करें।
मूल सिद्धांतों को समझना ही आपको यह जानने में सक्षम बनाता है कि क्या, कब और क्यों उपयोग करना है।
आज मेरे पास 100 से अधिक Skills हैं, स्वचालित प्रक्रियाएँ जिनमें पहले मुझे घंटों लगते थे, और कोड रिव्यू करने और मेरे लिए रुचिकर विषयों का अध्ययन करने के लिए एजेंट हैं।
मैंने यह लेख आपके साथ वह सब कुछ साझा करने के लिए लिखा है जो मैंने सीखा है।
चलिए शुरू करते हैं।
Agent Loop: Claude Code का हृदय
Claude Code एक एजेंट है।
एक सिस्टम जिसे आप एक लक्ष्य देते हैं और वह तब तक काम करता है जब तक वह उसे पूरा नहीं कर लेता।
यह एक चैट से अलग है। चैट में, आप पूछते हैं "मैं अपने ऐप में ऑथेंटिकेशन कैसे जोड़ूं?" और वह चरणों की व्याख्या करता है।
लेकिन आपको प्रोजेक्ट में जाना होगा, कोड में बदलाव करना होगा, और परीक्षण करना होगा कि यह काम करता है या नहीं।
काम आप करते हैं।
Claude Code के साथ, आप उसे बताते हैं "मेरे ऐप में ऑथेंटिकेशन जोड़ें" और वह इसका ध्यान रखता है।
यह कोड पढ़ता है, लाइब्रेरी चुनता है, बदलाव लिखता है, और जब यह समाप्त हो जाता है तो आपको सूचित करता है।
इसका एक लक्ष्य है: ऑथेंटिकेशन जोड़ना।
और यह तब तक काम करता है जब तक वह इसे पूरा नहीं कर लेता।
लेकिन यह कैसे जानता है कि प्रत्येक चरण के बाद क्या करना है? यह कैसे जानता है कि कुछ काम किया या नहीं? उन निर्णयों को समन्वयित करने के लिए इसे किसी चीज़ की आवश्यकता होती है।
वह है लूप।
एक चक्र जो खुद को दोहराता है।
Claude Code एक क्रिया निष्पादित करता है, परिणाम देखता है, तय करता है कि आगे क्या करना है, और फिर से शुरू करता है। यह तब तक नहीं रुकता जब तक लक्ष्य पूरा नहीं हो जाता।
अगर कुछ विफल होता है, तो यह वापस जाता है, सुधार करता है, और जारी रखता है।
लूप के 3 चरण हैं:
संदर्भ एकत्र करें → समझता है कि इसे क्या करना है। फ़ाइलें पढ़ता है, कोड का विश्लेषण करता है, प्रोजेक्ट संरचना का पता लगाता है।
कार्रवाई करें → परिवर्तन निष्पादित करता है। फ़ाइलों को संपादित करता है, कमांड चलाता है, निर्भरताएँ स्थापित करता है।
परिणाम सत्यापित करें → जाँचता है कि उसने जो किया वह काम करता है। टेस्ट चलाता है, त्रुटियों की समीक्षा करता है, अगर कुछ विफल होता है तो सुधार करता है।
लूप आप जो पूछते हैं उसके अनुसार अनुकूलित होता है।
एक साधारण प्रश्न के लिए केवल संदर्भ एकत्र करने की आवश्यकता हो सकती है। किसी बग को ठीक करने के लिए तीनों चरणों से कई बार गुजरना पड़ सकता है।
Claude Code तय करता है कि प्रत्येक चरण के लिए पिछले चरण से सीखी गई बातों के आधार पर क्या आवश्यक है। और आप भी उस लूप का हिस्सा हैं।
आप किसी भी समय इसे पुनर्निर्देशित करने, संदर्भ जोड़ने, या किसी अन्य दृष्टिकोण को आज़माने के लिए कहने के लिए बाधित कर सकते हैं।
यह Claude Code का हृदय है।
बाकी सब कुछ इस लूप को और अधिक शक्तिशाली बनाने के लिए मौजूद है।
टूल्स: Claude Code दुनिया में कैसे कार्य करता है
एक LLM, डिज़ाइन के अनुसार, केवल टेक्स्ट प्रोसेस करता है।
यह टेक्स्ट प्राप्त करता है और टेक्स्ट उत्पन्न करता है। इसकी आपकी फ़ाइल सिस्टम तक पहुँच नहीं है, यह कमांड निष्पादित नहीं कर सकता, यह नहीं जानता कि आपके प्रोजेक्ट में क्या है।
यह पृथक है।
तो, Claude Code एक फ़ाइल कैसे खोलता या संशोधित करता है?
यह टूल्स का उपयोग करता है।
टूल्स ऐसे फ़ंक्शन हैं जिन्हें Claude Code वास्तविक दुनिया के साथ बातचीत करने के लिए लागू कर सकता है।
इसे मोबाइल ऐप्स की तरह समझें। फ़ोन अकेला कुछ नहीं करता: यह ऐप्स हैं जो इसे विशिष्ट क्षमताएँ देते हैं: फ़ोटो लेना, संदेश भेजना, नेविगेट करना।
टूल्स Claude Code के लिए समान हैं।
जब भी यह एक टूल का उपयोग करता है, यह सिस्टम को अपनी आवश्यकता के अनुसार एक अनुरोध भेजता है। सिस्टम इसे निष्पादित करता है और परिणाम लौटाता है।
Claude Code आगे क्या करना है यह तय करने के लिए उस परिणाम का उपयोग करता है।
1आपका अनुरोध2 ↓3Claude Code तय करता है कि कौन सा टूल उपयोग करना है4 ↓5┌─────────────────────────────────┐6│ Read · Edit · Write · Bash │7│ Grep · Glob · WebFetch · WebSearch │8└─────────────────────────────────┘9 ↓10सिस्टम टूल निष्पादित करता है11 ↓12परिणाम Claude Code को वापस आता है13 ↓14समाप्त? → नहीं → दूसरा टूल उपयोग करें15 हाँ → उत्तर दें
Claude Code सबसे सामान्य कार्यों के लिए नेटिव टूल्स के साथ आता है:
Read / Edit / Write → फ़ाइलों को पढ़ना, संशोधित करना और बनाना। सबसे अधिक उपयोग किए जाने वाले। जब भी Claude Code "आपके कोड को समझता है" या "कोई बदलाव करता है," यह इन तीनों का उपयोग कर रहा होता है।
Bash → टर्मिनल तक पूर्ण पहुँच। यदि आप इसे कमांड लाइन से कर सकते हैं, तो Claude Code भी कर सकता है: निर्भरताएँ स्थापित करना, टेस्ट चलाना, कमिट करना।
Grep और Glob → प्रोजेक्ट के भीतर खोज। Glob नाम या पैटर्न के आधार पर फ़ाइलें ढूँढता है। Grep फ़ाइलों के भीतर विशिष्ट सामग्री खोजता है।
WebFetch और WebSearch → इंटरनेट पहुँच। डॉक्यूमेंटेशन से परामर्श करना, एक API पढ़ना, किसी ऐसी त्रुटि की जाँच करना जो उसने पहले कभी नहीं देखी।
लॉगिन बटन में बग के उदाहरण पर वापस आते हैं।
जब Claude Code उस पर काम करता है, तो यह एक साथ कई टूल का उपयोग करता है:
→ यह कंपोनेंट फ़ाइल खोजने के लिए Glob का उपयोग करता है
→ यह कोड पढ़ने और समझने के लिए Read का उपयोग करता है कि क्या हो रहा है
→ यह त्रुटि ठीक करने के लिए Edit का उपयोग करता है
→ यह टेस्ट चलाने और सत्यापित करने के लिए Bash का उपयोग करता है कि यह काम करता है
यह सब आपके हस्तक्षेप के बिना। यही एक चैट और एक एजेंट के बीच का अंतर है।
संदर्भ और मेमोरी: Claude Code क्या याद रखता है
Claude Code काम करता है, कार्य करता है, परिणाम प्राप्त करता है, और तय करता है कि आगे क्या करना है।
लेकिन यह कैसे जानता है कि उसने आगे बढ़ने पर क्या किया?
यह सब संदर्भ की बदौलत है।
संदर्भ वह जानकारी है जो उस समय Claude Code के पास उपलब्ध होती है। जब भी यह कोई कार्य करता है, परिणाम उसमें जमा होता जाता है।
न केवल आपका प्रारंभिक प्रॉम्प्ट, बल्कि वह सब कुछ जो यह पाता है: इसके द्वारा खोली गई फ़ाइलें, कोड में इसने क्या खोजा, इसके द्वारा निष्पादित कार्य, और उनके परिणाम।
यही कारण है कि यह चरणों को श्रृंखलाबद्ध कर सकता है, खुद को सुधार सकता है, और अकेले कार्य पूरा कर सकता है।
उस संदर्भ की 2 समस्याएँ हैं।
1. इसकी सीमित क्षमता है। यदि सत्र बहुत लंबा है, तो संदर्भ भर जाता है और Claude Code भूलने लगता है कि पहले क्या हुआ था। बाद में आप देखेंगे कि SubAgents इसे कैसे हल करते हैं।
2. जब भी आप एक नई बातचीत शुरू करते हैं तो यह खाली हो जाता है। Claude Code नहीं जानता कि आप किस प्रोजेक्ट में हैं, आपकी टीम कैसे काम करती है, या उन्होंने पहले से क्या निर्णय लिए हैं। यदि आप इसे नहीं बताते, तो यह अनुमान लगाता है या आपसे पूछता है।
मेमोरी दूसरी समस्या का समाधान करती है।
यह एक मार्कडाउन फ़ाइल सिस्टम है जहाँ आप वह सब कुछ सहेजते हैं जो Claude Code को जानना आवश्यक है: आपका स्टैक, टीम के नियम, प्रोजेक्ट्स कैसे संरचित हैं।
Claude Code प्रत्येक सत्र की शुरुआत में उन्हें पढ़ता है और आपके पहली पंक्ति लिखने से पहले उस जानकारी को संदर्भ में इंजेक्ट करता है।
मेमोरी के बिना: आप इसे बताते हैं "उपयोगकर्ता बनाने के लिए एक एंडपॉइंट जोड़ें" और Claude Code आपसे पूछता है: "आप किस फ्रेमवर्क का उपयोग करते हैं? क्या आपके पास डेटाबेस कॉन्फ़िगर है? रूट्स कैसे संरचित हैं?"
मेमोरी के साथ: आप इसे वही बात बताते हैं और यह पहले से जानता है कि आप Express का उपयोग Prisma के साथ करते हैं, रूट्स /src/routes में जाते हैं, और त्रुटियों को एक केंद्रीकृत मिडलवेयर के साथ संभाला जाता है। यह बिना पूछे काम करना शुरू कर देता है।
Claude Code में 2 मेमोरी सिस्टम हैं:
→ CLAUDE.md - मार्कडाउन फ़ाइलें जो आप Claude Code को जानने के लिए आवश्यक सब कुछ के साथ लिखते हैं। वे विभिन्न स्तरों पर रह सकती हैं:
→ ~/.claude/CLAUDE.md - आपके सभी प्रोजेक्ट्स पर लागू होता है। आपकी व्यक्तिगत प्राथमिकताएँ वहाँ जाती हैं: आप इसे कोड कैसे लिखना चाहते हैं, आपके द्वारा हमेशा उपयोग किए जाने वाले नियम। निर्देश विशिष्ट होने चाहिए: "2 स्पेस इंडेंटेशन का उपयोग करें" "कोड को अच्छी तरह से फॉर्मेट करें" से अधिक स्पष्ट है।
→ /your-project/CLAUDE.md - रिपॉजिटरी के लिए विशिष्ट। आर्किटेक्चर, टीम के नियम, और महत्वपूर्ण कमांड वहाँ जाते हैं। जब आप एक नया प्रोजेक्ट शुरू करते हैं, तो /init चलाएँ और Claude Code इसे स्वचालित रूप से जनरेट करता है। इसे 200 लाइनों के नीचे रखें: यदि यह बहुत बढ़ जाता है, तो Claude Code निर्देशों को अनदेखा करना शुरू कर देता है। और यदि आप इसे रिपॉजिटरी में कमिट करते हैं, तो पूरी टीम एक ही संदर्भ साझा करती है।
→ .claude/rules/ - मॉड्यूलर नियम जो फ़ाइल प्रकार के अनुसार सक्रिय होते हैं। तब उपयोगी जब प्रोजेक्ट बढ़ता है और आप सब कुछ एक ही फ़ाइल में नहीं रखना चाहते।
ऑटो मेमोरी - वह मेमोरी जो Claude Code अपने आप बनाता है। जैसे-जैसे आप काम करते हैं, यह अपने आप नोट्स लेता है: पैटर्न जो यह पता लगाता है, सुधार जो आप करते हैं, निर्णय जो आपने एक साथ लिए। यह इसमें सहेजा जाता है
~/.claude/projects/<project>/memory/ और प्रत्येक सत्र की शुरुआत में लोड किया जाता है।
इसे बार-बार जाँचें: हो सकता है कि Claude Code ने आपके ध्यान में आए बिना बुरी आदतें सहेज ली हों।
टिप: आप वह सब कुछ देख और संपादित कर सकते हैं जो Claude Code /memory चलाकर याद रखता है।
Hooks और Skills: नियंत्रण लें
1. Hooks
Claude Code स्वायत्त रूप से काम करता है।
यह कार्य करता है, निर्णय लेता है, आगे बढ़ता है।
लेकिन उस स्वायत्तता का एक पक्ष है जिसका उतना उल्लेख नहीं किया जाता: Claude Code वही करता है जो वह प्रत्येक चरण में सही मानता है।
अगर कुछ गलत होता है, या यह कुछ ऐसा करता है जो आप नहीं चाहते थे, तो हो चुका है।
आप इसे कैसे नियंत्रित करते हैं? Hooks के साथ।
एक Hook एक कमांड है जो चक्र में विशिष्ट बिंदुओं पर स्वचालित रूप से चलता है। इससे पहले कि Claude Code एक टूल का उपयोग करे, इसके बाद, जब सत्र समाप्त होता है।
आप परिभाषित करते हैं कि प्रत्येक क्षण में क्या होता है।
मुख्य बात यह है कि Hooks नियतात्मक हैं।
वे Claude Code के "याद रखने" पर निर्भर नहीं करते कि कुछ करना है। वे हमेशा निष्पादित होते हैं, बिना किसी अपवाद के।
चार मुख्य Hooks हैं:
PreToolUse - इससे पहले चलता है कि Claude Code एक टूल का उपयोग करे। यह एकमात्र Hook है जो किसी कार्य को अवरुद्ध कर सकता है। उदाहरण: किसी भी कमांड को ब्लॉक करें जो .env फ़ाइलों को संशोधित करने का प्रयास करता है।
PostToolUse - Claude Code द्वारा एक टूल का उपयोग करने के बाद चलता है। उदाहरण: जब भी Claude Code एक फ़ाइल संपादित करता है तो स्वचालित रूप से Prettier चलाएँ।
Notification - तब चलता है जब Claude Code को आपके ध्यान की आवश्यकता होती है। उदाहरण: जब Claude Code एक लंबा कार्य समाप्त कर लेता है तो अपने Mac पर एक सूचना प्राप्त करें।
Stop - तब चलता है जब Claude Code उत्तर देना समाप्त करता है। उदाहरण: जब एजेंट समाप्त कर लेता है तो स्वचालित रूप से स्टेजिंग पर पुश करें।
वे .claude/settings.json में कॉन्फ़िगर किए गए हैं:
1{2 "hooks": {3 "PostToolUse": [4 {5 "matcher": "Edit|Write",6 "hooks": [7 {8 "type": "command",9 "command": "npx prettier --write $file_path"10 }11 ]12 }13 ]14 }15}
यह Hook जब भी Claude Code एक फ़ाइल संपादित या बनाता है, स्वचालित रूप से Prettier चलाता है।
बिना आपके पूछे। बिना Claude Code को इसे याद रखना पड़े।
Hook के बिना: Claude Code एक फ़ाइल संपादित करता है, कोड अप्रारूपित रहता है, और आपको अगले कमिट में पता चलता है।
Hook के साथ: Claude Code एक फ़ाइल संपादित करता है, PostToolUse स्वचालित रूप से ट्रिगर होता है, Prettier फ़ाइल को फॉर्मेट करता है, और कोड हमेशा साफ रहता है।
Hooks आपको एजेंट के चक्र में गारंटीकृत व्यवहार जोड़ने की अनुमति देते हैं। सुझाव नहीं, निर्देश नहीं जिन्हें मॉडल अनदेखा कर सकता है। नियम जो हमेशा निष्पादित होते हैं।
2. Skills
एक और समस्या है: स्थिरता।
आप इसे एक ही कार्य के लिए दो बार पूछते हैं और अलग-अलग परिणाम मिलते हैं। हर बार जब आप एक नई बातचीत शुरू करते हैं, Claude Code बिना यह जाने शुरू करता है कि आपने पिछली बार यह कैसे किया था।
आप इसे कैसे हल करते हैं? Skills के साथ।
एक Skill एक मार्कडाउन फ़ाइल है जहाँ आप किसी कार्य के लिए सटीक प्रक्रिया Claude Code को समझाते हैं: क्या समीक्षा करना है, किस क्रम में, किस फॉर्मेट का उपयोग करना है, क्या अनदेखा करना है।
जब भी वह कार्य सामने आता है, Claude Code उन निर्देशों का पालन करता है।
Skill के बिना: आप इसे एक API दस्तावेज़ बनाने के लिए कहते हैं और यह कुछ उत्पन्न करता है, लेकिन हर बार एक अलग फॉर्मेट के साथ। कभी उदाहरणों के साथ, कभी उनके बिना।
Skill के साथ: आप इसे एक API दस्तावेज़ बनाने के लिए कहते हैं और यह आपके द्वारा परिभाषित सटीक प्रक्रिया का पालन करता है। हमेशा समान चरणों, समान फॉर्मेट, समान मानदंडों के साथ। हर बार वही।
एक Skill बनाने के लिए, आप इस संरचना के साथ एक फ़ोल्डर परिभाषित करते हैं:
1my-skill/2├── SKILL.md # मुख्य निर्देश (आवश्यक)3├── template.md # टेम्पलेट जिसे Claude पूरा करता है4├── examples/5│ └── sample.md # अपेक्षित आउटपुट का उदाहरण6└── scripts/7 └── validate.sh # स्क्रिप्ट जिसे Claude निष्पादित कर सकता है
एकमात्र अनिवार्य फ़ाइल SKILL.md है। बाकी वैकल्पिक है और आप इसे कार्य की आवश्यकता के अनुसार जोड़ते हैं।
SKILL.md के 2 भाग हैं:
फ्रंटमैटर - नाम और विवरण के साथ एक YAML ब्लॉक। नाम मैन्युअल रूप से इसे लागू करने का कमांड है। विवरण वह है जो Claude Code यह तय करने के लिए पढ़ता है कि इसे स्वचालित रूप से कब सक्रिय करना है।
बॉडी - मार्कडाउन में निर्देश। वर्कफ़्लो, मानदंड, आउटपुट फॉर्मेट।
1---2name: api-docs3description: API एंडपॉइंट का दस्तावेज़ीकरण करता है। इसका उपयोग तब करें जब4 उपयोगकर्ता किसी API का दस्तावेज़ीकरण करने या "swagger" या "endpoints" का उल्लेख करता है5---67## प्रक्रिया81. सभी एंडपॉइंट की पहचान करें92. प्रत्येक के लिए: विधि, पथ, पैरामीटर, अपेक्षित प्रतिक्रिया103. एक अनुरोध और प्रतिक्रिया उदाहरण शामिल करें114. एक सारांश तालिका के साथ समाप्त करें
एक बार बनने के बाद, आप इसे दो तरीकों से लागू कर सकते हैं।
सीधे चैट में /api-docs लिखकर, या बस Claude Code को प्राकृतिक भाषा में पूछकर।
यदि विवरण आपके द्वारा पूछे जा रहे कार्य से मेल खाता है, तो यह अपने आप सक्रिय हो जाता है।
आप उन्हें किसी भी ऐसे कार्य के लिए बना सकते हैं जिसे आप एक स्पष्ट प्रक्रिया के साथ दोहराते हैं: API दस्तावेज़ीकरण, चेंजलॉग, मीटिंग सारांश, कोड माइग्रेशन।
SubAgents: जब समस्या बढ़ जाए तो प्रतिनिधि बनाएँ
हमने पहले ही देखा कि संदर्भ की सीमित क्षमता होती है।
सत्र जितना लंबा होता है, यह उतना ही भरता जाता है। और जब यह भर जाता है, तो Claude Code पहले क्या हुआ था, इसके बारे में जानकारी खोने लगता है।
कल्पना करें कि आप इसे सुरक्षा मुद्दों के लिए अपने पूरे प्रोजेक्ट की समीक्षा करने के लिए कहते हैं। यह दर्जनों फ़ाइलें पढ़ता है, कोड का विश्लेषण करता है, एक विस्तृत रिपोर्ट उत्पन्न करता है।
यह सब जल्दी से संदर्भ भर देता है।
और जब यह ऐसा कर रहा होता है, आपकी मुख्य बातचीत अवरुद्ध हो जाती है।
आप इसे कैसे हल करते हैं? SubAgents के साथ।
एक SubAgent Claude Code का एक अलग इंस्टेंस है जो अपने स्वयं के संदर्भ के साथ चलता है।
मुख्य एजेंट इसे एक कार्य सौंपता है, SubAgent इसे स्वतंत्र रूप से निष्पादित करता है, और जब यह समाप्त होता है, तो यह परिणामों के साथ एक सारांश भेजता है।
मुख्य एजेंट का संदर्भ पूरी प्रक्रिया से नहीं भरता, केवल निष्कर्ष से।
1मुख्य एजेंट2 ↓3"प्रोजेक्ट की सुरक्षा मुद्दों के लिए समीक्षा करें"4 ↓5┌─────────────────────────────┐6│ SubAgent: security-reviewer │7│ │8│ प्रोजेक्ट फ़ाइलें पढ़ता है │9│ कोड का विश्लेषण करता है │10│ कमजोरियों का पता लगाता है │11│ रिपोर्ट उत्पन्न करता है │12└─────────────────────────────┘13 ↓14मुख्य एजेंट को सारांश लौटाता है15 ↓16मुख्य एजेंट लूप जारी रखता है
और केवल इतना ही नहीं।
SubAgents समानांतर में चल सकते हैं।
तीन भागों के कोड का क्रमिक रूप से विश्लेषण करने के बजाय, Claude Code तीनों को एक ही समय में सौंप सकता है।
जिसमें मिनट लगते थे, वह सेकंड में हो सकता है।
1मुख्य एजेंट2 ↓3काम को स्वतंत्र कार्यों में विभाजित करता है4 ↓5┌──────────────┐ ┌──────────────┐ ┌──────────────┐6│ SubAgent 1 │ │ SubAgent 2 │ │ SubAgent 3 │7│ │ │ │ │ │8│ ऑथ की समीक्षा करता है │ DB की समीक्षा करता है │ बाहरी API की │9│ │ │ │ │ समीक्षा करता है │10└──────────────┘ └──────────────┘ └──────────────┘11 ↓ ↓ ↓12 मुख्य एजेंट तीनों सारांश प्राप्त करता है13 ↓14 लूप जारी रखता है
Claude Code में 3 नेटिव SubAgents हैं जिनका यह स्वचालित रूप से उपयोग करता है:
→ Explore - एक तेज़, केवल-पढ़ने वाला एजेंट जो प्रोजेक्ट की खोज और विश्लेषण में विशेषज्ञ है। परिणाम SubAgent के संदर्भ में रहते हैं, आपके नहीं।
→ Plan - प्लान मोड में सक्रिय होता है। आपको एक योजना प्रस्तुत करने से पहले, Claude Code प्रोजेक्ट की जाँच इस एजेंट को सौंपता है।
→ General-purpose - जटिल कार्यों के लिए जिनमें खोज और संशोधन दोनों की आवश्यकता होती है।
आप अपना खुद का भी बना सकते हैं।
SubAgents YAML फ्रंटमैटर के साथ मार्कडाउन फ़ाइलों में परिभाषित किए जाते हैं और .claude/agents/ में सहेजे जाते हैं।
1---2name: security-reviewer3description: सुरक्षा कमजोरियों के लिए कोड की समीक्षा करता है।4 इसका उपयोग तब करें जब उपयोगकर्ता सुरक्षा समीक्षा के लिए कहता है।5tools: Read, Grep, Glob6---78आप एक सुरक्षा विशेषज्ञ हैं। कोड का विश्लेषण करें:9- SQL इंजेक्शन10- संवेदनशील डेटा एक्सपोज़र11- प्रमाणीकरण कमजोरियाँ1213गंभीरता के अनुसार क्रमबद्ध निष्कर्षों के सारांश के साथ समाप्त करें।
ध्यान दें कि फ्रंटमैटर में हम टूल्स को Read, Grep और Glob तक सीमित करते हैं।
यह एजेंट विश्लेषण कर सकता है लेकिन कभी कुछ संशोधित नहीं करता।
जब आपको इस बात पर सटीक नियंत्रण की आवश्यकता होती है कि प्रत्येक एजेंट क्या कर सकता है, तो वह टूल प्रतिबंध महत्वपूर्ण है।
एक बार बनने के बाद, Claude Code स्वचालित रूप से विवरण द्वारा इसका पता लगाता है और जब कार्य फिट बैठता है तो इसे लागू करता है। या आप इसे स्पष्ट रूप से कॉल कर सकते हैं: "इस PR की समीक्षा करने के लिए security-reviewer एजेंट का उपयोग करें।"
SubAgents का उपयोग कब करें और कब न करें?
यह समझ में आता है जब कार्य लंबा हो और बहुत अधिक आउटपुट उत्पन्न करेगा, जब आप काम को स्वतंत्र भागों में विभाजित कर सकते हैं जो समानांतर में चलते हैं, या जब आपको सीमित टूल वाले विशेषज्ञ एजेंट की आवश्यकता होती है।
यह छोटे कार्यों के लिए इसके लायक नहीं है जो संदर्भ नहीं भरते। SubAgents का समन्वय करने से जटिलता बढ़ती है जो समझ में नहीं आती अगर मुख्य एजेंट दो मिनट में कार्य हल कर सकता है।
MCP: एजेंट को बाहरी दुनिया से जोड़ना
टूल्स Claude Code को आपकी मशीन पर कार्य करने की क्षमता देते हैं।
लेकिन एक सीमा है: जो कुछ भी होता है, वह वहीं होता है।
यह GitHub पर PR नहीं खोल सकता, प्रोडक्शन डेटाबेस क्वेरी नहीं कर सकता, या Jira में टिकट नहीं बना सकता। ऐसा करने के लिए, आपको पहले एजेंट को छोड़ना होता था और इसे स्वयं हाथ से करना होता था।
आप इसे कैसे हल करते हैं? MCP के साथ।
MCP (Model Context Protocol) एक ओपन प्रोटोकॉल है जो परिभाषित करता है कि Claude Code बाहरी सेवाओं से कैसे जुड़ता है।
यह क्लाइंट-सर्वर आर्किटेक्चर के साथ काम करता है: Claude Code क्लाइंट है, और प्रत्येक बाहरी सेवा का अपना MCP सर्वर है जो उजागर करता है कि वह क्या कर सकता है।
जब आप एक MCP सर्वर कनेक्ट करते हैं, Claude Code अपने नाम और विवरण के साथ उपलब्ध टूल्स की एक सूची प्राप्त करता है।
वहाँ से, यह उनका उपयोग बिल्कुल नेटिव टूल्स की तरह करता है। एकमात्र अंतर यह है कि कार्रवाई बाहरी सेवा में होती है, आपकी मशीन पर नहीं।
1Claude Code2 ↓3GitHub MCP सर्वर से एक टूल का उपयोग करने का निर्णय लेता है4 ↓5┌─────────────────────────────┐6│ GitHub MCP Server │7│ │8│ PR खोलता है │9│ समीक्षक नियुक्त करता है │10│ पुष्टि लौटाता है │11└─────────────────────────────┘12 ↓13Claude Code परिणाम प्राप्त करता है और जारी रखता है
MCP के बिना: आप इसे बताते हैं "मैंने बदलाव पूरे कर लिए, PR खोलें" और Claude Code नहीं कर सकता। आपको GitHub पर जाना होगा, फॉर्म भरना होगा, समीक्षक नियुक्त करने होंगे, और इसे स्वयं मर्ज करना होगा।
MCP के साथ: आप इसे वही बात बताते हैं और Claude Code PR खोलता है, विवरण लिखता है, समीक्षक नियुक्त करता है, और जब यह तैयार होता है तो आपको सूचित करता है। यह सब आपके एजेंट को छोड़े बिना।
कुछ MCP सर्वर जिन्हें आप आज कनेक्ट कर सकते हैं:
→ GitHub - PRs, समीक्षाएँ, issues
→ Postgres / Supabase - डेटाबेस क्वेरी और संशोधित करें
→ Slack - संदेश और चैनल
→ Jira - टिकट और प्रोजेक्ट
आपके स्थानीय वातावरण के लिए नेटिव टूल्स। बाहरी दुनिया के लिए MCP।
यह सब एक साथ कैसे फिट बैठता है
Claude Code एक एजेंट है: एक सिस्टम जो एक लक्ष्य लेता है और एक स्वायत्त लूप में तब तक संचालित होता है जब तक वह इसे पूरा नहीं कर लेता।
इस लेख में आपने जो भी टुकड़ा देखा, वह उस लूप को और अधिक शक्तिशाली बनाने के लिए मौजूद है। लेकिन इसे समझने का सबसे अच्छा तरीका है कि उन्हें एक साथ बातचीत करते हुए देखा जाए।
केस 1: एक PR की समीक्षा करें और मर्ज करें
आप Claude Code से कहते हैं: "PR #42 की समीक्षा करें और अगर सब कुछ ठीक है, तो इसे मर्ज कर दें।"
→ यह संशोधित फ़ाइलों को पढ़ने और बदलावों को समझने के लिए GitHub MCP का उपयोग करता है
→ यह मुख्य संदर्भ को न भरने के लिए सुरक्षा विश्लेषण को एक विशेषज्ञ SubAgent को सौंपता है
→ एक Hook स्थानीय रूप से टेस्ट चलाता है और सत्यापित करता है कि सब कुछ पास होता है
→ यदि टेस्ट पास होते हैं, तो यह आपके इंटरफ़ेस को छुए बिना मर्ज करने के लिए GitHub MCP का उपयोग करता है
आपने एक पंक्ति लिखी। Claude Code ने चार सिस्टमों का समन्वय किया।
केस 2: एक API का दस्तावेज़ीकरण करें और टीम को सूचित करें
आप Claude Code से कहते हैं: "नए एंडपॉइंट का दस्तावेज़ीकरण करें और टीम को बताएं।"
→ यह एक दस्तावेज़ीकरण Skill सक्रिय करता है जो सटीक फॉर्मेट को परिभाषित करता है: क्या शामिल करना है, इसे कैसे संरचित करना है, कौन से उदाहरण जोड़ने हैं
→ यह एंडपॉइंट निकालने के लिए कोड पढ़ने के लिए Tools का उपयोग करता है
→ एक Hook सहेजने से पहले आउटपुट को फॉर्मेट करता है
→ यह टीम चैनल पर सारांश भेजने के लिए Slack MCP का उपयोग करता है
हर बार जब आप इसे करते हैं, परिणाम वही होगा। बिना भिन्नताओं के, बिना आपको कुछ समझाने के।
सब कुछ लूप के इर्द-गिर्द घूमता है।
मेमोरी प्रत्येक सत्र को सूचित शुरू करने के लिए। टूल्स कार्य करने के लिए। Hooks नियंत्रित करने के लिए। Skills मानकीकृत करने के लिए। SubAgents स्केल करने के लिए। MCP बाहरी दुनिया से जुड़ने के लिए।
जब आप यह समझ लेते हैं, तो आप Claude Code को समझ जाते हैं।
और सिर्फ Claude Code ही नहीं: Cursor, Copilot, और कोई भी एजेंट जिसका आप अब से उपयोग करेंगे, वही नींव पर काम करता है।
नाम बदलते हैं, इंटरफ़ेस बदलता है, लेकिन लूप वही है।
AI तेजी से आगे बढ़ रहा है।
हर हफ्ते कुछ नया होता है। लेकिन नींव इतनी बार नहीं बदलती। उन्हें स्पष्ट रखना ही आपको तेजी से अनुकूलित करने और आगे आने वाली चीज़ों से अधिक लाभ उठाने में सक्षम बनाएगा।
Claude Code का उपयोग केवल प्रॉम्प्टिंग के लिए न करें। ध्यान दें कि नीचे क्या हो रहा है। वहीं अवसर हैं।
आज से शुरू करने के लिए कुछ शुरुआती बिंदु:
→ अपनी ऑटो मेमोरी की समीक्षा करें और Claude Code द्वारा सहेजी गई चीज़ों में सुधार करें
→ अपने प्रोजेक्ट के लिए एक CLAUDE.md बनाएँ यदि आपके पास नहीं है
→ GitHub MCP कनेक्ट करें
→ संदर्भ भरने वाले कार्यों के लिए एक SubAgent बनाएँ
→ प्रत्येक बदलाव के बाद टेस्ट चलाने वाला एक Hook कॉन्फ़िगर करें
बस इतना ही, कल मिलते हैं।
Marcus
