Anthropic के इंजीनियर्स AI लूप्स का उपयोग करके अपने दैनिक कोड आउटपुट को 8 गुना बढ़ा रहे हैं

Anthropic अपने इंजीनियरों को $80,000 प्रति माह का भुगतान करती है। वे इंजीनियर अब एक साल पहले की तुलना में प्रतिदिन 8 गुना अधिक कोड मर्ज करते हैं। ऐसा इसलिए नहीं है कि मॉडल अधिक स्मार्ट हो गया है। बल्कि इसलिए क्योंकि उन्होंने Claude को प्रॉम्प्ट देना बंद कर दिया है और ऐसे सिस्टम बनाना शुरू कर दिया है जो उनके लिए Claude को प्रॉम्प्ट करते हैं।

Anthropic में Claude Code के प्रमुख, Brian Cherny कहते हैं: "मैं अब Claude को प्रॉम्प्ट नहीं देता। मेरे पास लूप (loops) चल रहे हैं जो Claude को प्रॉम्प्ट करते हैं और तय करते हैं कि क्या करना है। मेरा काम लूप लिखना है।"

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

लूप वास्तव में क्या है

एक प्रॉम्प्ट एक एकल निर्देश है। एक लूप एक ऐसा लक्ष्य है जिस पर AI तब तक काम करता रहता है जब तक वह उसे प्राप्त न कर ले।

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

1Prompt      |  आप टाइप करते हैं, Claude जवाब देता है, आप फिर से टाइप करते हैं
2Loop        |  सिस्टम काम ढूंढता है, Claude निष्पादित करता है,
3            |  सिस्टम परिणाम की जांच करता है, पूरा होने तक दोहराता है

हर वास्तविक लूप के पांच चरण होते हैं:

1Discover    |  पता लगाएं कि क्या करने की आवश्यकता है
2Plan        |  तय करें कि इसे कैसे करना है
3Execute     |  काम करें
4Verify      |  लक्ष्य के विरुद्ध जांचें
5Iterate     |  पूरा नहीं हुआ? परिणाम वापस फीड करें और फिर से शुरू करें

इनमें से तीन चरण सारा वास्तविक काम करते हैं।

Verify (सत्यापन) इसका हृदय है। परिणाम की वास्तविक जांच के बिना आपके पास लूप नहीं है - आपके पास एक एजेंट है जो बार-बार खुद से सहमत हो रहा है। जांच वस्तुनिष्ठ (objective) होनी चाहिए। एक ऐसा टेस्ट जो पास या फेल हो। एक बिल्ड जो कंपाइल हो या न हो। एक लिंटर जो शून्य या गैर-शून्य रिटर्न करे। न कि कोई दूसरा एजेंट जिसे "समीक्षा" करने के लिए कहा गया हो। दो आशावादियों का सहमत होना सत्यापन नहीं है।

State (स्थिति) वह है जो लूप को सीखने में मदद करती है। हर बार AI को यह याद रखना होगा कि उसने पहले क्या कोशिश की है, वरना वह हमेशा वही गलती दोहराएगा। एक वास्तविक लूप बातचीत के बाहर एक रिकॉर्ड रखता है - क्या हो गया है, क्या विफल रहा, आगे क्या है। एजेंट सत्रों के बीच भूल जाता है। फाइल नहीं भूलती।

एक स्टॉप कंडीशन (रोकने की शर्त) वह है जो इसे सुरक्षित रखती है। बिना निकास वाला लूप तब तक चलता है जब तक वह सफल न हो जाए, टूट न जाए या आपका बजट खत्म न कर दे। हर गंभीर लूप के रुकने के दो तरीके होते हैं - सफलता, और एक हार्ड लिमिट। इसके बिना आपने एक ऐसी मशीन बनाई है जो चुपचाप आपसे पैसे वसूलती है।

कुछ भी बनाने से पहले 4-शर्तों वाला टेस्ट

एक लूप अपनी लागत तभी वसूल करता है जब ये चारों बातें सच हों। एक भी चूक जाए तो उसे मैन्युअल प्रॉम्प्ट ही रहने दें।

