Claude Code में लूप्स (Loops) के साथ शुरुआत करना

इन दिनों "लूप्स डिज़ाइन करने" की बात बहुत हो रही है, बजाय इसके कि आप अपने कोडिंग एजेंट को प्रॉम्प्ट करें। अगर आप X पर यह समझने की कोशिश करते हैं कि लूप आखिर है क्या, तो आपको कई अलग-अलग जवाब मिलेंगे।

Claude Code टीम में, हम लूप्स को एजेंट्स के रूप में परिभाषित करते हैं जो एक रुकने की शर्त पूरी होने तक काम के चक्रों को दोहराते हैं। हम कुछ अलग-अलग प्रकार के लूप्स को इस आधार पर वर्गीकृत करते हैं:

• वे कैसे ट्रिगर होते हैं
• वे कैसे रुकते हैं
• किस Claude Code प्रिमिटिव का उपयोग किया जाता है
• प्रत्येक के लिए किस प्रकार का कार्य सबसे उपयुक्त है।

हम मुख्य लूप प्रकारों को कवर करेंगे, प्रत्येक का उपयोग कब करना है, और टोकन उपयोग को प्रबंधित करते हुए कोड गुणवत्ता कैसे बनाए रखनी है। सभी कार्यों के लिए जटिल लूप्स की आवश्यकता नहीं होती; सबसे सरल समाधान से शुरू करें और इन पैटर्न का चयनात्मक रूप से उपयोग करें।

टर्न-आधारित लूप्स

• द्वारा ट्रिगर: एक उपयोगकर्ता प्रॉम्प्ट।
• रुकने की कसौटी: Claude निर्णय लेता है कि उसने कार्य पूरा कर लिया है या उसे अतिरिक्त संदर्भ की आवश्यकता है।
• इसके लिए सबसे उपयुक्त: छोटे कार्य जो किसी नियमित प्रक्रिया या शेड्यूल का हिस्सा नहीं हैं।
• द्वारा प्रबंधित उपयोग: विशिष्ट प्रॉम्प्ट लिखें और टर्न की संख्या कम करने के लिए स्किल्स का उपयोग करके सत्यापन में सुधार करें।‍

आपके द्वारा भेजा गया हर प्रॉम्प्ट आपके द्वारा प्रत्येक टर्न को निर्देशित करने के साथ एक मैनुअल लूप शुरू करता है। Claude संदर्भ इकट्ठा करता है, कार्रवाई करता है, अपने काम की जाँच करता है, यदि आवश्यक हो तो दोहराता है, और प्रतिक्रिया देता है। हम इसे एजेंटिक लूप कहते हैं।

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

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

उदाहरण के लिए, आप अपनी SKILL.md फ़ाइल में निर्दिष्ट कर सकते हैं:

1---
2name: verify-frontend-change
3description: किसी भी UI बदलाव को एंड-टू-एंड सत्यापित करें, इससे पहले कि उसे पूर्ण घोषित किया जाए।
4---
5
6# फ्रंटएंड बदलावों का सत्यापन करना
7किसी UI बदलाव को केवल सफल संपादन के आधार पर कभी भी पूर्ण के रूप में रिपोर्ट न करें। इसे उसी तरह सत्यापित करें जैसे कोई मानव समीक्षक करेगा:
8
91. डेव सर्वर शुरू करें और संपादित पेज को ब्राउज़र में खोलें।
10
112. बदलाव के साथ सीधे इंटरैक्ट करें। एक नए कंट्रोल (बटन, इनपुट, टॉगल) के लिए: उस पर क्लिक करें, अपेक्षित स्थिति परिवर्तन की पुष्टि करें, और पहले/बाद का स्क्रीनशॉट लें।
12
133. ब्राउज़र कंसोल की जाँच करें: कोई नई त्रुटि या चेतावनी नहीं होनी चाहिए।
14
154. Chrome Devtools MCP का उपयोग करें, एक प्रदर्शन ट्रेस चलाएँ और Core Web Vitals का ऑडिट करें।
16
17यदि कोई भी चरण विफल होता है, तो समस्या को ठीक करें और चरण 1 से पुनः चलाएँ — आंशिक रूप से सत्यापित कार्य वापस न करें।

लक्ष्य-आधारित लूप (/goal)

• द्वारा ट्रिगर: रीयल-टाइम में एक मैनुअल प्रॉम्प्ट।
• रुकने की कसौटी: लक्ष्य प्राप्त हुआ या टर्न की अधिकतम संख्या तक पहुँच गया।
• इसके लिए सबसे उपयुक्त: ऐसे कार्य जिनमें सत्यापन योग्य निकास मानदंड हों।
• द्वारा प्रबंधित उपयोग: विशिष्ट पूर्णता मानदंड और स्पष्ट टर्न सीमाएँ निर्धारित करना, "5 प्रयासों के बाद रुकें।"

