लूप इंजीनियरिंग: एक ऐसा AI बनाएं जो आपके सोते समय कोडिंग करे

पिछले दिसंबर में, बोरिस चेर्नी ने एक महीने में 259 पुल रिक्वेस्ट शिप कीं। हर एक क्लॉड द्वारा लिखा गया था। उनका कहना है कि उन्होंने पूरे समय एक एडिटर भी नहीं खोला।

उनका काम कोड लिखना नहीं था। उनका काम वह चीज़ लिखना था जो कोड लिखती है। पीटर स्टीनबर्गर ने इसे दो पंक्तियों में कहा, जिसे 8 मिलियन से अधिक बार देखा जा चुका है: "अब आपको कोडिंग एजेंटों को प्रॉम्प्ट नहीं करना चाहिए। आपको ऐसे लूप डिज़ाइन करने चाहिए जो आपके एजेंटों को प्रॉम्प्ट करें।"

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

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

एक प्रश्न तय करता है कि आपने कौन सा लूप बनाया: क्या यह किसी सत्य पर अभिसरित होता है, या यह सिर्फ एक महँगा यादृच्छिक चलना (रैंडम वॉक) है?

1. एक लूप छह टुकड़े और एक प्रश्न है

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

अब आप इनमें से कुछ भी हाथ से नहीं बनाते। एक साल पहले लूप का मतलब शेल स्क्रिप्ट का ढेर था जिसे आप खुद संभालते थे और हमेशा देखभाल करते थे। अब ये टुकड़े उत्पादों के अंदर शिप होते हैं, और वही छह ओपनएआई Codex ऐप और क्लॉड कोड दोनों पर मैप होते हैं। एक बार जब आप इसे देख लेते हैं, तो उपकरण बहस का विषय नहीं रह जाता और लूप डिज़ाइन बन जाता है।

1PIECE          JOB IN THE LOOP           CODEX                      CLAUDE CODE
2-------------  ------------------------  -------------------------  --------------------------
3State          remember across runs      markdown / Linear (MCP)    markdown / Routines + MCP
4Automations    run on a schedule         Automations tab + Triage   /loop (skill), Routines, /goal
5Worktrees      isolate parallel agents   Worktree per thread        --worktree, isolation: worktree
6Skills         codify your intent        ~/.agents/skills/SKILL.md   ~/.claude/skills/SKILL.md
7Connectors     touch your real tools     MCP servers (config.toml)  MCP servers (.mcp.json)
8Sub-agents     split maker from checker  TOML in .codex/agents/     .claude/agents/ + agent teams

2. स्टेट (State) ही एकमात्र ऐसी चीज़ है जो अगले रन को विरासत में मिलती है

नीचे से शुरू करें, क्योंकि बाकी सब कुछ इसी पर टिका है।

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

व्यवहार में यह एक फ़ाइल है। रिपॉजिटरी में एक STATUS.md या एक कनेक्टर के माध्यम से पहुँचा जाने वाला लीनियर बोर्ड, जिसमें यह होता है कि क्या हो चुका है, क्या प्रगति पर है, आगे क्या है, और उन कुछ चीज़ों का उल्लेख जिन्हें लूप को कभी नहीं छूना चाहिए।