1Condition 1  |  कार्य कम से कम साप्ताहिक रूप से दोहराया जाता है
2             |  साप्ताहिक से कम - सेटअप लागत कभी वसूल नहीं होगी
3
4Condition 2  |  कोई स्वचालित रूप से खराब आउटपुट को अस्वीकार कर सकता है
5             |  एक टेस्ट, बिल्ड, लिंटर, टाइप चेक
6             |  कोई स्वचालित गेट नहीं - आप हर डिफ (diff) की समीक्षा कर रहे होंगे
7
8Condition 3  |  एजेंट काम को शुरू से अंत तक कर सकता है
9             |  काम के बीच में आधा काम आपको वापस नहीं सौंपता
10
11Condition 4  |  'पूरा होना' वस्तुनिष्ठ है, न कि कोई निर्णय
12             |  यदि गुणवत्ता पसंद का मामला है, तो इंसान ही जीतता है

अच्छे शुरुआती लूप:

1CI विफलता ट्राइएज      |  रात में, विफलताओं को वर्गीकृत करें, फिक्स ड्राफ्ट करें
2डिपेंडेंसी अपडेट्स      |  साप्ताहिक, अपडेट स्कैन करें, PR खोलें
3लिंट-एंड-फिक्स पास    |  हर PR पर, स्टाइल फिक्स स्वचालित रूप से लागू करें
4इश्यू-टू-PR ड्राफ्ट्स    |  मजबूत टेस्ट कवरेज वाले कोडबेस पर

बुरे शुरुआती लूप - इंसान को नियंत्रण में रखें:

1आर्किटेक्चर रीराइट्स  |  निर्णय का मामला, लूप भटक जाएगा
2Auth या भुगतान कोड  |  अपरिवर्तनीय गलतियां बहुत महंगी हैं
3प्रोडक्शन डिप्लॉय      |  मानवीय अनुमोदन गेट की आवश्यकता है
4अस्पष्ट प्रोडक्ट वर्क     |  'पूरा होना' वस्तुनिष्ठ नहीं है

पांच बिल्डिंग ब्लॉक्स

हर काम करने वाला लूप पांच भागों से बना होता है। Claude Code इन पांचों के साथ आता है।

1 - ऑटोमेशन (धड़कन)

यही वह चीज है जो लूप को एक वास्तविक लूप बनाती है, न कि केवल एक बार किया गया रन। एक ट्रिगर शेड्यूल या इवेंट पर फायर होता है, कार्य को Claude को सौंपता है और आपके जांच किए बिना निष्कर्ष वापस लाता है।

1/loop     |  एक प्रॉम्प्ट को निश्चित अंतराल पर फिर से चलाता है
2/goal     |  तब तक चलता रहता है जब तक आपके द्वारा लिखी गई शर्त सच न हो जाए
3hooks     |  एजेंट लाइफसाइकिल के बिंदुओं पर कमांड फायर करते हैं
4cron      |  GitHub Actions के माध्यम से लैपटॉप बंद करने के बाद चलता है

सबसे महत्वपूर्ण /goal है। एक अलग छोटा मॉडल जांचता है कि शर्त पूरी हुई है या नहीं - ताकि जिस एजेंट ने कोड लिखा है, वह उसे ग्रेड न दे।

1/loop 30m /goal "test/auth में सभी टेस्ट पास हैं और लिंट साफ है।"
2विफलताओं के लिए src/auth स्कैन करें, फिक्स ड्राफ्ट करें, लक्ष्य पूरा होने पर PR खोलें।

2 - स्किल्स (प्रोजेक्ट ज्ञान एक बार लिखें)

एक स्किल वह तरीका है जिससे आप हर सत्र में एक ही प्रोजेक्ट संदर्भ को बार-बार समझाना बंद करते हैं। एक SKILL.md फाइल उन निर्देशों, सम्मेलनों और नियमों को रखती है जिन्हें लूप हर रन पर पढ़ता है।

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

1skills/
2  ci-triage.md   - वर्गीकरण नियम, फिक्स पैटर्न, एस्केलेशन मानदंड
3  frontend.md    - Tailwind, Next.js, SEO, एक्सेसिबिलिटी नियम
4  security.md    - auth पैटर्न, इनपुट वैलिडेशन, नेवर-टच लिस्ट
5  deps.md        - अपडेट नियम, संगतता जांच, रोलबैक पैटर्न

