चेतावनी: AI लूप न बनाएं। जब तक 4 शर्तें पूरी न हों, आप सिर्फ पैसे बर्बाद कर रहे हैं

【चेतावनी】लूप न बनाएँ। जब तक 4 शर्तें पूरी न हों, पैसा पिघल जाएगा।

"प्रॉम्प्ट करना बंद करो, लूप बनाना शुरू करो।"

पिछले कुछ महीनों में AI की दुनिया में यह वाक्यांश सबसे ज़्यादा चर्चा में रहा है। Claude Code के निर्माता और OpenAI के लोगों ने अलग-अलग तरीकों से एक ही बात कहना शुरू कर दिया है।

हालाँकि, इन शब्दों को देखने वाले ज़्यादातर लोग यह समझे बिना ही आगे बढ़ जाते हैं कि करना क्या है। पहले मैं भी ऐसा ही था।

और एक और बात है जो कोई पहले से नहीं बताता। अगर सही शर्तें पूरी न करने वाला व्यक्ति लूप बनाता है, तो वह एक ऐसी मशीन बन जाती है जो चुपचाप आपका पैसा पिघला देती है।

इस लेख में, मैं लूप की सामग्री को विस्तार से समझाऊँगा और उन लोगों के बीच रेखा खींचूँगा जिन्हें लूप बनाना चाहिए और जिन्हें नहीं बनाना चाहिए। उसके बाद, मैं उन लोगों के लिए भी आज से लूप चलाने का "सबसे हल्का" तरीका बताऊँगा जो अभी सभी शर्तें पूरी नहीं करते।

ध्यान दें कि इस लेख में दो तरह के टेक्स्ट हैं: कमांड्स (टर्मिनल या Claude Code इनपुट फ़ील्ड में टाइप करने के लिए) और प्रॉम्प्ट्स (AI चैट में पेस्ट करने के लिए निर्देशात्मक टेक्स्ट)। उन्हें अलग-अलग चिह्नित किया गया है ताकि आप उन्हें पहचान सकें।

ज़्यादातर लोग AI का इस्तेमाल सबसे धीमे तरीके से कर रहे हैं

ज़्यादातर लोग अभी "एक-बार-में-एक-सवाल" वाला तरीका इस्तेमाल कर रहे हैं। आप तय करते हैं कि क्या पूछना है, आप जाँचते हैं कि मिला जवाब काम का है या नहीं, और आप तय करते हैं कि आगे क्या करना है।

AI तब तक नहीं हिलता जब तक आप उसे धक्का न दें, और जैसे ही आप रुकते हैं, वह रुक जाता है।

यह ज़रूरी नहीं कि बुरा हो। हालाँकि, इसकी एक सीमा है। आप इंजन हैं, और AI आपके हाथ में सिर्फ़ एक औज़ार बना रहता है।

काम करने का एक और तरीका है। उसे कदम-दर-कदम चलाना बंद करें; इसके बजाय, उसे लक्ष्य दें और उसे खुद चलने दें। AI कदम तय करता है, काम करता है, लक्ष्य के हिसाब से अपने नतीजों की जाँच करता है, कमज़ोरियों को ठीक करता है, और फिर से कोशिश करता है। आप अपनी मेज़ से उठकर जा सकते हैं, और काम फिर भी आगे बढ़ता रहता है।

यही एक लूप है।

लूप की असली पहचान: 5 चरण

प्रॉम्प्ट एक एकल निर्देश है। लूप एक ऐसा लक्ष्य है जिसकी ओर AI तब तक दौड़ता रहता है जब तक वह पहुँच न जाए।

अगर आप लूप के अंदर देखें, तो यह ऐसा दिखता है:

① पता लगाएँ ... समझें कि क्या करने की ज़रूरत है

② तय करें ... योजना बनाएँ कि इसे कैसे किया जाए

③ करें ... वास्तव में काम पूरा करें

④ जाँचें ... लक्ष्य से तुलना करके पास या फेल तय करें

⑤ दोहराएँ ... अगर लक्ष्य तक नहीं पहुँचा, तो नतीजा वापस जमा करें और दोहराएँ

इन पाँच में से, आखिरी तीन ही वाकई मायने रखते हैं। और यहीं वे सभी लड़खड़ाते हैं जो असफल होते हैं।