1# STATUS.md  (लूप इसे पहले पढ़ता है, अंत में लिखता है)
2## Done
3- [x] auth: migrated to tokens v2, tests green
4## In progress
5- [ ] billing: webhook refactor (PR #214, CI red)
6## Next
7- [ ] dashboard: flaky test in test/charts
8## Never
9- do not modify infra/ without a human

लूप को ऐसे समझें जैसे कोई नाइट शिफ्ट जिसे आप कभी नहीं देखते। आपको इस बात से नहीं आंका जाता कि उसने रात 3 बजे क्या किया। आपको उस नोट से आंका जाता है जो सुबह नौ बजे आपकी मेज़ पर पड़ा होता है। पहले उस नोट को डिज़ाइन करें और अधिकांश लूप खुद को डिज़ाइन कर लेगा।

3. ऑटोमेशन (Automations) ही लूप और एक बार चलाई गई चीज़ के बीच का अंतर है

एक लूप तभी नाम कमाता है जब वह अपने आप चले।

Codex ऐप में आप Automations टैब में एक बनाते हैं: रिपॉजिटरी, प्रॉम्प्ट, कैडेंस। जो रन कुछ ढूंढते हैं वे Triage इनबॉक्स में आते हैं; जो रन कुछ नहीं ढूंढते वे खुद को आर्काइव कर लेते हैं। OpenAI इसका उपयोग कोडबेस की अप्रतिष्ठित रीढ़ के लिए करता है: दैनिक इश्यू ट्राइएज, CI-विफलता सारांश, पिछले सप्ताह की गई बग को पकड़ना।

क्लॉड कोड कुछ आदिम तत्वों के माध्यम से वहाँ पहुँचता है, और लोकप्रिय लेखों में अक्सर विवरण गलत होते हैं, इसलिए सटीक होना उचित है। /loop एक स्किल है, कोई बिल्ट-इन कमांड नहीं, और यह आपके सत्र के खुले रहने पर एक कैडेंस पर एक प्रॉम्प्ट को फिर से चलाता है। आवर्ती क्लाउड जॉब्स Routines हैं, जो /schedule के साथ सेट की जाती हैं, जिनमें न्यूनतम एक घंटा होता है, और वे आपके लैपटॉप के बंद होने पर भी चलती रहती हैं। कोई स्थानीय क्रॉन्टैब नहीं है।

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

1# क्लॉड कोड: तब तक चलाएं जब तक यह वास्तव में समाप्त न हो जाए, न कि जब तक यह समाप्त महसूस हो
2/goal all tests in test/auth pass and the lint step is clean
3
4# क्लॉड कोड: एक आवर्ती क्लाउड जॉब (न्यूनतम 1 घंटा)
5/schedule daily PR triage at 9am
6
7# Codex: एक ऑटोमेशन प्रॉम्प्ट (कैडेंस को फॉर्म में सेट करें)
8"Weekdays 9am: scan open PRs, flag failing CI or no reviewer, post to Triage."

स्टॉप कंडीशन को एक अनुबंध की तरह लिखें। "test/auth के सभी टेस्ट पास हों" एक अनुबंध है। "इसे बेहतर बनाएं" वह तरीका है जिससे एक लूप पेडे तक चलता है।

4. वर्कट्री (Worktrees) समानांतर एजेंटों को एक-दूसरे के रास्ते से दूर रखते हैं

जैसे ही आप एक से अधिक एजेंट चलाते हैं, विफलता मोड बदल जाता है। यह अब मॉडल नहीं है। यह दो एजेंट हैं जो एक ही फ़ाइल लिख रहे हैं, वही गड़बड़ी जैसे दो इंजीनियर बिना बात किए एक ही लाइनों पर कमिट कर रहे हों।

गिट वर्कट्री उनके बीच की दीवार है: अपनी खुद की ब्रांच पर एक अलग वर्किंग डायरेक्टरी, जो रेपो हिस्ट्री साझा करती है, ताकि एक एजेंट के संपादन दूसरे के चेकआउट तक न पहुँच सकें।

1# क्लॉड कोड: प्रति एजेंट एक अलग चेकआउट
2claude --worktree feature-auth
3
4# या उप-एजेंट पर, .claude/agents/<name>.md फ्रंटमैटर में:
5#   isolation: worktree
6
7# Codex: थ्रेड खोलते समय "Worktree" चुनें (प्रत्येक का एक डिटैच्ड HEAD होता है)

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

5. स्किल्स (Skills) आपका इरादा हैं, एक बार लिखा गया, बाहर की तरफ

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

दोनों उपकरणों पर प्रारूप समान है: निर्देशों और एक विवरण के साथ एक SKILL.md फ़ोल्डर, साथ ही कोई भी स्क्रिप्ट जिसकी आवश्यकता है। यह तब फायर करता है जब आप इसे नाम से कॉल करते हैं या जब आपका कार्य इसके विवरण से मेल खाता है, यही कारण है कि एक सपाट, शाब्दिक विवरण एक चतुर विवरण से बेहतर है।

1# .claude/skills/triage/SKILL.md   (Codex: ~/.agents/skills/triage/SKILL.md)
2---
3name: triage
4description: कल की CI विफलताओं, खुले इश्यू और हाल के कमिट्स को पढ़ें;
5  प्रत्येक निष्कर्ष को STATUS.md में एक कार्य के रूप में लिखें।
6---
71. विफल CI को खींचें और मूल कारण के आधार पर समूहित करें।
82. प्रत्येक को उस खुले इश्यू या कमिट से मिलाएँ जिसके कारण यह हुआ।
93. प्रति वास्तविक निष्कर्ष एक STATUS.md कार्य लिखें। शोर को छोड़ दें।

स्किल्स के बिना, हर चक्र आपके प्रोजेक्ट को शुरू से सीखता है। उनके साथ, लूप हर सुबह थोड़ा और तेज हो जाता है।

6. कनेक्टर्स (Connectors) लूप को सिर्फ बात करने के बजाय कार्य करने देते हैं

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

1# क्लॉड कोड
2claude mcp add --transport http linear https://mcp.linear.app/mcp
3
4# Codex
5codex mcp add linear --url https://mcp.linear.app/mcp

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

7. उप-एजेंट (Sub-agents) मेकर को चेकर से दूर रखते हैं

किसी भी लूप में सबसे मूल्यवान कदम उस एजेंट को विभाजित करना है जो लिखता है और जो जाँचता है।

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

1# Codex: .codex/agents/reviewer.toml
2name = "reviewer"
3description = "प्रतिकूल PR समीक्षक: शुद्धता, सुरक्षा, लापता परीक्षण।"
4developer_instructions = "एक मालिक की तरह समीक्षा करें। मान लें कि लेखक गलत है
5  जब तक कि डिफ़ अन्यथा साबित न करे।"
6model_reasoning_effort = "high"
7
8# क्लॉड कोड: .claude/agents/reviewer.md फ्रंटमैटर
9#   name: reviewer
10#   description: प्रतिकूल समीक्षक। किसी भी कोड परिवर्तन के बाद उपयोग करें।
11#   model: opus

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

8. एक लूप कैसा दिखता है

छह को एक साथ रखें और एक एकल थ्रेड एक छोटी मशीन बन जाता है।

एक निर्धारित ऑटोमेशन हर सुबह रिपॉजिटरी पर चलता है। यह आपके ट्राइएज स्किल को कॉल करता है, जो रात भर की CI विफलताओं, खुले इश्यू और हाल के कमिट्स को पढ़ता है, और प्रत्येक वास्तविक निष्कर्ष को STATUS.md में लिखता है। हर उस निष्कर्ष के लिए जो करने लायक है, लूप एक अलग वर्कट्री खोलता है, एक उप-एजेंट को फिक्स का मसौदा तैयार करने और दूसरे को आपकी स्किल्स और आपके परीक्षणों के विरुद्ध इसकी समीक्षा करने के लिए भेजता है। कनेक्टर्स PR खोलते हैं और टिकट अपडेट करते हैं। जो कुछ भी यह संभाल नहीं सकता वह आपके ट्राइएज इनबॉक्स में प्रतीक्षा करता है। STATUS.md याद रखता है कि क्या पास हुआ और क्या अभी भी खुला है, ताकि कल वहीं से शुरू हो जहाँ आज रुका था।

जब आप जागते हैं तो आपको वास्तव में लॉग की दीवार के बजाय एक छोटा सा हैंडऑफ़ दिखता है:

1# 9:00am — लूप का रात भर का हैंडऑफ़ (आपका ट्राइएज इनबॉक्स)
2READY TO MERGE
3  PR #218  fix flaky test in test/charts          CI green
4  PR #219  retry webhook on 429, add backoff test  CI green
5NEEDS YOU
6  auth/session.ts  दो सुरक्षित तरीके हैं इसे ठीक करने के; मैंने कोई नहीं चुना, आपका फैसला
7QUIET
8  7 निर्धारित रनों में कुछ नहीं मिला और उन्होंने खुद को आर्काइव कर लिया

आपने इसे एक बार डिज़ाइन किया। आपने इसका कुछ भी प्रॉम्प्ट नहीं किया।

9. जाने से पहले ब्रेक लगाएँ

यह वह आधा हिस्सा है जो कोई नहीं सिखाता, और यह तय करता है कि आपका लूप एक संपत्ति है या देयता।

वह $47,000 का बिल कोई चालाक मॉडल नहीं था जो बिगड़ गया। यह दो एजेंट थे, एक विश्लेषक और एक सत्यापनकर्ता, प्रत्येक विनम्रता से दूसरे से और काम माँग रहा था, बिना किसी चरण सीमा, बिना बजट सीमा, और बिना किसी रोक की स्थिति के। यह ग्यारह दिन चला। एक कैप ने इसे पहले ही मार दिया होता।

हॉर्सपावर से पहले ब्रेक लगाएँ। जब तक आपने ब्रेक पेडल शिप नहीं किया तब तक इंजन को शिप न करें।

1# जाने से पहले इन्हें लगाएँ:
2- step cap:        --max-turns 50            (कठोर रोक, कोई अपवाद नहीं)
3- budget ceiling:  claude -p --max-budget-usd 10   (प्रिंट मोड; प्रति चरण)
4- blast radius:    एक वर्कट्री, एक ब्रांच, src/ के बाहर केवल पढ़ने योग्य
5- circuit breaker: एक ही उपकरण + एक ही आर्ग्युमेंट लगातार 3 बार = रुक जाएँ
6- dead-man check:  हर रन में STATUS.md में एक हार्टबीट लिखें; चुप्पी आपको पेज करे

एक लूप का दायरा इस बात से तय करें कि यह क्या नष्ट कर सकता है, न कि आप इससे क्या करवाना चाहते हैं: कौन सी रिपॉजिटरी, कौन सी ब्रांच, कितने डॉलर, कितने कदम इसके फोर्स-क्विट करने से पहले। पहले ब्लास्ट रेडियस चुनें, फिर कार्य।

और इसकी कीमत ईमानदारी से लगाएँ। स्टीनबर्गर का सौ एजेंटों का बेड़ा वास्तविक है, और यह लगभग $1.3 मिलियन प्रति माह चलता है। यह काम करता है क्योंकि OpenAI अब उन्हें नियोजित करता है और बिल का भुगतान करता है। फ्रंटियर केस प्रायोजित है। आपका नहीं है। $20 से $200 योजना पर, जो लूप भुगतान करता है वह छोटा, सीमित और एक उबाऊ काम पर लगा होता है, न कि झुंड पर।

1लागत का प्रसार (सभी वास्तविक, सभी पिछले छह महीनों से)
2-----------------------------------------------------------------
330 दिनों में 259 PRs     एक इंजीनियर, 100% क्लॉड द्वारा लिखित
4$47,000 11 दिनों में      एक बेलगाम लूप बिना किसी कैप के, कोई नहीं देख रहा
5~$1.3M प्रति माह          एक 100-एजेंट बेड़ा (बिल प्रायोजित है)
6-----------------------------------------------------------------
7एक ही तकनीक। अंतर ब्रेक का है।

10. लूप कैसे मरते हैं

हर लूप जो विफल होता है, वह चार मौतों में से एक मरता है। अब नाम सीख लें ताकि आप उन्हें रात 3 बजे पहचान सकें।

अनियंत्रित पुनरावृत्ति (Runaway recursion)। दो एजेंट एक-दूसरे को हमेशा के लिए खिलाते रहते हैं। इसका इलाज ऊपर बताया गया स्टेप कैप और बजट सीमा है, इससे चतुर कुछ नहीं।

मूक मृत्यु (Silent death)। एक डेवलपर का रात भर का रन एक पूर्ण संदर्भ विंडो से टकराया, रुक गया, फिर उसी दीवार में फिर से शुरू करने की कोशिश करता रहा जबकि वह अभी भी जीवित दिख रहा था। आपका लूप घंटों तक मरा रह सकता है और फिर भी प्रगति की रिपोर्ट कर सकता है। इसका इलाज एक हार्टबीट और प्रति चरण एक ताज़ा संदर्भ है, न कि एक अंतहीन रन।

यादृच्छिक चलना (Random walk)। किसी सत्यापन योग्य रोक की स्थिति के बिना, लूप लक्ष्य से दूर भटकता है न कि उसकी ओर। एक पासिंग टेस्ट सूट एक निश्चित बिंदु है जहाँ यह पहुँच सकता है। "देखने में पूरा लगता है" ऐसा नहीं है।

समझ ऋण (Comprehension debt)। जितनी तेज़ी से लूप आपके द्वारा न लिखा गया कोड शिप करता है, आपकी रिपॉजिटरी क्या करती है और आप क्या समझते हैं, के बीच की खाई उतनी ही चौड़ी होती जाती है। इसे बिना पढ़े काफी देर तक चलने दें और आप इंजीनियर नहीं रह जाते, बल्कि एक रबर स्टैम्प बन जाते हैं। इसका इलाज एक मानव-पठित गेट है जिसे लूप को कभी भी छोड़ने की अनुमति नहीं है।

11. लूप बनाएँ। इंजीनियर बने रहें।

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

चेर्नी की बात कभी यह नहीं थी कि काम आसान हो गया। यह थी कि लीवरेज स्थानांतरित हो गया: प्रॉम्प्ट से लूप में, और टाइपिंग से निर्णय में। यह प्रॉम्प्टिंग से कठिन काम है, आसान नहीं।

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

जो कोई भी 200 पुल रिक्वेस्ट प्रति माह शिप कर रहा है, उसने सौ एजेंटों से शुरुआत नहीं की। उन्होंने एक लूप से शुरुआत की जिस पर उन्हें भरोसा था, और वे पूरे रास्ते इंजीनियर बने रहे। वह एक लूप बनाएँ।