ऑटोमेशन स्किल को नाम से कॉल करता है। आवर्ती कार्य (recurring job) बनाए रखने योग्य रहता है, बजाय इसके कि वह किसी ऐसे शेड्यूल के अंदर सड़ जाए जिसे कोई अपडेट नहीं करता।

3 - सब-एजेंट्स (मेकर को चेकर से दूर रखें)

किसी भी लूप में सबसे उपयोगी संरचनात्मक चीज। लिखने वाले एजेंट को जांचने वाले एजेंट से अलग करें।

जिस मॉडल ने कोड लिखा है, वह अपने काम को ग्रेड देने में बहुत उदार होता है। अलग-अलग निर्देशों वाला एक दूसरा एजेंट - और कभी-कभी एक मजबूत मॉडल - वह पकड़ लेता है जिसके लिए पहले वाले ने खुद को मना लिया था।

1मेकर एजेंट     |  तेज सस्ता मॉडल - खोजता है, लागू करता है, ड्राफ्ट करता है
2चेकर एजेंट   |  मजबूत मॉडल, उच्च प्रयास - समीक्षा करता है, सत्यापित करता है, अस्वीकार करता है

1.claude/agents/
2  explorer.md      |  रीड-ओनली, तेज मॉडल, पता लगाता है कि क्या करने की आवश्यकता है
3  implementer.md   |  फिक्स लिखता है, टेस्ट चलाता है
4  reviewer.md      |  सुरक्षा ऑडिट, कोड गुणवत्ता, वस्तुनिष्ठ गेट

एक मॉडल। तीन विशेषज्ञ। लूप तब चलता है जब आप देख नहीं रहे होते हैं और वेरिफायर ही एकमात्र कारण है कि आप वास्तव में दूर जा सकते हैं।

4 - कनेक्टर्स (ताकि यह कार्य करे, सुझाव न दे)

एक ऐसे लूप के बीच का अंतर जो कहता है "यह रहा फिक्स" और एक लूप जो PR खोलता है, टिकट लिंक करता है और CI ग्रीन होने पर Slack पर पिंग करता है।

1GitHub    |  रेपो पढ़ें, ब्रांच बनाएं, PR खोलें, वेबहुक पर प्रतिक्रिया दें
2Linear    |  टिकट अपडेट करें, PR लिंक करें, सत्यापन पास होने पर आइटम बंद करें
3Slack     |  ट्राइएज परिणाम पोस्ट करें, एस्केलेशन पर इंसानों को पिंग करें
4Sentry    |  लाइव अलर्ट की जांच करें, उच्च-आवृत्ति वाले अलर्ट के लिए फिक्स ड्राफ्ट करें

कनेक्टर्स के बिना लूप वर्णन करता है कि वह क्या करेगा। कनेक्टर्स के साथ वह इसे कर देता है।

5 - स्टेट फाइल (एजेंट भूल जाता है। फाइल नहीं भूलती।)

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

1# लूप स्टेट - ci-triage
2
3## पिछला रन
42026-06-09 03:30 UTC - 7 विफलताओं को वर्गीकृत किया गया, 3 फिक्स ड्राफ्ट किए गए, 4 एस्केलेट किए गए
5
6## प्रगति पर
7- claude/fix-auth-token-refresh - टेस्ट स्थानीय रूप से पास हो रहे हैं, CI की प्रतीक्षा है
8
9## आज पूरा हुआ
10- claude/bump-axios-1.7.4 - मर्ज किया गया, CI ग्रीन
11
12## इंसानों को एस्केलेट किया गया
13- src/billing/refund.ts - टेस्ट 3 तरीकों से विफल हो रहे हैं, मूल कारण स्पष्ट नहीं है
14
15## सीखे गए सबक
16- 2026-06-08: PowerShell विंडोज रनर पर TLS समस्या का सामना करता है। bash का उपयोग करें।
17- 2026-06-07: tests/e2e/checkout के लिए Stripe वेबहुक सीक्रेट की आवश्यकता है। यदि गायब हो तो छोड़ दें।

कल का रन इस फाइल को पढ़ता है और फिर से शुरू होता है। इसके बिना हर रन शून्य से शुरू होता है।

एक वास्तविक लूप कैसा दिखता है