सत्यापन चरण ही लूप का दिल है

अगर नतीजों की सच में जाँच करने की कोई व्यवस्था नहीं है, तो वह लूप नहीं है। वह सिर्फ़ AI है जो बार-बार खुद से कह रहा है, "शाबाश।"

दोहराव को प्रगति में बदलने वाली चीज़ यही जाँच है। यह हो सकता है कि टेस्ट पास हो रहा है या नहीं, या कोई संख्या किसी निश्चित मान से ज़्यादा है या नहीं। AI को खुद को ग्रेड देने के लिए एक स्कोरकार्ड देना भी चलता है।

गेटकीपर के बिना, काम करने वाला व्यक्ति अपने ही होमवर्क को ग्रेड देने लगता है। और जिसने वह कर लिखा है, वह ग्रेडर के तौर पर अपने प्रति बहुत उदार होता है।

रिकॉर्ड लूप को सीखने देते हैं

हर चक्र के साथ, AI को याद रखना होता है कि उसने पहले क्या कोशिश की थी। अगर उसे याद नहीं रहता, तो वह हमेशा वही गलतियाँ दोहराता रहेगा।

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

वैसे, यहीं से लागत भी बढ़ने लगती है। इसकी वजह मैं आगे बताऊँगा।

बिना रुकने की शर्त वाला लूप सुबह तक चलता है

बिना बाहर निकलने के रास्ते वाला लूप तब तक चलता रहेगा जब तक वह सफल न हो जाए, टूट न जाए, या आपका बैंक खाता खाली न कर दे। एक सही लूप में रुकने के दो रास्ते होते हैं: सफल होने पर, और एक सख्त सीमा जैसे "8 कोशिशों के बाद फेल होने पर रुकें और रिपोर्ट करें।"

अगर आप यह छोड़ देते हैं, तो आपके पास एक ऐसी मशीन होगी जो पूरी रात चलती रहेगी और कुछ नहीं बनाएगी।

प्रॉम्प्ट AI को एक निर्देश देता है। लूप AI को एक काम, पूरा होने का पैमाना, और हार मानने के नियम देता है।

लेकिन पहले: क्या आपको लूप बनाना भी चाहिए?

ज़्यादातर लेख यह बताने से पहले लूप की सिफारिश कर देते हैं कि उन्हें कब नहीं बनाना चाहिए। यहाँ वह पैमाना है जो वास्तव में लूप चलाने वाले लोग इस्तेमाल करते हैं:

लूप बनाना तभी उचित है जब निम्नलिखित चारों शर्तें पूरी हों:

① यह ऐसा काम है जो हफ्ते में कम से कम एक बार दोहराया जाता है

अगर उससे कम है, तो इसे बनाने की मेहनत कभी नहीं निकलेगी। एक बार के काम के लिए, एक अच्छा प्रॉम्प्ट ज़्यादा तेज़ है।

② खराब नतीजों को अपने आप अस्वीकार करने की व्यवस्था हो

टेस्ट, टाइप चेक, बिल्ड, लिंटर, या सख्त नियम। अगर आप कुछ भी फ़िल्टर नहीं कर सकते, तो लूप सिर्फ़ अपने पहिये घुमाता रहेगा।

③ AI इसे पूरी तरह से अपने दम पर पूरा कर सके

अगर उसे बीच में आपके पास लौटना पड़े, तो आप काम करने से ज़्यादा समय इंतज़ार में बिताएँगे।

④ "पूरा होना" निष्पक्ष रूप से तय हो

अगर गुणवत्ता व्यक्तिगत पसंद का मामला है, तो इंसान ही अब भी जीतता है।

अगर इनमें से एक भी चीज़ गायब है, तो मैनुअल प्रॉम्प्टिंग से चिपके रहें।

इस चर्चा का सबसे ईमानदार हिस्सा यह है: लूप की अवधारणा असली है। हालाँकि, ज़्यादातर लोगों को अभी "भारी" वाला वर्ज़न नहीं चाहिए। जो वर्ज़न हर कोई इस्तेमाल कर सकता है वह "हल्का" वाला है, जो मैं इस लेख के दूसरे हाफ़ में दूँगा। फिर भी, आपको पता होना चाहिए कि रेखा कहाँ खिंची गई है।

यह पहले कोडिंग की दुनिया में क्यों फैला: 5 घटक

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

