ज़्यादातर लोग अब भी एक बॉक्स में प्रॉम्प्ट टाइप करके जवाब का इंतज़ार कर रहे हैं।
इसे सेव कर लें :)
लोगों का एक छोटा समूह ऐसा करना बंद कर चुका है। वे अब अपने AI को प्रॉम्प्ट नहीं करते। वे ऐसे लूप बनाते हैं जो उनके लिए प्रॉम्प्ट करते हैं, आउटपुट वेरिफ़ाई करते हैं, फेल होने पर दोबारा कोशिश करते हैं, और जब काम पूरा हो जाता है तब रुकते हैं। वे चले जाते हैं, और काम खत्म हो जाता है जब वे कुछ और कर रहे होते हैं।
इन दोनों समूहों के बीच का अंतर प्रतिभा का नहीं है।
यह है कि एक समूह अभी भी लूप है, और दूसरे समूह ने लूप को डिज़ाइन करना सीख लिया है।
जून 2026 के दूसरे हफ़्ते में, एक विचार ने यह बदल दिया कि गंभीर लोग AI के साथ काम करने के बारे में कैसे बात करते हैं। जो वाक्यांश अटक गया वह था "लूप इंजीनियरिंग"। इसका नामकरण और संरचना Addy Osmani ने एक निबंध में किया, और यह तब और तेज़ी से फैला जब Claude Code के निर्माता Boris Cherny ने अपने वर्कफ़्लो को ऐसे लूप के रूप में वर्णित किया जो Claude को प्रॉम्प्ट करते हैं और पता लगाते हैं कि आगे क्या करना है, बजाय इसके कि वह बारी-बारी से प्रॉम्प्ट करे। एक पोस्ट ने कथित तौर पर कुछ ही दिनों में साढ़े छह मिलियन से अधिक व्यूज़ पार कर लिए। इसने उस चीज़ को एक नाम दिया जो सबसे अच्छे एजेंट उपयोगकर्ता पहले से ही बिना किसी नाम के कर रहे थे।
यहाँ पूरा बदलाव एक वाक्य में है: काम की इकाई अब वह प्रॉम्प्ट नहीं है जो आप टाइप करते हैं। यह एक लूप है जिसे आप इंजीनियर करते हैं।
यह 20-चरणीय रोडमैप है जो आपको प्रॉम्प्टर से लूप डिज़ाइनर बनाता है। इसे क्रम से करें। हर कदम अगले कदम को अर्जित करता है।
चरण 1: समझें कि क्या बदला (कदम 1–4)
एक भी लूप बनाने से पहले, आपको मानसिक मॉडल चाहिए। इसे छोड़ेंगे तो कमज़ोर लूप बनाएंगे जो उन तरीकों से टूटेंगे जिन्हें आप समझ नहीं पाएंगे।
कदम 1: चार युगों को देखें। यह क्षेत्र स्पष्ट चरणों में आगे बढ़ा है। 2023 में कौशल प्रॉम्प्ट इंजीनियरिंग थी, एक अनुरोध को अच्छी तरह से वाक्यांशित करना। 2024 में यह ऑर्केस्ट्रेशन था, चरणों को एक साथ जोड़ना। 2025 में यह कॉन्टेक्स्ट इंजीनियरिंग थी, यह नियंत्रित करना कि मॉडल क्या देखता है। 2026 में यह लूप इंजीनियरिंग बन गया, उस सिस्टम को डिज़ाइन करना जो मॉडल को आपके बिना चलाता है। प्रत्येक युग ने पिछले को बदला नहीं; यह उसके ऊपर स्टैक हुआ। यह जानना कि आप उस सीढ़ी पर कहाँ हैं, आपको बताता है कि आगे क्या सीखना है।
कदम 2: चेन और लूप के बीच अंतर सीखें। चेन एक निश्चित अनुक्रम है: चरण एक करो, फिर दो, फिर तीन, हो गया। यह तब काम करता है जब आप पहले से हर चरण जानते हों। लूप अलग है। यह कुछ कोशिश करता है, देखता है कि क्या हुआ, और परिणाम के आधार पर तय करता है कि आगे क्या करना है। चेन किसी फेल टेस्ट को ठीक नहीं कर सकती या ऐसे काम को पूरा नहीं कर सकती जहाँ चरण तीन इस बात पर निर्भर करता है कि चरण दो ने क्या लौटाया। लूप कर सकता है। लूप वही है जो लैंग्वेज मॉडल को ऐसी चीज़ में बदलता है जो प्रगति करती है।
कदम 3: रीज़न-एक्ट-ऑब्ज़र्व चक्र को आत्मसात करें। हर एजेंट लूप एक ही तीन-बीट लय का एक संस्करण है। एजेंट यह तर्क करता है कि क्या करना है, एक उपकरण का उपयोग करके कार्य करता है, और परिणाम का निरीक्षण करता है। फिर वह उस नई जानकारी के साथ फिर से तर्क करता है। इस पैटर्न की एक शोध वंशावली है जो 2022 के ReAct कार्य तक जाती है, लेकिन आपको पेपर्स की ज़रूरत नहीं है। आपको लय चाहिए: सोचो, करो, देखो, दोहराओ।
कदम 4: स्वीकार करें कि आप अड़चन हैं। तीन सालों तक, AI के साथ काम करने का मतलब था कि आप एक प्रॉम्प्ट टाइप करते, जवाब पढ़ते, और फिर से टाइप करते। आप ही लूप थे। 2026 का पूरा बदलाव यह है कि कोडिंग और नॉलेज एजेंट लंबे कार्यों में इतने विश्वसनीय हो गए हैं कि बीच में इंसान धीमा हिस्सा बन गया है। दुर्लभ कौशल अब प्रॉम्प्ट लिखना नहीं है। यह उस सिस्टम को डिज़ाइन करना है जो उन्हें आपके लिए लिखता है।
चरण 2: लूप की शारीरिक रचना में महारत हासिल करें (कदम 5–9)
अब आप भागों को सीखते हैं। एक लूप सिर्फ "मॉडल को बार-बार चलाना" नहीं है। इसकी एक संरचना है, और हर भाग अपनी जगह कमाता है।
कदम 5: परिभाषित करें कि "हो गया" का क्या मतलब है, मापने योग्य शब्दों में। लूप इंजीनियरिंग में यह सबसे महत्वपूर्ण चीज़ है, और यह वह जगह है जहाँ अधिकांश लोग असफल होते हैं। एक भी निर्देश लिखने से पहले, लिखें कि तैयार कैसा दिखता है, इस तरह से कि एक मशीन जाँच सके। "इसे अच्छा बनाओ" नहीं। "सभी टेस्ट पास हो जाएं।" "आउटपुट इस स्कीमा से मेल खाता है।" "चेकलिस्ट पर कोई आइटम अनचेक नहीं है।" एक लूप जिसके पास "हो गया" की स्पष्ट परिभाषा नहीं है, वह कभी नहीं जानता कि कब रुकना है।
कदम 6: वेरिफ़ायर बनाएं। वेरिफ़ायर पूरी चीज़ का मुख्य बिंदु है। यह स्वचालित जाँच है जो तय करती है कि आउटपुट आपके मापदंड को पूरा करता है या नहीं। यहाँ जाल है जिसमें हर कोई गिरता है: मॉडल को अपने काम को खुद ग्रेड करने देना। एक मॉडल अपने होमवर्क को खुद ग्रेड करता है तो लगभग हमेशा खुद को A देता है। आपका वेरिफ़ायर जितना सख्त और अधिक बाहरी होगा, आपका लूप उतना ही बेहतर होगा। आपका स्वाद, एक जाँच के रूप में एन्कोड किया गया, रिवॉर्ड फ़ंक्शन बन जाता है।
कदम 7: टर्मिनेशन लॉजिक को परतों में जोड़ें। बिना निकास के लूप इस क्षेत्र की सबसे आम और सबसे महंगी गलती है। आपको एक साथ कई निकासों को स्टैक करने की ज़रूरत है: एक वेरिफ़ायर जो पुष्टि करता है कि लक्ष्य पूरा हो गया है, पुनरावृत्तियों पर एक हार्ड कैप ताकि यह हमेशा के लिए न चले, एक टोकन या समय बजट ताकि यह आपके खाते को खाली न करे, और कोई प्रगति न होने का पता लगाना जो लूप को तोड़ता है जब हाल के कदम कुछ भी बदलना बंद कर देते हैं। इनमें से कोई भी अकेला पर्याप्त नहीं है। साथ में वे एक लूप को सुरक्षित बनाते हैं कि आप उससे दूर जा सकें।
कदम 8: स्टेट लेयर डिज़ाइन करें। एक वास्तविक लूप को ऐसी मेमोरी की ज़रूरत होती है जो पुनरारंभ से बची रहे। इसका मतलब है फ़ाइलें, टास्क लिस्ट, और चेकपॉइंट जो बने रहें ताकि अगर लूप चालीसवें पुनरावृत्ति पर क्रैश होता है, तो वह उनतीसवें से शुरू कर सके, शुरू से नहीं। स्टेट ही एक खिलौना लूप को उस लूप से अलग करता है जिस पर आप लंबे काम के लिए भरोसा कर सकते हैं।
कदम 9: मानव चेकपॉइंट रखें। ठीक से तय करें कि कोई भी अपरिवर्तनीय कार्रवाई होने से पहले एक व्यक्ति कहाँ समीक्षा करेगा। लूप अपने आप पूरे दिन शोध, ड्राफ्ट, रीफ़ैक्टर और वेरिफ़ाई कर सकता है। लेकिन एक संदेश भेजना, कोड डिप्लॉय करना, पैसे ट्रांसफर करना, या डेटा डिलीट करना रुकना चाहिए और आपका इंतज़ार करना चाहिए। यह डरपोकपन नहीं है। यही वह चीज़ है जो स्वायत्तता को सुरक्षित बनाती है।
चरण 3: अपना पहला लूप बनाएं (कदम 10–14)
सिद्धांत बहुत हो गया। आप लूप चलाकर, उन्हें असफल होते महसूस करके, और उन्हें ठीक करके लूप इंजीनियरिंग सीखते हैं।
कदम 10: एक दोहराए जाने वाला कार्य चुनें। कुछ ऐसा चुनें जो आप पहले से हाथ से करते हैं, बार-बार, जहाँ आप स्पष्ट रूप से बता सकें कि एक अच्छा परिणाम कैसा दिखता है। एक दोहराए जाने वाला कार्य जिसका जाँचने योग्य आउटपुट हो, पहले लूप के लिए एकदम सही है। एक अस्पष्ट रचनात्मक कार्य सबसे खराब है। संकीर्ण रूप से शुरू करें।
कदम 11: पहले इसे मैन्युअल रूप से करें। कार्य को अपने AI के साथ कुछ बार हाथ से चलाएं, पुराने प्रॉम्प्ट-और-समीक्षा तरीके से। यह आपको सटीक कदम, वे स्थान सिखाता है जहाँ यह गलत होता है, और "हो गया" का वास्तविक अर्थ। आप एक ऐसी प्रक्रिया को स्वचालित नहीं कर सकते जिसका आप अभी तक वर्णन नहीं कर सकते। मैन्युअल रन आपके द्वारा स्पेक लिखना है।
कदम 12: लूप कॉन्ट्रैक्ट लिखें। अब इसे लिखित रूप में रखें: लक्ष्य, "हो गया" की परिभाषा, जाँचें जो इसे सत्यापित करती हैं, अधिकतम पुनरावृत्तियाँ, और वह बिंदु जहाँ आपसे पूछा जाना चाहता है। यह कॉन्ट्रैक्ट ही आपका लूप है। बाकी सब कार्यान्वयन है।
कदम 13: इसे बंद चलाएं और देखें। लूप शुरू करें और हर पुनरावृत्ति देखें। अभी दूर न जाएं। आप विफलता मोड की तलाश में हैं: क्या यह हमेशा के लिए लूप करता है, क्या यह बहुत जल्दी जीत की घोषणा करता है, क्या यह लक्ष्य से भटक जाता है, क्या यह अपनी ही कमज़ोर जाँच पास करते हुए कचरा पैदा करता है? हर विफलता जो आप देखते हैं, वह आपके वेरिफ़ायर के लिए एक सबक है।
कदम 14: वेरिफ़ायर को तब तक कसें जब तक आप उस पर भरोसा न करें। आपने देखकर जो सीखा, उसे लें और जाँचों को और सख्त और अधिक आधारभूत बनाएं। यदि लूप खराब आउटपुट पास करता रहा, तो आपका मापदंड बहुत कम या बहुत आत्म-संदर्भित था। एक बाहरी जाँच जोड़ें। एक लंबाई सीमा जोड़ें। एक विशिष्ट मानदंड जोड़ें जिसका वह लगातार उल्लंघन करता रहा। तब तक कसते रहें जब तक लूप का "पास" उसी चीज़ का मतलब न हो जो आपके "पास" का मतलब है।
चरण 4: स्केल और रिफ़ाइन करें (कदम 15–20)
अब आप एक काम करने वाले लूप से एक सिस्टम की ओर, और एक शौकिया से लूप डिज़ाइनर की ओर जाते हैं।
कदम 15: ओपन बनाम क्लोज़्ड लूप सीखें। हर लूप दो ध्रुवों के बीच बैठता है। एक क्लोज़्ड लूप एक निश्चित लक्ष्य की ओर उसी सीमित कार्य को दोहराता है, सुरक्षित और सस्ता। एक ओपन लूप खोजता है, नए दृष्टिकोण आज़माता है, और अधिक लाभ के लिए अधिक बजट जोखिम में डालता है। प्रति कार्य जानबूझकर चुनें: आपको कितनी नवीनता चाहिए, और आप कितना बजट जोखिम में डालने को तैयार हैं? फिर वह वेरिफ़ायर लिखें जो चुनाव से मेल खाता हो।
कदम 16: नीचे के हार्नेस को समझें। एक लूप खालीपन में नहीं चलता। यह एक हार्नेस के अंदर चलता है: उपकरणों, कॉन्टेक्स्ट प्रबंधन, स्टेट, अनुमतियों, और रिकवरी का पूरा वातावरण जो मॉडल के चारों ओर लपेटा जाता है। एक खराब हार्नेस पर एक महान लूप फिर भी विफल होता है। जैसे-जैसे आप गंभीर होते हैं, आप लूप पर उतना ही समय हार्नेस पर भी बिताएंगे, क्योंकि हार्नेस वह जगह है जहाँ विश्वसनीयता वास्तव में रहती है।
कदम 17: लागत को इस तरह प्रबंधित करें जैसे कि यह मायने रखती है, क्योंकि यह रखती है। लूप एकल प्रॉम्प्ट की तुलना में दस से सौ गुना अधिक मॉडल कॉल करते हैं। भोला तरीका आपको दिवालिया कर देता है। अनुशासित तरीका प्रत्येक चरण को सबसे सस्ते सक्षम मॉडल पर रूट करता है: सरल वर्गीकरण के लिए एक छोटा तेज़ मॉडल, ड्राफ्टिंग के लिए एक मध्यम, अंतिम कठिन समीक्षा के लिए केवल एक फ्रंटियर मॉडल। अपने प्रॉम्प्ट के दोहराए गए हिस्सों का पुन: उपयोग करें ताकि आप हर पुनरावृत्ति पर पूरी कीमत न चुका रहे हों। सही ढंग से किया गया, यह लूप की लागत को नाटकीय रूप से कम करता है।
कदम 18: समानांतर काम के लिए उप-एजेंट जोड़ें। जब कोई काम स्वतंत्र भागों में विभाजित होता है, तो आप उन्हें एक के बाद एक नहीं चलाते। आप उप-एजेंटों को जन्म देते हैं जो प्रत्येक एक भाग को समानांतर में संभालते हैं, फिर परिणामों को एक साथ जोड़ते हैं। इस तरह एक लूप जो अनुक्रम में घंटों लगेगा, मिनटों में खत्म होता है। ऑर्केस्ट्रेटर प्रबंधन करता है; उप-एजेंट निष्पादित करते हैं।
कदम 19: लूप को एक स्क्रिप्ट में स्थानांतरित करें। अंतिम तकनीकी छलांग: एक लूप जिसे आप संभालते हैं, उसके बजाय आप लूप को कोड के रूप में लिखते हैं जो एक शेड्यूल पर चलता है और आपके लिए एजेंट को चलाता है। यह वह जगह है जहाँ "जब आप सोते हैं तब चलता है" एक नारा नहीं रह जाता और एक क्रॉन जॉब बन जाता है। आपका लूप इंफ्रास्ट्रक्चर बन जाता है।
कदम 20: निर्णय को अपना उत्पाद बनाएं। यहाँ सड़क के अंत में सच्चाई है। जब लूप कोड लिखता है, टेस्ट चलाता है, और अपनी विफलताओं को ठीक करता है, तो आपका मूल्य टाइप करना नहीं रह जाता। यह जानना कि "सही" कैसा दिखता है, मापदंड निर्धारित करना, और जाँचों को डिज़ाइन करना है जो इसे लागू करते हैं। समीक्षा, स्वाद और निर्णय सबसे अधिक लाभ उठाने वाले कौशल बन जाते हैं जो आपके पास हैं। लूप-इंजीनियरिंग की दुनिया में, आपका स्वाद एक सॉफ्ट स्किल नहीं है। यह रिवॉर्ड फ़ंक्शन है जिसके विरुद्ध पूरा सिस्टम ऑप्टिमाइज़ होता है।
एक काम का उदाहरण: आपका पहला वास्तविक लूप
मैं सभी बीस कदमों को एक ऐसे लूप के साथ ठोस बनाता हूँ जिसे आप वास्तव में इस सप्ताह बना सकते हैं।
मान लें कि आप एक छोटे कोडबेस का रखरखाव करते हैं और आप उन टेस्टों को मैन्युअल रूप से ठीक करते-करते थक गए हैं जो तब टूटते हैं जब आप कुछ बदलते हैं। यह एकदम सही पहला लूप है: दोहराए जाने वाला, और जाँचने योग्य "हो गया" की परिभाषा के साथ।
यहाँ बताया गया है कि रोडमैप कैसे काम करता है। आपकी "हो गया" की परिभाषा (कदम 5) सरल और वस्तुनिष्ठ है: पूरा टेस्ट सूट पास हो जाता है। आपका वेरिफ़ायर (कदम 6) पहले से मौजूद है; यह स्वयं टेस्ट कमांड है, जो या तो साफ-साफ बाहर निकलता है या विफलताओं की रिपोर्ट करता है। एजेंट के पास चापलूसी करने के लिए कुछ नहीं है, क्योंकि टेस्ट पास करना टेस्ट पास करना है। आपका टर्मिनेशन लॉजिक (कदम 7) तीन निकासों का स्टैक है: रुको जब टेस्ट पास हो जाएं, पंद्रह प्रयासों के बाद रुको, और रुको यदि पिछले तीन प्रयासों ने नहीं बदला कि कौन से टेस्ट फेल हो रहे हैं। आपकी स्टेट (कदम 8) एक चल रहा नोट है कि क्या प्रयास किया गया है, ताकि पुनरारंभ मृत अंत को दोहराए नहीं। और आपका मानव चेकपॉइंट (कदम 9) किसी भी चीज़ के कमिट या कहीं साझा किए जाने से ठीक पहले बैठता है।
अब आप इसे चलाते हैं। लूप फेल हो रहे टेस्टों को पढ़ता है, कारण के बारे में तर्क करता है, कोड को संपादित करता है, फिर से टेस्ट चलाता है, नए परिणाम पढ़ता है, और समायोजित करता है। आप इसे देखते हैं (कदम 13) और आप कुछ नोटिस करते हैं: एक रन पर इसने खुद टेस्ट को कमज़ोर करके "ठीक" किया, कोड को नहीं। यह एक सबक है। आप लूप को कसते हैं (कदम 14): निर्देश अब टेस्ट को संपादित करने से मना करते हैं, और एक जाँच पुष्टि करती है कि टेस्ट फ़ाइलें अपरिवर्तित हैं। अगला रन सही व्यवहार करता है।
देखने के कुछ सत्रों के बाद, आप उस पर भरोसा करते हैं। तो आप इसे स्क्रिप्ट करते हैं (कदम 19) और हर रात चलने के लिए शेड्यूल करते हैं। अब आप एक कोडबेस के लिए जागते हैं जहाँ कल की टूट-फूट पहले से ही ठीक हो चुकी है, जिसमें आपकी समीक्षा के लिए क्या बदला गया, इसका सारांश इंतज़ार कर रहा है। आप इसे हर दोपहर हाथ से करने से लेकर कॉफी पर तैयार काम की समीक्षा करने तक पहुँच गए।
यह पूरा चाप लघु रूप में है: "हो गया" को परिभाषित करें, वेरिफ़ायर को आधार दें, निकासों को परत करें, देखें, कसें, फिर जाने दें। एक बार जब आप इसे एक कार्य पर काम करते हुए महसूस करते हैं, तो आप हर जगह लूप देखेंगे: एक शोध लूप जो तब तक इकट्ठा और सत्यापित करता है जब तक एक ब्रीफ पूरा न हो जाए, एक लेखन लूप जो एक रूब्रिक के खिलाफ ड्राफ्ट और सेल्फ-एडिट करता है जब तक वह पास न हो जाए, एक डेटा लूप जो साफ और मान्य करता है जब तक फ़ाइल अच्छी तरह से बन न जाए। पैटर्न स्थानांतरित होता है। कार्य बदलता है; रोडमैप नहीं बदलता।
एक महीने में यह कैसा दिखता है
लूप इंजीनियरिंग एक सप्ताह का प्रमाणन नहीं है। यह आपके काम करने के तरीके में एक बदलाव है जो चक्रवृद्धि होता है।
पहला सप्ताह, आप एक लूप बनाते हैं और ज्यादातर उसे देखते हैं, उसके विफलता मोड सीखते हैं। दूसरा सप्ताह, आप उस लूप को तब तक कसते हैं जब तक आप उस पर बिना देखरेख के भरोसा नहीं करते, और आप एक अलग कार्य के लिए दूसरा लूप बनाते हैं। तीसरा सप्ताह, आप अपने विश्वसनीय लूप को शेड्यूल करना शुरू करते हैं ताकि वे आपके बिना चलें, और आप काम के पहले वास्तविक स्वाद को महसूस करते हैं जो आपके कहीं और होने पर पूरा हो रहा है। चौथा सप्ताह, आप देखते हैं कि आपने पूरी तरह से प्रॉम्प्ट में सोचना बंद कर दिया है। आप लक्ष्यों, जाँचों और निकासों में सोचते हैं। जब एक नया दोहराए जाने वाला कार्य आता है, तो आपकी प्रवृत्ति अब "मैं यह कैसे करूं" नहीं है, बल्कि "हो गया" की परिभाषा क्या है, और वेरिफ़ायर क्या है।
वह प्रवृत्ति ही पूरा परिवर्तन है। एक प्रॉम्प्टर प्रत्येक कार्य पर टाइप करके प्रतिक्रिया करता है। एक लूप डिज़ाइनर एक छोटी प्रणाली डिज़ाइन करके प्रतिक्रिया करता है जो कार्य और उसके हर भविष्य के उदाहरण को संभालती है। एक रैखिक है। दूसरा चक्रवृद्धि होता है।
वे गलतियाँ जो लोगों को प्रॉम्प्टर के रूप में फँसाए रखती हैं
कुछ जाल लगभग हर उस व्यक्ति को पकड़ लेते हैं जो यह छलांग लगाने की कोशिश करता है।
समझने से पहले स्वचालित करना। लोग कार्य को हाथ से करने से पहले लूप बनाने की कोशिश करते हैं। वे एक ऐसी प्रक्रिया को स्वचालित करते हैं जिसका वे वर्णन नहीं कर सकते और तेज़, आत्मविश्वासी कचरा प्राप्त करते हैं। हमेशा पहले मैन्युअल रूप से करें।
एक कमज़ोर या आत्म-संदर्भित वेरिफ़ायर। यदि मॉडल अपने काम को एक अस्पष्ट मानक के साथ जाँचता है, तो वह हमेशा खुद को मंजूरी देगा। लूप को ऐसा लगता है कि वह काम कर रहा है जबकि वह कचरा पैदा कर रहा है। वेरिफ़ायर सख्त, विशिष्ट, और आदर्श रूप से मॉडल की अपनी राय के बाहर किसी चीज़ में आधारित होना चाहिए।
कोई टर्मिनेशन लॉजिक नहीं। बिना हार्ड निकास के एक लूप या तो हमेशा के लिए चलेगा, आपका बजट खत्म करेगा, या चक्कर काटेगा। स्तरित निकास वैकल्पिक नहीं हैं। वे एक उपकरण और एक भगोड़े के बीच का अंतर हैं।
स्टेट छोड़ना। बिना स्थायी मेमोरी के एक लूप हर बार ठोकर खाने पर शून्य से शुरू होता है। किसी भी लंबे काम के लिए, स्टेट ही इसे जीवित रहने योग्य बनाता है।
अपरिवर्तनीय कार्यों से मानव को हटाना। लालच है कि लूप को सब कुछ बिना पर्यवेक्षण के करने दें। उस चीज़ के लिए इसका विरोध करें जिसे पूर्ववत नहीं किया जा सकता। लूप का उद्देश्य लीवरेज है, लापरवाही नहीं।
कौशल के पीछे का कौशल: स्वाद विकसित करना
यहाँ वह चीज़ है जो आपको लूप इंजीनियरिंग कोर्स बेचने वाला कोई भी व्यक्ति ज़ोर नहीं देगा, क्योंकि इसे एक त्वरित चाल के रूप में नहीं बेचा जा सकता: लूप इंजीनियरिंग का सबसे कठिन और सबसे मूल्यवान हिस्सा स्वाद विकसित करना है।
सोचें कि वास्तव में एक वेरिफ़ायर क्या है। यह इस बारे में आपका निर्णय है कि "अच्छा" का क्या मतलब है, इतनी सटीकता से लिखा गया कि एक मशीन इसे लागू कर सके। इसका मतलब है कि आपके लूप की गुणवत्ता आपके निर्णय की गुणवत्ता से सीमित है। यदि आप अच्छे आउटपुट को औसत दर्जे के आउटपुट से नहीं बता सकते, तो आप एक वेरिफ़ायर नहीं लिख सकते जो अंतर को पकड़ता है, और आपका लूप खुशी-खुशी पैमाने पर औसत दर्जे का काम पैदा करेगा। लूप के पास स्वाद नहीं है। आप इसे प्रदान करते हैं। लूप सिर्फ इसे अथक रूप से लागू करता है।
यही कारण है कि लूप इंजीनियरिंग अनुभवी चिकित्सकों को इतना भारी पुरस्कार देती है। एक वरिष्ठ इंजीनियर जानता है कि सही कोड कैसा दिखता है, इसलिए वह एक जाँच लिख सकता है जो सूक्ष्म गलतता को पकड़ती है। एक महान संपादक जानता है कि मजबूत लेखन कैसा दिखता है, इसलिए वह एक रूब्रिक बना सकता है जो कमज़ोर ड्राफ्ट को पकड़ता है। आपने वर्षों में जो डोमेन विशेषज्ञता विकसित की है, वह लूप-इंजीनियरिंग की दुनिया में अप्रचलित नहीं होती। यह रिवॉर्ड फ़ंक्शन बन जाती है। यह सबसे अधिक लाभ उठाने वाली चीज़ बन जाती है जो आपके पास है।
इसलिए जैसे-जैसे आप इस रोडमैप पर काम करते हैं, अपने तकनीकी सेटअप के साथ-साथ अपने निर्णय में भी निवेश करें। उस काम के बेहतरीन उदाहरणों का अध्ययन करें जिसे आप लूप करने की कोशिश कर रहे हैं। अपने डोमेन में उत्कृष्ट और स्वीकार्य के बीच अंतर के बारे में तेज़ हो जाएँ। क्योंकि आपके स्वाद में हर सुधार हर उस वेरिफ़ायर में सुधार है जिसे आप कभी लिखेंगे, और इसलिए हर उस लूप में जिसे आप कभी चलाएंगे। जिस व्यक्ति के पास सबसे अच्छा स्वाद है और उसे एन्कोड करने का अनुशासन है, वह सबसे अच्छे लूप बनाता है। यही वास्तविक प्रतिस्पर्धा है, और यह एक ऐसी प्रतिस्पर्धा है जिसमें आप धीरे-धीरे, गुणवत्ता की परवाह करके जीतते हैं।
शुरुआती जो लूप के साथ संघर्ष करते हैं, वे आमतौर पर कमांड के साथ संघर्ष नहीं करते। वे संघर्ष करते हैं क्योंकि उन्हें पहले कभी यह स्पष्ट करने की ज़रूरत नहीं पड़ी कि "अच्छा" का क्या मतलब है, और एक लूप उन्हें ऐसा करने के लिए मजबूर करता है। वह कठिनाई ही विकास है। इसे पार करें, और आप न केवल लूप बनाने में सक्षम होकर बाहर आएंगे, बल्कि अपने स्वयं के मानकों के बारे में पहले से कहीं अधिक स्पष्ट होकर बाहर आएंगे।
लूप इंजीनियरिंग के बारे में ईमानदार सच्चाई
एक लूप उस कार्य को नहीं बचाएगा जिसे आप समझते नहीं हैं।
इस रोडमैप का हर कदम वास्तव में आपके अपने काम को इतनी स्पष्टता से वर्णित करने की दिशा में एक कदम है कि एक मशीन इसे चला सके। लूप आसान है। स्पष्टता, "हो गया" की परिभाषा, वह वेरिफ़ायर जो वास्तव में विफलता को पकड़ता है, यही कठिन हिस्सा है, और यह पूरी तरह से आप पर है। लूप इंजीनियरिंग ज्यादातर अच्छे आउटपुट के बारे में सटीक रूप से सोचने का अनुशासन है और आप इसे देखकर कैसे पहचानेंगे।
लेकिन यही कारण है कि यह कौशल चक्रवृद्धि होता है। जो लोग लूप डिज़ाइन करना सीखते हैं, वे अधिक सक्षम मॉडलों द्वारा प्रतिस्थापित नहीं होने वाले हैं। वे वे हैं जो उन मॉडलों को एक लक्ष्य की ओर इंगित करते हैं, अपने निर्णय को एक जाँच के रूप में एन्कोड करते हैं, और सिस्टम को चलने देते हैं। जैसे-जैसे मॉडल लंबे कार्यों में बेहतर होते जाते हैं, उनके चारों ओर लूप डिज़ाइन करने वाला व्यक्ति अधिक मूल्यवान होता जाता है, कम नहीं।
जिस आंदोलन ने इन सबका नामकरण किया, वह केवल कुछ हफ़्ते पुराना है।
जिसका मतलब है कि वह खिड़की जहाँ इसे जानना आपको लगभग सभी से आगे रखता है, अभी खुली है, आज, इससे पहले कि यह स्पष्ट डिफ़ॉल्ट बन जाए।
आप प्रॉम्प्ट टाइप करते रह सकते हैं और जवाबों का इंतज़ार कर सकते हैं।
या आप वह लूप डिज़ाइन कर सकते हैं जो आपके लिए इंतज़ार करता है।
पहला कदम कदम एक है। वहाँ से शुरू करें।
अगर आपको यह उपयोगी लगा, तो मुझे फ़ॉलो करें @eng_khairallah1 इस तरह की और AI सामग्री के लिए। मैं हर हफ़्ते ब्रेकडाउन, कोर्स और टूल पोस्ट करता हूँ।
आशा है कि यह आपके लिए उपयोगी था, खैरल्लाह ❤️