CI विफलता ट्राइएज - सबसे अच्छे शुरुआती लूपों में से एक क्योंकि सत्यापन स्वचालित है और खराब आउटपुट का जोखिम कम है।

1ट्रिगर     |  रात 3 बजे या CI विफलता इवेंट पर
2स्किल       |  ci-triage.md
3स्टेट रीड  |  STATE.md - कल क्या विफल हुआ, क्या ठीक किया गया

लूप चलता है:

1Step 1  |  कनेक्टर के माध्यम से GitHub से CI विफलताओं को पढ़ता है
2Step 2  |  प्रत्येक को वर्गीकृत करता है: env / flake / bug / dependency / infra
3Step 3  |  प्रत्येक ठीक करने योग्य विफलता के लिए - वर्कट्री खोलता है, इम्प्लीमेंटर एजेंट भेजता है
4Step 4  |  रिव्यूअर एजेंट टेस्ट और सुरक्षा नियमों के खिलाफ फिक्स की जांच करता है
5Step 5  |  गेट पास - PR खोलता है और Linear टिकट लिंक करता है
6Step 6  |  गेट फेल - मानव ट्राइएज इनबॉक्स में एस्केलेट करता है
7Step 7  |  STATE.md अपडेट करता है
8Step 8  |  Slack पर रात भर का सारांश पोस्ट करता है

सुबह आप एक Slack संदेश, केवल कठिन समस्याओं वाले ट्राइएज इनबॉक्स और उन PRs के सेट के साथ जागते हैं जो पहले ही स्वचालित समीक्षा पास कर चुके हैं। आपने एक भी स्टेप प्रॉम्प्ट नहीं किया।

वह लूप जो पूरे व्यवसाय में कंपाउंड होता है

सबसे शक्तिशाली संस्करण एक लूप नहीं है। यह कई लूप हैं जो एक साझा आर्टिफैक्ट सिस्टम में लिख रहे हैं ताकि वे एक-दूसरे से सीख सकें।

SuperDesign में उनके लूप सपोर्ट, SEO, प्रोडक्ट ग्रोथ और विज्ञापनों को कवर करते हैं। प्रत्येक का अपना ट्रिगर और वर्कफ़्लो है। लेकिन वे सभी एक ही साझा सिग्नल स्टोर में लिखते हैं।

सपोर्ट लूप पांच उपयोगकर्ताओं को यह पूछते हुए नोटिस करता है कि कुछ एक्सपोर्ट कैसे करें। यह एक सिग्नल बनाता है:

1kind: signal
2title: एक्सपोर्ट ढूंढना बहुत कठिन है
3frequency: 5
4category: friction
5tags: [feedback, pricing, conversion]

SEO लूप मजबूत ट्रैफ़िक लेकिन खराब रूपांतरण वाले पेज को नोटिस करता है। एक और सिग्नल बनाता है। प्रोडक्ट ग्रोथ लूप एनालिटिक्स के साथ-साथ दोनों सिग्नलों को पढ़ता है और पहचानता है कि एक्सपोर्ट फ्रिक्शन कच्चे डेटा द्वारा सुझाए गए से बड़ा है - क्योंकि अब दो स्वतंत्र स्रोत एक ही समस्या की पुष्टि करते हैं। विज्ञापन लूप एक कीवर्ड गैप ढूंढता है और इसे सीधे SEO लूप में फीड करता है।

1सपोर्ट लूप   |  फ्रिक्शन ढूंढता है, सिग्नल लिखता है
2SEO लूप       |  कंटेंट गैप ढूंढता है, सिग्नल लिखता है
3प्रोडक्ट लूप   |  दोनों सिग्नल पढ़ता है, प्राथमिकता की पहचान करता है
4विज्ञापन लूप   |  कीवर्ड गैप ढूंढता है, SEO लूप को फीड करता है

इनमें से कोई भी लूप अलग-थलग ऑटोमेशन नहीं है। वे इस बात के साझा ज्ञान आधार से काम करते हैं कि व्यवसाय क्या सीख रहा है। प्रत्येक लूप हर दूसरे लूप को स्मार्ट बनाता है। यही कंपाउंडिंग है।

वे विफलताएं जिनके बारे में कोई आपको चेतावनी नहीं देता