कोड-केंद्रित लूप के लिए, एक लक्ष्य और एक सख्त जाँच एक सेट के रूप में दी जाती है।

▼AI चैट में पेस्ट करने के लिए निर्देशात्मक टेक्स्ट▼

1लक्ष्य: /tests/auth के सभी टेस्ट पास हों, शून्य लिंटर चेतावनी, शून्य टाइप एरर।
2
3हर बार करने के लिए:
4① टेस्ट चलाएँ और सभी फेलियर पढ़ें
5② सबसे असरदार एक फेलियर चुनें
6③ उसे ठीक करने के लिए न्यूनतम बदलाव करें
7④ टेस्ट, लिंटर और टाइप चेक फिर से चलाएँ
8
9पास होने की शर्तें: सभी टेस्ट पास + शून्य चेतावनी + शून्य टाइप एरर
10रुकने की शर्तें: पास होने पर, या 8 चक्रों के बाद
11रुकने पर: क्या बदला गया और क्या अभी भी फेल हो रहा है, इसका सारांश रिपोर्ट करें

यह लूप पाँच घटकों से बना है। Claude Code और Codex में ये सभी पाँच शामिल हैं।

① स्वचालित ट्रिगर (दिल की धड़कन): यही चीज़ इसे एक बार के काम की बजाय लूप बनाती है। अगर आप निर्देश, अंतराल और लक्ष्य तय करते हैं, तो यह आपके शुरू किए बिना भी चलेगा। Claude Code में, /loop तय अंतराल पर एक ही निर्देश चलाता है, और /goal सेशन को तब तक जारी रखता है जब तक शर्तें सच में पूरी नहीं हो जातीं। अगर आप इसे cron या GitHub Actions पर लगाते हैं, तो यह आपके लैपटॉप का ढक्कन बंद करने के बाद भी काम करता है। नतीजे खुद आपके पास आते हैं, इसलिए आपको उन्हें ढूँढने नहीं जाना पड़ता।

▼AI चैट में पेस्ट करने के लिए निर्देशात्मक टेक्स्ट▼

1/loop 1h इस रिपॉज़िटरी के टेस्ट चलाएँ, ठीक एक फेलियर ठीक करें, और रिपोर्ट करें।

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

③ निर्माता और निरीक्षक को अलग करना: लूप सेट करने का यह सबसे असरदार तरीका है। कोड लिखने वाला मॉडल अपने होमवर्क के प्रति उदार होता है। अलग निर्देशों वाला दूसरा मॉडल—कभी-कभी एक मज़बूत मॉडल—लाकर आप उन चीज़ों को पकड़ सकते हैं जिनके बारे में पहले मॉडल ने खुद को समझा लिया था कि सब ठीक है। लेखक एक तेज़, सस्ता मॉडल है; निरीक्षक एक धीमा, सख्त मॉडल है। यह अलगाव ही अधिकांश गुणवत्ता पैदा करता है।

④ इंटीग्रेशन (सुझाव देने की बजाय निष्पादन): ऐसे AI के बीच जो कहता है "आपको इसे ऐसे ठीक करना चाहिए" और ऐसे लूप के बीच जो PR खोलता है, टिकट लिंक करता है, और बिल्ड पास होते ही नोटिफिकेशन भेजता है, यही फ़र्क है। क्या यह वास्तविक वर्कस्पेस तक पहुँच सकता है—यही विभाजक रेखा है।

⑤ निरीक्षक (गेट): टेस्ट या टाइप चेक जो खराब काम को अपने आप अस्वीकार कर देते हैं। अकेला यही घटक तय करता है कि लूप आपकी मदद करेगा या सिर्फ़ आपका पैसा खर्च करेगा। बाकी सब कुछ सिर्फ़ पाइपलाइन है।

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

यह एक शानदार कहानी है। लेकिन एक कीमत है जो कभी डेमो में नहीं दिखती।

वो लागत वाली कहानी जो कोई नहीं बताता

लूप टोकन पर चलते हैं। टोकन पैसा है। समस्या यह नहीं है कि हर कदम पर पैसा लगता है; समस्या यह है कि लागत कैसे बढ़ती है।

