Claude Code कैसे काम करता है
📚 श्रृंखला नेविगेशन: पिछला लेख 02 · इंस्टालेशन और उपयोग आपको Claude Code इंस्टॉल करने और चलाने के बारे में बताता है। यह लेख आपको पर्दे के पीछे ले जाता है, यह दिखाने के लिए कि यह वास्तव में कैसे काम करता है—क्यों यह सिर्फ चैट करने के बजाय खुद कोड पढ़ सकता है, फ़ाइलों को बदल सकता है, और कमांड चला सकता है।
पहली बार Claude Code का उपयोग करते समय, आप अक्सर इस तरह की बातचीत का सामना करेंगे—
आप: "यह टेस्ट क्यों फेल हो गया?" Claude: "मैं पहले टेस्ट सूट रन करके देखता हूँ।" (कमांड चलाना शुरू करता है) Claude: "त्रुटि कहती है कि
validateEmailने undefined लौटाया, मैं इस फ़ंक्शन को देखता हूँ।" (फ़ाइल पढ़ता है) Claude: "मिल गया, यहाँ एक return छूट गया है। मैं इसे ठीक कर दूँगा, और फिर पुष्टि करने के लिए टेस्ट फिर से चलाऊँगा।" (ठीक करने के बाद, एक बार फिर चलाता है) Claude: "टेस्ट पास हो गया।"
इसे देखकर थोड़ा हैरान होना आसान है: सिर्फ एक वाक्य पूछने पर, यह खुद कमांड कैसे चलाता है, खुद फ़ाइलें पढ़ता है, खुद बदलाव करता है, और यहां तक कि खुद को वेरिफाई भी करता है?
सरल शब्दों में, यही Claude Code और एक सामान्य AI चैटबॉक्स के बीच का सबसे बड़ा अंतर है। एक चैटबॉक्स केवल "आपको टेक्स्ट का एक पैराग्राफ वापस करेगा", जबकि Claude Code चीजें खुद करेगा। इसके पीछे एक निश्चित कार्य तंत्र है, जिसे आज हम विस्तार से समझेंगे।
इस लेख को पढ़ने के बाद, आपको मिलेगा:
- एक तस्वीर में Claude Code के "एजेंट लूप" को समझना—यह जो भी करता है, उसमें तीन क्रियाओं को दोहराता है
- यह समझना कि इसके पास मौजूद 5 प्रकार के "उपकरण" क्या कर सकते हैं, और यह कैसे तय करता है कि किसका उपयोग करना है
- यह जानना कि यह आपके कंप्यूटर पर क्या देख सकता है और क्या नहीं देख सकता (सुरक्षा से संबंधित)
- एक छोटा सा प्रयोग जिसे आप खुद कर सकते हैं, अपनी आँखों से इसे पूरे लूप से गुजरते हुए देखने के लिए
01 एजेंट लूप: सोचना → करना → देखना
पहले निष्कर्ष: Claude Code कोई भी काम करता है, तो वह तीन क्रियाओं को दोहराता है—संदर्भ एकत्र करना, कार्रवाई करना, परिणाम सत्यापित करना। आधिकारिक तौर पर इस तंत्र को "एजेंट लूप (agentic loop)" कहा जाता है।
अधिक सरल शब्दों में कहें तो: सोचना → करना → देखना।
- सोचना (संदर्भ एकत्र करना): पहले स्थिति को समझना—संबंधित फ़ाइलें पढ़ना, त्रुटियां देखना, git स्थिति की जांच करना
- करना (कार्रवाई करना): काम करना—कोड बदलना, कमांड चलाना, नई फ़ाइलें बनाना
- देखना (परिणाम सत्यापित करना): जाँचना कि अभी जो किया वह सही है या नहीं—टेस्ट चलाना, आउटपुट देखना, अगर गलत है চিহ্নিত तो एक और राउंड करना
सादृश्य: एक विश्वसनीय कार मैकेनिक। आप कार को दुकान में ले जाते हैं और कहते हैं कि "स्टीयरिंग व्हील हिल रहा है", मैकेनिक तुरंत इसे खोलना शुरू नहीं करेगा। वह पहले चारों ओर देखेगा, दो कदम चलाकर देखेगा (सोचना), फिर पाना उठाएगा (करना), और ठीक करने के बाद यह पुष्टि करने के लिए ड्राइव करेगा कि यह अब नहीं हिल रहा है (देखना)। अगर यह अभी भी हिलता है, तो वह पहले चरण पर वापस जाएगा और फिर से जांच करेगा। Claude Code बिल्कुल ऐसा ही मैकेनिक है, बस यह आपके कोड को ठीक करता है।
शुरुआत में दी गई बातचीत पर वापस जाएं, इसकी तुलना करें और आप समझ जाएंगे:
| Claude क्या कहता है | लूप में कौन सा चरण |
|---|---|
| "मैं पहले टेस्ट सूट रन करके देखता हूँ" | सोचना (संदर्भ एकत्र करना) |
| "त्रुटि कहती है कि undefined, मैं इस फ़ंक्शन को देखता हूँ" | सोचना (संदर्भ एकत्र करना जारी) |
| "यहाँ एक return छूट गया है, मैं इसे ठीक कर दूँगा" | करना (कार्रवाई करना) |
| "और फिर पुष्टि करने के लिए टेस्ट फिर से चलाऊँगा" | देखना (परिणाम सत्यापित करना) |
| "टेस्ट पास हो गया" | लूप समाप्त |
यह इन तीन चरणों को एक श्रृंखला में जोड़ता है, एक कदम का परिणाम यह तय करता है कि आगे क्या करना है। एक बग को ठीक करने में कई राउंड लग सकते हैं, यह पूछने पर कि "इस कोड का क्या मतलब है", केवल "सोचना" चरण पर्याप्त हो सकता है। लूप कितनी बार चलता है, यह कार्य की जटिलता से निर्धारित होता है, न कि पहले से तय होता है।
ऊपर दी गई तस्वीर वह चक्र है जिसे Claude Code हर बार काम करते समय घुमाता है: "सोचने" से "करने" तक फिर "देखने" तक, यदि संतुष्ट नहीं है तो "देखने" से वापस "सोचने" पर जाता है और एक और राउंड करता है—आप इसे रोकने के लिए किसी भी समय Esc दबा सकते हैं।
यहाँ एक मुख्य बात है जिसे कई लोग नहीं समझते हैं: आप भी इस लूप का हिस्सा हैं। यदि यह भटक जाता है, तो आप इसे ठीक करने के लिए किसी भी समय हस्तक्षेप कर सकते हैं—अगले भाग में इस पर विस्तार से चर्चा की जाएगी।
इस लूप को चलाने वाली दो चीजें हैं: मॉडल "सोचने" के लिए जिम्मेदार है, और उपकरण "करने" और "देखने" के लिए जिम्मेदार हैं।
मॉडल Claude का मस्तिष्क है—Sonnet रोजमर्रा की प्रोग्रामिंग के लिए पर्याप्त है, Opus का तर्क मजबूत है, जो जटिल आर्किटेक्चर के लिए उपयुक्त है। आप बातचीत में /model दर्ज करके किसी भी समय स्विच कर सकते हैं, या शुरू करते समय claude --model sonnet का उपयोग कर सकते हैं।
💡 एक वाक्य में सारांश: Claude Code "आपको एक पैराग्राफ वापस करना" नहीं है, बल्कि काम पूरा होने तक "सोचना→करना→देखना" चक्र घुमाना है, यही इसके और चैटबॉक्स के बीच का मूल अंतर है।
02 आप भी लूप में हैं: किसी भी समय बाधित करें
पिछले भाग के अंत में कहा गया था: आप भी इस लूप का हिस्सा हैं। आइए इस पर विस्तार से बात करते हैं। सामान्य AI चैट "आप एक वाक्य पूछते हैं, यह एक पैराग्राफ का उत्तर देता है, दौर समाप्त" है। Claude Code अलग है—जब यह लूप में खुद चल रहा होता है, आपको इंतजार करने की आवश्यकता नहीं है, आप किसी भी समय हस्तक्षेप कर सकते हैं।
उदाहरण के लिए, इसे किसी मॉड्यूल को रिफैक्टर करने के लिए कहें, देखें कि यह भटक गया है और बहुत सी फाइलों को बदलने वाला है, सीधे Esc दबाएं, यह तुरंत रुक जाएगा, और चल रही कमांड भी रद्द हो जाएगी। फिर एक वाक्य जोड़ें "उस फ़ाइल को मत छुओ, केवल इस फ़ंक्शन को बदलो", और यह नए निर्देशों के साथ जारी रहेगा।
बाधित करने के दो तरीके, अंतर को स्पष्ट रूप से समझें:
| कार्य | प्रभाव | कब उपयोग करें |
|---|---|---|
Esc दबाएं | तुरंत रुकें, चल रही टूल कॉल रद्द हो जाती है, आपके अगले निर्देश की प्रतीक्षा करता है | यह भटक गया है, गलत काम कर रहा है, इसे जल्दी से रोकें |
टाइपिंग + Enter | वर्तमान ऑपरेशन को बाधित न करें, एक पूरक वाक्य भेजें, यह अपना काम पूरा करने के बाद इसे पढ़ेगा | बस एक संदर्भ जोड़ना चाहते हैं, एक अनुस्मारक देना चाहते हैं, रोकने की कोई जल्दी नहीं है |
आपको एक "संपूर्ण प्रॉम्प्ट" सोचने की ज़रूरत नहीं है। बस एक सामान्य विचार दें, देखें कि यह क्या करता है, और यदि यह गलत है तो इसे ठीक करें—यह एक बातचीत है, न कि एक बार की कमांड।
यह आधिकारिक दस्तावेज़ीकरण का मूल कथन है और विशेष रूप से याद रखने योग्य है। शुरुआत करते समय, हम अक्सर "एक वाक्य में सभी आवश्यकताओं को बताना" चाहते हैं और इसके लिए बहुत समय लगाते हैं। वास्तव में, इसकी कोई आवश्यकता नहीं है: एक बड़ी दिशा दें, अगर यह गलत करता है तो इसे रोकें, पुनरावृत्ति (iteration) एक बार में सब कुछ सही करने की कोशिश से बहुत तेज है।
💡 एक वाक्य में सारांश: यह स्वतंत्र रूप से काम करता है, लेकिन हमेशा आपके आदेशों को सुनता है—
Escआपातकालीन स्टॉप, टाइपिंग सप्लीमेंट, स्टीयरिंग व्हील हमेशा आपके हाथों में होता है।
03 उपकरण: यह वास्तव में कार्रवाई क्यों कर सकता है
पिछले भाग में कहा गया था कि मॉडल "सोचने" के लिए जिम्मेदार है। तो "करना" और "देखना" किस पर निर्भर करता है? उपकरण।
यह Claude Code के बारे में याद रखने वाली सबसे महत्वपूर्ण बात है: उपकरणों के बिना, Claude केवल आपको पाठ वापस कर सकता है; उपकरणों के साथ, यह वास्तव में आपके कोड को पढ़ सकता है, आपकी फ़ाइलों को बदल सकता है, और आपके कमांड चला सकता है।
सादृश्य: एक स्मार्ट रिस्टबैंड पहने हुए एक सहायक। जो सहायक केवल बात कर सकता है, वह केवल विचार दे सकता है; उसे ऐसे उपकरण दें जो दरवाजे खोल सकें, टाइप कर सकें, जानकारी खोज सकें, तभी वह वास्तव में आपके लिए काम पूरा कर सकता है। उपकरण Claude Code के "हाथ" हैं।
आधिकारिक तौर पर अंतर्निहित उपकरणों को 5 प्रमुख श्रेणियों में विभाजित किया गया है। मैं उन्हें सरल शब्दों में सूचीबद्ध करूँगा—
| उपकरण श्रेणी | यह क्या कर सकता है | आपके सामान्य कार्यों के अनुरूप क्या है |
|---|---|---|
| फ़ाइल ऑपरेशन | फ़ाइलें पढ़ना, कोड बदलना, नई फ़ाइलें बनाना, नाम बदलना, पुनर्गठित करना | आप संपादक में खोलते हैं, टाइप करते हैं, सहेजते हैं |
| खोज | फ़ाइल नाम से फ़ाइलें खोजना, सामग्री में खोजने के लिए रेगेक्स (regex) का उपयोग करना, पूरे कोडबेस को खोजना | आप Ctrl+F या grep दबाते हैं |
| निष्पादन | shell कमांड चलाना, सर्वर शुरू करना, टेस्ट चलाना, git का उपयोग करना | आप टर्मिनल में कमांड टाइप करके एंटर दबाते हैं |
| नेटवर्क | वेब पेज खोजना, दस्तावेज़ प्राप्त करना, त्रुटि संदेश खोजना | आप त्रुटि के एक हिस्से को खोजने के लिए ब्राउज़र खोलते हैं |
| कोड इंटेलिजेंस | प्रकार त्रुटियां और चेतावनियां देखना, परिभाषा पर जाना, संदर्भ खोजना | IDE का "गो टू डेफिनिशन" "फाइंड रेफरेंस" |
⚠️ ध्यान दें: 5वीं श्रेणी "कोड इंटेलिजेंस" के लिए एक अतिरिक्त कोड इंटेलिजेंस प्लगइन स्थापित करने की आवश्यकता होती है, पहले 4 बॉक्स से बाहर काम करते हैं। आधिकारिक दस्तावेजों को संदर्भ मानें।
तो यह कैसे तय करता है कि किस उपकरण का उपयोग करना है? यह आपके द्वारा निर्दिष्ट नहीं किया गया है, बल्कि मॉडल आपकी बातों और वर्तमान प्रगति के आधार पर खुद चुनता है।
एक आधिकारिक उदाहरण लें, आप कहते हैं "विफल टेस्ट को ठीक करें", यह आंतरिक रूप से कुछ इस तरह जाएगा:
- यह देखने के लिए टेस्ट सूट चलाएं कि कौन सा विफल हुआ —— निष्पादन का उपयोग किया
- त्रुटि आउटपुट पढ़ें —— निष्पादन
- संबंधित स्रोत फ़ाइलें खोजें —— खोज
- तर्क को समझने के लिए इन फ़ाइलों को पढ़ें —— फ़ाइल ऑपरेशन
- बग को ठीक करने के लिए फ़ाइलें बदलें —— फ़ाइल ऑपरेशन
- सत्यापित करने के लिए एक बार फिर से टेस्ट चलाएं —— निष्पादन
क्या आपने देखा? ये 6 चरण टूल स्तर पर "सोचना→करना→देखना" लूप का विस्तार हैं। हर बार जब यह एक उपकरण का उपयोग करता है, तो यह थोड़ी नई जानकारी वापस लाता है, मॉडल को फीड करता है ताकि वह अगला कदम तय कर सके—लूप इसी तरह चलता है।
एक बहुत ही सामान्य परिदृश्य: इसे बिना दस्तावेज़ वाले पुराने प्रोजेक्ट की "निर्देशिका संरचना को सुलझाने" के लिए कहें। आपको इसे कोई भी फ़ाइल फीड करने की आवश्यकता नहीं है, यह खुद ls करेगा, कीवर्ड खुद grep करेगा, सात या आठ फाइलें पढ़ेगा, और अंत में एक संरचना आरेख (structure diagram) बनाएगा। पूरी प्रक्रिया के दौरान किसी भी फाइल को निर्दिष्ट नहीं किया गया—यही वह है जिसे आधिकारिक तौर पर "सौंपना (delegate) कहा जाता है, निर्देश (instruct) नहीं": दिशा दें, यह विवरणों का खुद पता लगाएगा।
जहाँ तक Skill, MCP, Hook, Subagent की बात है—वे इन 5 प्रकार के अंतर्निहित उपकरणों के ऊपर विस्तार परतें (extension layers) हैं, जो Claude को अधिक जानने और बाहरी सेवाओं से अधिक जुड़ने की अनुमति देते हैं। इस श्रृंखला में आगे हम उन्हें एक-एक करके समझाएंगे, अभी के लिए बस इतना जानना काफी है कि ऐसी कोई चीज़ है।
💡 एक वाक्य में सारांश: उपकरण Claude Code के "हाथ" हैं, 5 श्रेणियां प्रत्येक अपने क्षेत्र का प्रबंधन करती हैं; किसका उपयोग करना है, कितनी बार उपयोग करना है, यह खुद तय करता है, आप केवल लक्ष्य बताएं।
04 यह आपके कंप्यूटर पर क्या देख सकता है
यह अनुभाग सुरक्षा से संबंधित है, इसलिए इसे स्पष्ट रूप से समझाना होगा। पहली बार इसका इस्तेमाल करने वाले कई लोगों को संदेह होगा: क्या इसने मेरी पूरी हार्ड ड्राइव को स्कैन करके उसे भेज दिया है? नहीं।
पहले यह वाक्य याद रखें: Claude Code की "दृष्टि" (vision) मूल रूप से उस निर्देशिका (directory) में टर्मिनल के माध्यम से आप जिन चीज़ों तक पहुँच सकते हैं, उनके बराबर है। आप जिस फ़ोल्डर में claude टाइप करते हैं, इसकी गतिविधियों का दायरा उसी के इर्द-गिर्द केंद्रित होता है।
आधिकारिक दस्तावेज़ीकरण के अनुसार, जब आप किसी निर्देशिका में claude चलाते हैं, तो यह इन तक पहुँच सकता है:
- आपका प्रोजेक्ट: वर्तमान निर्देशिका और उपनिर्देशिकाओं (subdirectories) में फ़ाइलें (अन्य स्थानों में फ़ाइलों को छूने के लिए आपको अनुमति देनी होगी)
- आपका टर्मिनल: कोई भी कमांड जो आप चला सकते हैं—बिल्ड टूल्स, git, पैकेज मैनेजर, स्क्रिप्ट्स। जो कुछ भी कमांड लाइन कर सकती है, यह कर सकता है
- आपकी git स्थिति: वर्तमान ब्रांच, बिना कमिट किए गए बदलाव, हाल का कमिट इतिहास
- आपका
CLAUDE.md: आपकी प्रोजेक्ट-विशिष्ट निर्देश पुस्तिका (instruction manual), जिसे यह हर सत्र में पढ़ेगा (इस फ़ाइल के बारे में बाद में विस्तार से चर्चा की जाएगी) - आपके द्वारा कॉन्फ़िगर किए गए एक्सटेंशन: MCP, Skill, Subagent आदि
चूंकि यह पूरा प्रोजेक्ट देख सकता है, न कि केवल वह फ़ाइल जो आपने वर्तमान में खोली हुई है, इसलिए यह कई फ़ाइलों में समन्वय (coordinate) कर सकता है—आप कहते हैं "लॉगिन बग को ठीक करें", यह कई संबंधित फ़ाइलों को खोज सकता है, उन्हें एक साथ बदल सकता है, और फिर सत्यापित करने के लिए टेस्ट चला सकता है। यह इनलाइन पूर्णता (inline completion) प्लगइन से बिल्कुल अलग है जो केवल वर्तमान फ़ाइल को देखता है।
तो सुरक्षा की गारंटी कैसे दी जाती है? दो गेट—
पहला गेट: चेकपॉइंट (checkpoint), जो गेम सेव के बराबर है। किसी भी फ़ाइल को बदलने से पहले, यह वर्तमान सामग्री का एक स्नैपशॉट लेगा। यदि यह कुछ खराब कर देता है, तो इनपुट बॉक्स खाली होने पर दो बार Esc दबाएं (या /rewind दर्ज करें), एक "रिवाइंड मेनू" पॉप अप होगा, "रिस्टोर कोड" चुनें और फ़ाइल बदलने से पहले की स्थिति में वापस आ जाएगी; या आप सीधे कह सकते हैं "अभी किए गए बदलावों को पूर्ववत करें (undo)"।
चेकपॉइंट केवल उन फ़ाइलों को प्रबंधित करता है जिन्हें Claude संपादन उपकरण का उपयोग करके बदलता है—bash कमांड द्वारा बदले गए, और बाहरी साइड इफेक्ट्स शामिल नहीं हैं। डेटाबेस, API, ऑनलाइन परिनियोजन (deployment) जैसे ऑपरेशन जिन्हें "वापस नहीं लिया जा सकता", उन्हें सहेजा नहीं जा सकता—इसलिए Claude ऐसे कमांड चलाने से पहले आपसे पूछेगा जिनका बाहरी प्रभाव होता है।
यहाँ एक आम समस्या है: कभी-कभी यह पांच या छह फ़ाइलों को बदल देता है, और उन्हें देखने के बाद आपको लगता है कि दिशा पूरी तरह से गलत है। पहले आपको मैन्युअल रूप से एक-एक करके git checkout करके रोलबैक करना पड़ता था, अब आप दो बार Esc दबाते हैं, और पॉप-अप मेनू में "रिस्टोर कोड" चुनते हैं—पांच फाइलें एक साथ बदलने से पहले की स्थिति में वापस आ जाती हैं, साफ-सुथरा। इस सुविधा के साथ, इसे कोड बदलने देने में कम डर लगता है।
दूसरा गेट: अनुमति मोड, जो एक इंटर्न (intern) द्वारा काम शुरू करने से पहले आपसे पूछने के बराबर है। चक्र बदलने के लिए Shift+Tab दबाएं:
| अनुमति मोड | Claude का व्यवहार |
|---|---|
| डिफ़ॉल्ट | फ़ाइलें बदलने या कमांड चलाने से पहले आपसे पूछता है |
| स्वचालित रूप से संपादन स्वीकार करें (Auto-accept edits) | फ़ाइलें और सामान्य फ़ाइल कमांड (जैसे mkdir, mv) बदलते समय नहीं पूछता है, अन्य कमांड के लिए पूछता है |
| योजना मोड (Plan Mode) | फ़ाइलें पढ़ सकता है और अन्वेषणात्मक (exploratory) कमांड चला सकता है, लेकिन स्रोत कोड (source code) को संपादित नहीं कर सकता; पहले आपको एक योजना देगा, और जब आप इसे अनुमोदित (approve) करेंगे तभी कार्रवाई करेगा |
| स्वचालित मोड (Auto Mode) | सभी ऑपरेशनों का मूल्यांकन करने के लिए पृष्ठभूमि सुरक्षा जांच का उपयोग करता है (प्रायोगिक, वर्तमान में एक शोध पूर्वावलोकन (research preview) है, बदल सकता है) |
सबसे अच्छी आदत है Plan Mode का उपयोग करना: जटिल कार्यों के लिए, पहले दो बार Shift+Tab दबाकर इसमें प्रवेश करें, इसे "केवल विश्लेषण करने, योजना बनाने, कार्रवाई न करने" दें, योजना की समीक्षा करें, इसे बदलें, और फिर पुष्टि करने के बाद इसे निष्पादित करने दें। यह कई बार "गलत दिशा में आधा काम करने" की पुनरावृत्ति से बचा सकता है—काम करते हुए बदलने की तुलना में पहले ब्लूप्रिंट देखना बहुत आसान है।
हर बार पूछने से परेशान हैं? आप प्रोजेक्ट की .claude/settings.json में विश्वसनीय कमांड (जैसे npm test, git status) को श्वेतसूची (whitelist) में जोड़ सकते हैं, ताकि यह भविष्य में न पूछे। कॉन्फ़िगरेशन विवरण के बारे में बाद में एक विशेष लेख में बात की जाएगी।
💡 एक वाक्य में सारांश: इसकी दृष्टि ≈ उस निर्देशिका में आपकी टर्मिनल अनुमतियां; चेकपॉइंट "खराब बदलावों को वापस लेने" का प्रबंधन करता है, अनुमति मोड यह प्रबंधित करता है कि "कार्रवाई करने से पहले पूछना है या नहीं"—इन दो गेटों के साथ, आप मन की शांति के साथ इसका उपयोग कर सकते हैं।
05 कार्रवाई करें: इसे एक पूरा लूप पूरा करते हुए खुद देखें
केवल सिद्धांत को पढ़ने से आप इसे याद नहीं रख पाएंगे, एक न्यूनतम प्रयोग करें और अपनी आँखों से इसे "सोचना→करना→देखना" का एक पूरा चक्कर लगाते हुए देखें। यह प्रयोग किसी भी मौजूदा प्रोजेक्ट पर निर्भर नहीं करता है, आप इसे केवल एक खाली फ़ोल्डर बनाकर कर सकते हैं।
पहला कदम: एक खाली निर्देशिका बनाएं, दर्ज करें और Claude Code शुरू करें।
टर्मिनल में चलाएं (Mac / Linux; Windows पर PowerShell में mkdir -p को mkdir से बदलें):
mkdir -p ~/cc-demo && cd ~/cc-demo
claudeदूसरा कदम: प्रवेश करने के बाद, पहले योजना मोड पर स्विच करें ताकि यह देखा जा सके कि यह कैसे "सोचता" है।
दो बार Shift+Tab दबाएं, और इंटरफ़ेस के नीचे यह संकेत मिलेगा कि आपने Plan Mode (योजना मोड) में प्रवेश कर लिया है। फिर इसे यह वाक्य दें:
मेरे लिए एक Python स्क्रिप्ट add.py लिखें, जिसमें एक फ़ंक्शन add(a, b) हो जो दो संख्याओं का योग लौटाता हो,
फिर इसे सत्यापित करने के लिए कुछ परीक्षण मामले (test cases) लिखें, और अंत में परीक्षण चलाएं। पहले मुझे योजना दें, सीधे कार्रवाई न करें।देखने की उम्मीद: यह तुरंत फ़ाइल नहीं बनाएगा, बल्कि पहले आपको एक योजना के साथ उत्तर देगा, मोटे तौर पर इस तरह—
योजना:
1. add.py बनाएं, add(a, b) लागू करें
2. परीक्षण बनाएं (assert या pytest का उपयोग करके)
3. परीक्षण चलाएं, पुष्टि करें कि सभी पास हो गए
क्या आप चाहते हैं कि मैं शुरू करूँ?यही है "सोचना"—इसने कार्रवाई करने से पहले अपनी विचार प्रक्रिया को स्पष्ट कर लिया है। ध्यान दें कि यह आपके अनुमोदन (approval) की प्रतीक्षा करने के लिए रुक गया है, यह योजना मोड की विशेषता है।
तीसरा कदम: अनुमोदन करें, इसे "करते" + "देखते" हुए देखें।
उत्तर दें "हाँ, शुरू करें"। फिर आप इसे क्रम में देखेंगे:
- फ़ाइल बनाना (फ़ाइल ऑपरेशन टूल)——शायद पहले अनुमति की पुष्टि के लिए पॉप अप हो, आप सहमत होने के लिए दबाएं
- लिखने के बाद परीक्षण चलाना (निष्पादन टूल), उदाहरण के लिए
python add.pyयाpytestनिष्पादित करें - परीक्षण आउटपुट आपको पेस्ट करेगा, उम्मीद के अनुसार कुछ इस तरह:
परीक्षण पास: add(2, 3) == 5 ✓ add(-1, 1) == 0 ✓ add(0, 0) == 0 ✓यहाँ तक, आपने पूरा लूप देख लिया है: सोचना (योजना बनाना) → करना (फ़ाइल बनाना, कोड लिखना) → देखना (परीक्षण चलाना और परिणाम की रिपोर्ट करना)।
चौथा कदम (वैकल्पिक): जानबूझकर एक "पुनरावृत्ति (re-loop)" बनाएं।
इसे बताएं: "add को घटाव में बदलें, लेकिन फ़ंक्शन का नाम न बदलें, और फिर परीक्षण फिर से चलाएं।"
आप देखेंगे कि यह कोड बदलता है, और परीक्षण फिर से चलाता है—यदि परीक्षण का दावा (assertion) अभी भी जोड़ है, तो परीक्षण विफल हो जाएगा, और यह खुद पता लगाएगा कि यह विफल हो गया है, वापस जाएगा और इसे फिर से बदल देगा। यही लूप का सार है: गलती देखने पर, स्वचालित रूप से एक और राउंड करना।
शुरुआती लोगों के लिए यह प्रयोग एक बार करना उचित है। "एजेंट लूप" शब्द को दस बार पढ़ने की तुलना में, अपनी आँखों से इसे रुककर योजना बनाते, फिर कार्रवाई करते, और फिर सत्यापित करते देखना, समझने में बहुत तेज है।
💡 एक वाक्य में सारांश: इस न्यूनतम प्रयोग को चलाने से, आप अपनी आँखों से "सोचना→करना→देखना" चक्र देखेंगे—विशेष रूप से जब यह खुद अपनी गलती का पता लगाता है और स्वचालित रूप से एक और राउंड शुरू करता है।
06 सारांश
इस लेख ने एक बात स्पष्ट कर दी है: Claude Code अपने आप काम क्यों कर सकता है।
आइए मुख्य बातों पर नज़र डालें:
| मुख्य बिंदु | एक वाक्य में याद रखें |
|---|---|
| एजेंट लूप | सोचना→करना→देखना, काम पूरा होने तक घूमना; यही इसके और चैटबॉक्स के बीच का मूल अंतर है |
| मॉडल + उपकरण | मॉडल सोचने के लिए जिम्मेदार है, उपकरण करने और देखने के लिए जिम्मेदार हैं |
| 5 प्रकार के उपकरण | फ़ाइल / खोज / निष्पादन / नेटवर्क / कोड इंटेलिजेंस, यह खुद चुनता है कि किसका उपयोग करना है |
| यह क्या देख सकता है | ≈ उस निर्देशिका में आपकी टर्मिनल अनुमतियां, कई फ़ाइलों में समन्वय कर सकता है |
| दो सुरक्षा गेट | चेकपॉइंट (खराब बदलावों को वापस लिया जा सकता है) + अनुमति मोड (कार्रवाई करने से पहले पूछना है या नहीं) |
अब आपको यह समझने में सक्षम होना चाहिए कि कार्य चलाते समय Claude Code की स्क्रीन पर क्या हो रहा है—हर फ़ाइल जो यह पढ़ता है, हर कमांड जो यह चलाता है, लूप का एक चरण है; आपने यह भी जान लिया है कि आपातकालीन स्टॉप के लिए Esc का उपयोग कैसे करें, योजना देखने के लिए पहले योजना मोड का उपयोग कैसे करें, और इसे कोड बदलने देने के लिए चेकपॉइंट पर कैसे भरोसा करें।
इस तंत्र को समझने के बाद, इसका उपयोग करते समय आपकी मानसिकता पूरी तरह से अलग होगी: यह कोई विशिंग वेल (wishing well) नहीं है, बल्कि एक ऐसा भागीदार है जो खुद सोचेगा, काम करेगा और जांच करेगा—आपका काम दिशा देना, स्वीकृति मानक निर्धारित करना और भटकने पर इसे वापस ट्रैक पर लाना है।
अगला लेख 04 · API कॉन्फ़िगरेशन: Claude Code इंस्टॉल हो गया है, और आप सिद्धांत को समझ गए हैं, लेकिन इसे वास्तव में काम करने के लिए एक मॉडल से जुड़ना होगा। अगला लेख आपको API कॉन्फ़िगरेशन के माध्यम से ले जाएगा—एक बार जब यह चरण पूरा हो जाता है, तो आपके द्वारा पहले सीखे गए लूप और टूल काम कर सकते हैं।