राल्फ विगम लूप। एक एजेंट जिसका मतलब केवल पूरा होने पर संकेत देना है, वह जल्दी संकेत दे देता है। लूप आधे-अधूरे काम पर बाहर निकल जाता है और कुछ भी पैदा किए बिना चलता रहता है और बिल बनाता रहता है। फिक्स: एक हार्ड गेट जो वस्तुनिष्ठ रूप से काम को विफल कर सकता है, न कि एक सॉफ्ट "मुझे अच्छा लग रहा है।"

लंबे सत्रों में लक्ष्य का भटकना। टर्न 47 तक बाधाएं गायब हो जाती हैं क्योंकि संदर्भ खुद को सारांशित करता है। फिक्स: एक स्थायी AGENTS.md जिसे एजेंट हर रन की शुरुआत में फिर से पढ़ता है।

समझ का कर्ज। लूप जितनी तेजी से वह कोड शिप करता है जिसे आपने नहीं लिखा, उतना ही बड़ा अंतर उस चीज के बीच होता है जो मौजूद है और जिसे आप समझते हैं। जो बिल दुख देता है वह टोकन बिल नहीं है। वह दिन है जब आप एक ऐसे सिस्टम को डिबग करते हैं जिसे टीम में किसी ने नहीं पढ़ा है। फिक्स: लूप द्वारा खोले गए हर डिफ को पढ़ें।

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

टोकन लागत जो कंपाउंड होती है। हर लूप इटरेशन पूरे संदर्भ को फिर से पढ़ता है और ढेर हर पास के साथ बढ़ता है। स्वीकृत परिवर्तन प्रति लागत ट्रैक करें। 50% स्वीकृति दर से नीचे लूप बचाने से ज्यादा खर्च करता है।

बिल्ड ऑर्डर जो वास्तव में काम करता है

जो कोई भी ऐसे लूप शिप करता है जो प्रोडक्शन में जीवित रहते हैं, वे इसे एक ही तरह से करते हैं:

1Step 1  |  पहले एक मैन्युअल रन को विश्वसनीय बनाएं
2Step 2  |  इसे एक स्किल में बदलें - निर्देशों को SKILL.md में सहेजें
3Step 3  |  स्किल को लूप में लपेटें - गेट और स्टॉप कंडीशन जोड़ें
4Step 4  |  फिर इसे शेड्यूल पर रखें

किसी ऐसी चीज को शेड्यूल करना जिसे आपने हाथ से विश्वसनीय नहीं बनाया है, वही तरीका है जिससे लूप आपके सोते समय फट जाते हैं। इसे एक बार साबित करें। इसे मजबूत करें। फिर इसे स्वचालित करें।

जो मीट्रिक मायने रखता है वह खर्च किए गए टोकन या प्रयास किए गए कार्य नहीं हैं। यह स्वीकृत परिवर्तन प्रति लागत है। यदि लूप आपको दस परिणाम देता है और आप छह को अस्वीकार करते हैं, तो आप वह समीक्षा कार्य कर रहे हैं जिसे इसे बचाने के लिए माना गया था।

वह बदलाव जो पहले ही हो चुका है

2024 में लीवरेज प्रॉम्प्ट पर था। बेहतर प्रॉम्प्ट, बेहतर आउटपुट, बेहतर डेवलपर। 2026 में लीवरेज एक मंजिल ऊपर है - वह सिस्टम जो तय करता है कि Claude किस पर काम करता है, कब, किस गेट के साथ और रन के बीच क्या स्टेट बचती है।

Anthropic इंजीनियर प्रतिदिन 8 गुना अधिक कोड मर्ज करते हैं, इसलिए नहीं कि उन्हें Claude से सवाल पूछने का बेहतर तरीका मिल गया। बल्कि इसलिए क्योंकि उन्होंने सवाल पूछना बंद कर दिया और ऐसे सिस्टम बनाना शुरू कर दिया जो उनकी ओर से Claude से सवाल पूछते हैं - लगातार, रात भर, जब वे सोते हैं।

लूप काम को आसान नहीं बनाता। यह उस जगह को बदल देता है जहाँ काम होता है। प्रॉम्प्ट टाइप करने से लेकर उस सिस्टम को डिजाइन करने तक जो प्रॉम्प्ट टाइप करता है। टूल पकड़ने से लेकर फैक्ट्री बनाने तक।

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