लूप के हर चक्र के साथ, AI संदर्भ को फिर से पढ़ता है: लक्ष्य, कोड, पिछले नतीजे और फेलियर। यह पूरा ढेर हर बार मॉडल को भेजा जाता है, और हर चक्र के साथ बढ़ता जाता है।

अगर यह 10 बार लूप चलाता है, तो बिल 10 प्रॉम्प्ट का नहीं है; बिल है 10 लगातार बढ़ते हुए प्रॉम्प्ट्स का। इसके अलावा, गुणवत्ता सुधारने वाला "निर्माता और निरीक्षक का अलगाव" बिल को दोगुना कर देता है क्योंकि दो मॉडल संदर्भ पढ़ रहे होते हैं।

मोटा अनुमान:

1 AI / 1 मध्यम काम: 50,000 से 200,000 टोकन

हर लूप में संदर्भ फिर से पढ़ना: हर चक्र के साथ बढ़ता है

कई AI समानांतर चलाना: उपरोक्त को AI की संख्या से गुणा करें

लगभग कोई भी उस नंबर पर नज़र नहीं रखता जो वाकई मायने रखता है: प्रति स्वीकृत नतीजे की लागत। बात इस्तेमाल किए गए टोकन या चलाए गए चक्रों की नहीं है।

अगर एक लूप 10 नतीजे बनाता है और आप 6 को फेंक देते हैं, तो आप वह निरीक्षण का काम खुद कर रहे हैं जिसे आप बचाने वाले थे। अगर स्वीकृति दर 50% से नीचे गिर जाती है, तो वह लूप जितना मूल्य लौटाता है उससे ज़्यादा खर्च कर रहा है।

इससे भी बुरी बात, लूप चुपचाप असफल हो सकते हैं। इंजीनियर जेफ्री हंटली ने इसे "राल्फ विगगम लूप" (Ralph Wiggum Loop) कहा। AI जल्दबाज़ी में फैसला करता है "मैं पूरा हो गया" और आधे-अधूरे काम के साथ बाहर निकल जाता है। या, लूप घूमता ही रहता है, कुछ नहीं बनाता और बिल बढ़ता जाता है।

जिस लूप के पास असफल होने के लिए कोई गेट नहीं है, वह कभी असफल नहीं होगा। वह सिर्फ़ चुपचाप आपसे पैसे वसूलता रहेगा।

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

अगर क्रम गलत किया, तो यह आपके सोते समय जल जाएगा

अगर आप लूप बनाने जा रहे हैं, तो टूल्स से ज़्यादा ज़रूरी क्रम है। जो लोग ऐसे लूप चलाते हैं जो मैदान में टिकते हैं, वे हमेशा इसी क्रम में बनाते हैं:

① पहले, मैनुअल तरीके से एक बार पक्की सफलता पाएँ

② उसे "स्किल" में बदलें (निर्देश सेव करें)

③ स्किल को लूप में लपेटें (गेट और रुकने की शर्तें जोड़ें)

④ उसके बाद ही स्वचालित निष्पादन पर लगाएँ

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

सबसे हल्का लूप जो आप आज चला सकते हैं

कोडिंग-विशिष्ट AI के बिना भी, आप अभी लूप का अहसास ले सकते हैं। आप एक ही प्रॉम्प्ट से मैनुअल लूप चला सकते हैं।

ट्रिक यह है कि शुरुआत में ही तीनों घटक दें: लक्ष्य, सख्त पास होने की शर्तें, और रुकने से पहले AI को अपना निरीक्षण करने की प्रक्रिया।

---प्रॉम्प्ट (AI चैट में पेस्ट करने के लिए निर्देशात्मक टेक्स्ट)---

1अब आप मानदंड पूरे होने तक एक लूप में काम करेंगे।
2
3【कार्य】 [लिखें कि आप वास्तव में क्या बनवाना चाहते हैं]
4
5【पास होने की शर्तें (कोई नरम ग्रेडिंग नहीं)】
6
7[शर्त 1]
8[शर्त 2]
9[शर्त 3]
10
11【हर चक्र की प्रक्रिया】
12① योजना: केवल अगला एक कदम घोषित करें।
13② काम: बनाएँ या ठीक करें।
14③ निरीक्षण: हर शर्त को 1 से 10 के पैमाने पर ग्रेड करें। बेहद सख्त रहें। सभी कमज़ोरियाँ सूचीबद्ध करें।
15④ निर्णय: अगर सभी शर्तें 8 या उससे ज़्यादा हैं, तो "FINAL" आउटपुट करें और रुकें। नहीं तो, "ITERATING" आउटपुट करें और सबसे कम स्कोर वाली चीज़ को ठीक करके दोहराएँ।
16
17【नियम】
18
19जब तक सभी शर्तें 8 या उससे ज़्यादा न हों, "पूरा" न कहें।
20हर चक्र में, आपको पिछली बार सबसे कम स्कोर वाली चीज़ को ठीक करना होगा।
21मुझसे सवाल न पूछें। उचित धारणाएँ बनाएँ, उन्हें नोट करें, और आगे बढ़ें।
22कृपया शुरू करें। "FINAL" आउटपुट होने तक लूप करें।