कभी-कभी, एक ही टर्न पर्याप्त नहीं होता, खासकर अधिक जटिल कार्यों के लिए। एजेंट बेहतर करते हैं जब वे पुनरावृत्ति कर सकते हैं। आप /goal के साथ यह परिभाषित करके कि "हो गया" कैसा दिखता है, Claude को पुनरावृत्ति जारी रखने के समय को बढ़ा सकते हैं।

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

यही कारण है कि नियतात्मक मानदंड, जैसे पास किए गए टेस्ट की संख्या या एक निश्चित स्कोर सीमा को साफ़ करना, इतने प्रभावी हैं।

उदाहरण के लिए:

1/goal होमपेज का Lighthouse स्कोर 90 या उससे ऊपर लाएँ, 5 प्रयासों के बाद रुकें।

समय-आधारित लूप (/loop और /schedule)

• द्वारा ट्रिगर: एक निर्दिष्ट समय अंतराल।
• रुकने की कसौटी: आप इसे रद्द करते हैं, या कार्य पूरा हो जाता है (PR मर्ज हो जाता है, कतार खाली हो जाती है)।
• इसके लिए सबसे उपयुक्त: आवर्ती कार्यों के लिए, या बाहरी वातावरण/सिस्टम के साथ इंटरफेस करने के लिए।
• द्वारा प्रबंधित उपयोग: लंबे अंतराल सेट करें या समय के बजाय घटनाओं के आधार पर प्रतिक्रिया करें।

कुछ एजेंटिक कार्य आवर्ती होते हैं: कार्य वही रहता है और केवल इनपुट बदलते हैं। उदाहरण के लिए, हर सुबह Slack संदेशों को सारांशित करना। अन्य कार्य बाहरी सिस्टम पर निर्भर करते हैं, और उनमें से किसी एक के साथ इंटरफेस करने का एक सरल तरीका एक अंतराल पर उसकी जाँच करना और जो बदला है उस पर प्रतिक्रिया करना है। उदाहरण के लिए, एक PR जिसे कोड समीक्षाएँ मिल सकती हैं या CI विफल हो सकता है।

इनके लिए, आप ट्रिगर कर सकते हैं जब Claude \/loop`` के साथ चलता है जो एक अंतराल पर एक प्रॉम्प्ट को फिर से चलाता है। उदाहरण के लिए:

1/loop 5m मेरे PR की जाँच करें, समीक्षा टिप्पणियों का जवाब दें, और विफल CI को ठीक करें

