पिछले महीने दुनिया के दो सबसे वरिष्ठ AI इंजीनियरों ने एक ही बात कही।
पीटर स्टीनबर्गर, OpenClaw के निर्माता, अब OpenAI में:
"अब आपको कोडिंग एजेंट्स को प्रॉम्प्ट नहीं करना चाहिए। आपको ऐसे लूप्स डिज़ाइन करने चाहिए जो आपके एजेंट्स को प्रॉम्प्ट करें।"
बोरिस चेर्नी, Anthropic में Claude Code के प्रमुख:
"मैं अब Claude को प्रॉम्प्ट नहीं करता। मेरे पास लूप्स चल रहे हैं जो Claude को प्रॉम्प्ट करते हैं और तय करते हैं कि क्या करना है। मेरा काम लूप्स लिखना है।"
ज़्यादातर लोगों ने यह पढ़ा और सोचा: इसका वास्तव में क्या मतलब है?
और इससे भी महत्वपूर्ण: मैं एक कैसे बनाऊं?
यह लेख आपको बिल्कुल बताता है कि कैसे।
जिस तरह से ज़्यादातर लोग AI का उपयोग करते हैं वह पहले से ही पुराना हो चुका है
प्रॉम्प्ट लिखें। प्रतीक्षा करें। आउटपुट पढ़ें। इसे मैन्युअल रूप से ठीक करें। दूसरा प्रॉम्प्ट लिखें।
आप ही लूप हैं।
हर कदम आपके माध्यम से चलता है। AI इंतज़ार करता है। आप निर्णय लेते हैं। AI फिर इंतज़ार करता है।
जिस पल आप रुकते हैं, सब कुछ रुक जाता है।
2026 में सबसे तेज़ी से आगे बढ़ने वाले बिल्डर बेहतर प्रॉम्प्ट नहीं लिख रहे हैं।
वे ऐसी प्रणालियाँ बना रहे हैं जो उनके लिए प्रॉम्प्टिंग करती हैं।
लीवरेज पॉइंट स्थानांतरित हो गया है।
प्रॉम्प्ट टाइप करने से → लूप्स डिज़ाइन करने तक।
वास्तव में एक लूप क्या है (इसे आगे बढ़ने से पहले परिभाषित करें)
एक प्रॉम्प्ट एक प्रश्न है।
आप पूछते हैं। मॉडल एक बार उत्तर देता है। समाप्त।
एक लूप एक कार्य है।
एजेंट काम करता रहता है, अपनी प्रगति की जाँच करता है, और तब तक चलता रहता है जब तक कार्य वास्तव में पूरा नहीं हो जाता।
तब तक नहीं जब तक वह उत्तर उत्पन्न नहीं करता।
जब तक वह सत्यापित परिणाम तक नहीं पहुँचता।
यह दोहराओ-जबतक-पूरा-हो चक्र ही लूप है।
और यह उस इंजन के अंदर है जो हर AI एजेंट में है जिसे आपने कभी इस्तेमाल किया है।
Claude Code, Cursor, Codex।
अंदर से, वे सभी एक ही तरह से काम करते हैं:
→ एजेंट एक मॉडल को कॉल करता है
→ मॉडल एक कार्य चुनता है
→ कार्य चलता है
→ परिणाम वापस मॉडल के पास जाता है
→ यह तब तक दोहराता है जब तक लक्ष्य पूरा नहीं हो जाता
लूप ही वह चीज़ है जो एक एजेंट को एकल उत्तर के बजाय एजेंट बनाती है।
उन सभी टूल्स में, लूप निश्चित और छिपा हुआ है।
आप इसे खोल नहीं सकते। आप यह नहीं बदल सकते कि यह कैसे काम करता है। आपको वही मिलता है जो टूल ने तय किया कि लूप होना चाहिए।
यह बदलने वाला है।
Slate द्वारा प्रोग्राम (लूप्स का अगला चरण)
Slate AI एजेंट्स चलाने के लिए एक CLI है जो वास्तव में फैलता है। एक सहायक के कदम दर कदम काम करने के बजाय, Slate स्वतंत्र थ्रेड्स को स्पिन करता है जो समानांतर में चलते हैं।
प्रोग्राम आपको अपने स्वयं के एजेंट वर्कफ़्लो बनाने देते हैं: प्रति कार्य कोई भी मॉडल चुनें, एजेंट को उपयोग करने के लिए वास्तविक सॉफ़्टवेयर दें, और ब्लैक-बॉक्स "प्रबंधित एजेंट" पर भरोसा करने के बजाय स्वयं लूप को नियंत्रित करें।
एक प्रोग्राम वह लूप है - सिवाय इसके कि यह जावास्क्रिप्ट में लिखा गया है और Slate इसे आपके लिए चलाता है।
आप तय करते हैं:
→ प्रत्येक चरण पर क्या होता है
→ कौन सा मॉडल किस चरण को संभालता है
→ लूप जारी रखने से पहले क्या जाँच करता है
→ यह कब रुकता है
तो लूप विचार है - तब तक काम करते रहें जब तक पूरा न हो।
एक प्रोग्राम वह है जिससे आप Slate में एक बनाते हैं।
यदि आप चरणों का वर्णन कर सकते हैं, तो आप लूप बना सकते हैं।
इसे Minecraft की तरह सोचें।
Minecraft आपको खेल के माध्यम से एक निश्चित रास्ता नहीं देता है।
यह आपको ब्लॉक देता है और कहता है: जाओ और जो कुछ भी तुम कल्पना कर सकते हो बनाओ।
प्रोग्राम उसी तरह काम करते हैं।
यहां वे ब्लॉक हैं जिन्हें आप जोड़ सकते हैं:
→ एक लक्ष्य इनपुट — उद्देश्य और सफलता मानदंड परिभाषित करें
→ एक योजनाकार — कार्य को चरणों में शोध और तोड़ता है
→ वर्कर ब्लॉक — प्रत्येक चरण को निष्पादित करते हैं
→ वेरिफायर ब्लॉक — बिना पूर्वाग्रह के निष्पादन की जाँच करते हैं
→ लूप स्वयं — प्रत्येक चरण के लिए चलता है, तब तक दोहराता है जब तक लक्ष्य पूरा न हो
→ मॉडल चयन — आसान चरणों के लिए सस्ता तेज़ मॉडल, कठिन सोच के लिए फ्रंटियर मॉडल
→ स्थिति — सत्रों में स्थायी मेमोरी
→ रुकने की शर्तें — प्रोग्राम कैसे जानता है कि कब बाहर निकलना है
एक बार जब कुछ ब्लॉक एक साथ काम करते हैं, तो Slate प्रोग्राम का स्व-निदान कर सकता है और अधिक ब्लॉक जोड़ सकता है।
लूप समय के साथ स्मार्ट होता जाता है।
यह क्यों मायने रखता है: कोई भी मॉडल, कोई भी चरण
एक प्रोग्राम के अंदर, आप किसी भी चरण पर किसी भी मॉडल का उपयोग कर सकते हैं।
फ़ाइलों को छाँटने के लिए एक सस्ता ओपन-वेट मॉडल।
कठिन तर्क के लिए एक मजबूत फ्रंटियर मॉडल।
जो भी चरण में फिट बैठता है।
इसमें ओपन-सोर्स मॉडल शामिल हैं।
अधिकांश एजेंट टूल आपको एक मॉडल तक सीमित करते हैं।
प्रोग्राम नहीं करते।
आप इंजीनियर हैं।
आप तय करते हैं कि कहाँ क्या चलेगा।
एक वास्तविक प्रोग्राम: जंगल की आग का विकी
यहाँ बताया गया है कि यह एक वास्तविक कार्य पर कैसा दिखता है।
मान लीजिए आप जंगल की आग के डेटा के लिए एक इंटरैक्टिव विकी बनाना चाहते हैं।
आम तौर पर आप इसे मैन्युअल रूप से जोड़ने में एक या दो दिन खो देंगे।
प्रोग्राम के साथ, आप चरणों का वर्णन करते हैं। Slate लूप बनाता और चलाता है।
ब्लॉक 1 — गहन शोध
पहले ब्लॉक को प्रश्न पर इंगित करें।
यह खोजता है, पढ़ता है, तेज करता है।
डेटासेट, स्रोत और जो वास्तव में मायने रखता है, उसके साथ वापस आता है।
ब्लॉक 2 — योजनाकार
शोध को योजनाकार ब्लॉक को सौंपें।
इसे काम करने का क्रम बताएं:
→ पहले: प्रोजेक्ट सेट अप करने का तरीका पता करें
→ फिर: विकी को वास्तविक आवश्यकताओं में तोड़ें — मानचित्र दृश्य, टाइमलाइन, डेटा तालिकाएँ, खोज
ब्लॉक 3 — समानांतर वर्कर
प्रत्येक आवश्यकता को अपने आप चलाएं।
प्रत्येक अपना स्वयं का लक्ष्य ब्लॉक है जो समानांतर में काम करता है जब तक कि वह सुविधा पूरी न हो जाए।
ब्लॉक 4 — रचना
ब्लॉक रचना करते हैं।
जो एक शोध प्रश्न के रूप में शुरू हुआ वह एक React विकी के रूप में समाप्त होता है जिसे आप क्लिक करके देख सकते हैं।
एक दोहराने योग्य लूप से उत्पन्न हुआ जिसका आपने वर्णन किया है।
जब आपको इसे ताज़ा करने की आवश्यकता हो: लूप को फिर से चलाएं।
कोई अनुमान नहीं कि यह कैसे व्यवहार करेगा।
गहन शोध अंदर गया। एक इंटरैक्टिव वेबसाइट बाहर आई।
आप अकेले प्रोग्राम नहीं बनाते
आप एक खाली फ़ाइल से शुरू नहीं करते।
आप Slate को बताते हैं कि आप क्या चाहते हैं।
Slate आपके साथ कदम दर कदम लूप का मसौदा तैयार करता है।
यह लूप को सहेजता है ताकि आप इसे फिर से चला सकें।
यह इसे आपके लिए चलाता है।
Slate लूप बनाने के लिए आपका सह-इंजीनियर है।
यह हर दूसरे टूल से अलग है।
अन्य टूल: यहाँ एक निश्चित एजेंट है। इसे हमारे सिस्टम के अंदर उपयोग करें।
Slate: यहाँ ब्लॉक हैं। मुझे बताएं कि आप क्या बनाना चाहते हैं। मैं इसे आपके साथ जोड़ दूंगा।
क्रिएटिव मोड के बारे में सोचें।
आप इंजीनियर हैं जो दृष्टि निर्धारित करते हैं।
Slate सह-इंजीनियर है जो इन चीजों के आकार को जानता है और ब्लॉक रखता है।
क्योंकि प्रोग्राम जावास्क्रिप्ट हैं, वे वास्तविक काम कर सकते हैं
यह वह हिस्सा है जो संभव को बदलता है।
एक प्रॉम्प्ट एक प्रश्न का उत्तर दे सकता है।
एक प्रोग्राम दुनिया के साथ बातचीत कर सकता है।
एक प्रोग्राम को Slack पर इंगित करें और यह हर कुछ मिनटों में एक नए संदेश की जाँच कर सकता है, फिर मांग पर कोड उत्पन्न कर सकता है।
इसे अपने कोडबेस पर इंगित करें और यह आपके सोते समय माइग्रेशन चलाता है।
इसे एक स्प्रेडशीट पर इंगित करें और यह लगातार पंक्तियों को संसाधित करता है।
आप Claude Tag का अपना संस्करण बना सकते हैं।
आप एक सॉफ्टवेयर फैक्ट्री बना सकते हैं।
आप एक संगठन बना सकते हैं।
लूप स्थिति रखता है और चलता रहता है।
यह एक उत्तर वापस करने के बजाय वास्तविक काम करता है।
एक पंक्ति में Slate स्थापित करें
इसे अपने प्रोजेक्ट में शुरू करें:
Slate को बताएं कि आप कौन सा प्रोग्राम बनाना चाहते हैं।
यह आपके साथ लूप का मसौदा तैयार करता है।
पुनरावलोकन
एक प्रॉम्प्ट एक बार उत्तर देता है और रुक जाता है।
एक लूप एक कार्य है — एजेंट तब तक काम करता रहता है जब तक वह वास्तव में पूरा नहीं हो जाता।
हर AI एजेंट जिसे आपने कभी इस्तेमाल किया है — Claude Code, Cursor, Codex — अंदर से एक लूप है।
उन टूल्स में, लूप निश्चित है। आप इसे खोल नहीं सकते।
एक प्रोग्राम वह लूप है, सिवाय इसके कि यह जावास्क्रिप्ट में लिखा गया है और Slate इसे आपके लिए चलाता है।
आप चरणों का निर्णय लेते हैं। आप प्रत्येक चरण के लिए मॉडल चुनते हैं। आप रुकने की स्थिति निर्धारित करते हैं।
कोई भी मॉडल। कोई भी कार्य। कोई भी एकीकरण।
क्योंकि लूप सिर्फ कोड है, यह स्थिति रख सकता है, चलता रह सकता है, और किसी भी चीज़ के साथ बातचीत कर सकता है — आपका कोडबेस, एक इनबॉक्स, एक स्प्रेडशीट, एक गेम।
आप इसे अकेले नहीं बनाते।
Slate आपका सह-इंजीनियर है।
यदि यह उपयोगी था:
→ इसे उन सभी डेवलपर्स के साथ साझा करने के लिए रिपोस्ट करें जिन्हें आप जानते हैं
→ @sairahul1 को फॉलो करें इस तरह की और प्रणालियों के लिए
→ @wearerandomlabs को फॉलो करें — उन्होंने इसे बनाया है
ऐसे और दिलचस्प लेखों के लिए theaibuilders.co की सदस्यता लें
Slate द्वारा प्रोग्राम आज़माएं: randomlabs.ai
npm i -g