इसे पेस्ट करके देखें, आप खुद देख लेंगे। AI पहला ड्राफ्ट बनाता है, आपकी शर्तों के आधार पर खुद को ग्रेड करता है, कमज़ोरियाँ ढूँढता है, और फिर से लिखता है। यह तब तक दोहराता है जब तक वह मानक से आगे नहीं निकल जाता। वह आम व्यवहार—जहाँ वह बस पहली चीज़ थमा देता है जो ठीक-ठाक लगती है—गायब हो जाता है।

आप यह पूरी प्रक्रिया एक पैराग्राफ में बना सकते हैं।

हालाँकि, कुछ अभी भी गायब है

इस लूप में एक गंभीर खामी है: ट्रिगर आप हैं।

आपको चैट खोलनी है, उसे पेस्ट करना है, और देखते रहना है। अगर आप टैब बंद कर देते हैं, तो वह खत्म। यह तय समय पर नहीं चलेगा, और ईमेल आते ही नहीं जागेगा। यह तभी मौजूद है जब आप देख रहे हैं, इसलिए यह आपको सूचित करने नहीं आ सकता।

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

सच में भारी काम के लिए, यह एक सही निवेश है। लेकिन रोज़मर्रा के 90% कामों के लिए, आपको इतना ज़्यादा नहीं चाहिए। अभी के लिए, आपके पास पहले से मौजूद टूल्स के साथ जुड़ी शेड्यूल्ड एक्ज़ीक्यूशन सुविधाएँ ही काफी हैं। Claude Code के /loop और /goal, या शेड्यूल्ड रन। ये कोई नए कॉन्ट्रैक्ट नहीं हैं; वे पहले से आपके हाथ में हैं।

सारांश

• लूप का मतलब है AI को एक लक्ष्य, पूरा होने का फैसला करने का पैमाना, और हार मानने के नियम देना।
• दिल है निरीक्षण। अगर असफल होने के लिए कोई गेट नहीं है, तो वह लूप नहीं है।
• तब तक न बनाएँ जब तक कि: काम हफ्ते में दोहराया जाता हो, अपने आप अस्वीकार किया जा सकता हो, AI उसे पूरा कर सकता हो, और निष्पक्ष रूप से जाँचा जा सकता हो।
• हर चक्र के साथ लागत बढ़ती है। देखने वाला मीट्रिक प्रति स्वीकृत नतीजे की लागत है। 50% से कम स्वीकृति दर घाटा है।
• क्रम है: मैनुअल सफलता → स्किल → लूप → स्वचालित निष्पादन।
• अगर आपको भारी वर्ज़न नहीं चाहिए, तो ऊपर वाले एक प्रॉम्प्ट से शुरुआत करना काफी है।

लूप कोई फैशन नहीं हैं; वे इस बात में बदलाव हैं कि काम कौन करता है। हालाँकि, वे अंधाधुंध पीछा करने की चीज़ नहीं हैं। अगर गलत जगह थोप दिए जाएँ, तो वे सिर्फ़ पैसा गायब कर देते हैं। उन्हें उन मुफ्त टूल्स के साथ चलाएँ जो आपके पास पहले से हैं, और अगला कदम तभी सोचें जब आप खुद महसूस करें कि वे काफी नहीं हैं।

संदर्भ लेख

यह लेख निम्नलिखित के आधार पर जापानी में पुनर्निर्मित किया गया था:

Loops explained: Claude, GPT, Mira and what actually works

Anatoli Kopadze / 2026-06-20

https://x.com/AnatoliKopadze/status/2068328135611822149