\/loop` आपके कंप्यूटर पर चलता है, इसलिए यदि आप इसे बंद करते हैं, तो यह रुक जाता है। आप \/schedule\` के साथ एक रूटीन बनाकर लूप को क्लाउड पर ले जा सकते हैं।

सक्रिय लूप्स

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

ऊपर दिए गए प्रिमिटिव, अन्य Claude Code सुविधाओं जैसे ऑटो मोड और डायनामिक वर्कफ़्लो (रिसर्च प्रीव्यू) के साथ, लंबे समय तक चलने वाले काम के लिए एक लूप में रचे जा सकते हैं।

उदाहरण के लिए, आने वाले फीडबैक को संभालने के लिए, आप इसका उपयोग कर सकते हैं:

1. `/schedule` (रिसर्च प्रीव्यू) एक रूटीन चलाने के लिए जो नई रिपोर्ट की जाँच करता है
2. `/goal` यह परिभाषित करने के लिए कि "हो गया" कैसा दिखता है और स्किल्स यह दस्तावेज़ित करने के लिए कि इसे कैसे सत्यापित किया जाए
3. डायनामिक वर्कफ़्लो उन एजेंटों को ऑर्केस्ट्रेट करने के लिए जो प्रत्येक रिपोर्ट को ट्राइएज करते हैं, उसे ठीक करते हैं, और फिक्स की समीक्षा करते हैं
4. ऑटो मोड ताकि रूटीन अनुमति माँगने के लिए रुके बिना चले

इसे एक साथ रखते हुए, एक प्रॉम्प्ट इस तरह दिख सकता है:

1/schedule हर घंटे: बग रिपोर्ट के लिए प्रोजेक्ट-फीडबैक चैनल की जाँच करें। /goal: तब तक न रुकें जब तक इस रन में मिली हर रिपोर्ट को ट्राइएज, कार्रवाई और उत्तर नहीं दिया जाता। बग को ठीक करते समय, समानांतर वर्कट्री में तीन समाधानों का पता लगाने के लिए एक वर्कफ़्लो का उपयोग करें और एक जज को उनकी प्रतिकूल समीक्षा करने दें।

कोड गुणवत्ता बनाए रखना

लूप के आउटपुट की गुणवत्ता उसके आसपास के सिस्टम पर निर्भर करती है। सिस्टम डिज़ाइन करते समय:

• कोडबेस को स्वयं साफ रखें: Claude आपके कोडबेस में पहले से मौजूद पैटर्न और कन्वेंशन का पालन करता है।
• Claude को अपने काम को सत्यापित करने का एक तरीका दें: स्किल्स के साथ एन्कोड करें कि आपके और आपकी टीम के लिए अच्छा कैसा दिखता है।
• दस्तावेज़ों तक पहुँचना आसान बनाएं: फ्रेमवर्क और लाइब्रेरी के दस्तावेज़ों में नवीनतम सर्वोत्तम अभ्यास हैं।
• कोड समीक्षा के लिए दूसरे एजेंट का उपयोग करें: ताज़ा संदर्भ वाला एक समीक्षक कम पक्षपाती होता है और मुख्य एजेंट के तर्क से प्रभावित नहीं होता। आप Github के लिए बिल्ट-इन \/code-review`` स्किल या Code Review का उपयोग कर सकते हैं।

जब कोई व्यक्तिगत परिणाम मानक को पूरा नहीं करता है, तो केवल व्यक्तिगत मुद्दे को ठीक करने पर न रुकें, बल्कि भविष्य के सभी पुनरावृत्तियों के लिए सिस्टम को बेहतर बनाने के लिए इसे एन्कोड करने का प्रयास करें।

टोकन उपयोग का प्रबंधन

टोकन उपयोग को प्रबंधित करने के लिए, लूप्स की स्पष्ट सीमाएँ होनी चाहिए:

• काम के लिए सही प्रिमिटिव और मॉडल चुनें: छोटे कार्यों को कई एजेंटों या लूप्स की आवश्यकता नहीं होती। कुछ कार्य सस्ते और तेज़ मॉडल का उपयोग कर सकते हैं।
• स्पष्ट सफलता और रुकने के मानदंड परिभाषित करें: इस बारे में विशिष्ट रहें कि "हो गया" कैसा दिखता है ताकि Claude जल्दी (लेकिन बहुत जल्दी नहीं) समाधान पर पहुँच सके।
• बड़े रन से पहले पायलट करें: डायनामिक वर्कफ़्लो सैकड़ों एजेंटों को जन्म दे सकते हैं। पहले काम के एक छोटे हिस्से पर उपयोग का आकलन करें।
• नियतात्मक कार्य के लिए स्क्रिप्ट का उपयोग करें: स्क्रिप्ट चलाना चरणों के माध्यम से तर्क करने से सस्ता है। उदाहरण के लिए, एक PDF स्किल एक फॉर्म-भरने वाली स्क्रिप्ट भेज सकती है जिसे Claude हर बार चलाता है, कोड को फिर से प्राप्त करने के बजाय।
• रूटीन को आवश्यकता से अधिक बार न चलाएं: अंतराल को उस आवृत्ति से मिलाएँ जिस पर आप जिस चीज़ की निगरानी कर रहे हैं वह बदलती है।
• उपयोग की समीक्षा करें: \/usage` कमांड स्किल्स, सबएजेंट्स और MCPs द्वारा हाल के उपयोग को तोड़ता है, बिना तर्कों के \/goal\ अब तक के टर्न और टोकन उपयोग की संख्या दिखाता है, \/workflows\` प्रत्येक एजेंट का टोकन उपयोग दिखाता है और आप किसी भी समय एक एजेंट को रोक सकते हैं।

शुरू करना

सारांश में:

लूप

आप सौंपते हैं

इसका उपयोग करें जब

पहुँचें

टर्न-आधारित

जाँच

आप खोज रहे हैं या निर्णय ले रहे हैं

कस्टम सत्यापन स्किल्स

लक्ष्य-आधारित

रुकने की शर्त

आप जानते हैं कि "हो गया" कैसा दिखता है

/goal

समय-आधारित

ट्रिगर

काम आपके प्रोजेक्ट के बाहर एक शेड्यूल पर होता है

/loop

,

/schedule

सक्रिय

प्रॉम्प्ट

काम आवर्ती और अच्छी तरह से परिभाषित है

उपरोक्त सभी, और डायनामिक वर्कफ़्लो

लूप्स के साथ शुरू करने के लिए, उस काम को देखें जो आप पहले से करते हैं। एक ऐसा कार्य चुनें जहाँ आप बाधा हैं और पूछें कि आप कौन सा हिस्सा सौंप सकते हैं: क्या आप सत्यापन जाँच लिख सकते हैं? क्या लक्ष्य पर्याप्त स्पष्ट है? क्या काम एक शेड्यूल पर आता है?

एक बार जब आपके पास एक विचार हो, तो लूप चलाएँ, परिणामों का निरीक्षण करें जैसे कि यह कहाँ अटकता है या अति करता है, और उस पर पुनरावृत्ति करने से न डरें।

अधिक जानकारी के लिए, समानांतर में एजेंट चलाने के साथ-साथ लूप, शेड्यूल, गोल, और डायनामिक वर्कफ़्लो पृष्ठों पर Claude Code दस्तावेज़ पढ़ें।

यह लेख @delba_oliveira द्वारा लिखा गया था