फरवरी 2026 में, एक छोटी OpenAI टीम ने 1 मिलियन लाइन प्रोडक्शन कोड शिप किया।
उन्होंने एक भी लाइन हाथ से नहीं लिखी।
AI एजेंट्स ने इसे लिखा।
मनुष्यों ने वह सिस्टम डिज़ाइन किया जिसने एजेंट्स को विश्वसनीय बनाया।
उस सिस्टम का अब एक नाम है।
हार्नेस इंजीनियरिंग।
कुछ ही हफ्तों में, Anthropic ने इस पर 3 पेपर प्रकाशित किए।
ThoughtWorks ने एक फ्रेमवर्क को औपचारिक रूप दिया।
Hugging Face में Philipp Schmid ने इसे "2026 का सबसे महत्वपूर्ण अनुशासन" कहा।
एक नया इंजीनियरिंग अनुशासन 90 दिनों में साकार हुआ।
और AI इंफ्रास्ट्रक्चर टीमों के बाहर लगभग कोई भी इसे अभी तक नहीं समझता।
यह लेख सब कुछ समझाता है।
कोई फालतू बात नहीं। कोई अकादमिक शब्दजाल नहीं। बस वे मेंटल मॉडल जिनकी आपको वास्तव में इसका उपयोग करने के लिए आवश्यकता है।
इसे सेव करें। आप इसे दो बार पढ़ेंगे।
भाग 1: हार्नेस वास्तव में क्या है (वह अवधारणा जो AI के बारे में आपकी सोच बदल देती है)
1. हार्नेस की परिभाषा
सबसे सरल परिभाषा ThoughtWorks से आती है:
→ एजेंट = मॉडल + हार्नेस
हार्नेस वह सब कुछ है जो मॉडल नहीं है।
वे बाधाएँ जो एजेंट को ट्रैक पर रखती हैं। वे फीडबैक लूप जो गलतियों को पकड़ते हैं। वह दस्तावेज़ीकरण जो एजेंट को बताता है कि वह कहाँ है। वे उपकरण जिनका उपयोग करने की अनुमति उसे है।
हार्नेस हटाएँ → कच्चा भाषा मॉडल आपके कोडबेस में अपना रास्ता अंदाज़ से निकाल रहा है।
सही हार्नेस जोड़ें → सिस्टम जो प्रोडक्शन कोड शिप करता है।
यह नाम घोड़े की लगाम से आया है।
हार्नेस वह लगाम, काठी और बिट है जो एक शक्तिशाली लेकिन अप्रत्याशित जानवर को एक उपयोगी दिशा में ले जाता है।
आप घोड़े को होशियार नहीं बनाते। आप वह उपकरण डिज़ाइन करते हैं जो उसकी ताकत को उपयोगी बनाता है।
2. OS सादृश्य
Philipp Schmid ने सबसे अच्छा तकनीकी फ्रेमिंग दिया:
इसे एक कंप्यूटर की तरह समझें।
→ मॉडल = CPU (कच्ची प्रोसेसिंग पावर)
→ कॉन्टेक्स्ट विंडो = RAM (सीमित, अस्थायी कार्यशील मेमोरी)
→ हार्नेस = ऑपरेटिंग सिस्टम (प्रबंधित करता है कि CPU क्या और कब देखता है)
→ एजेंट = एप्लिकेशन जो इसके ऊपर चलता है
आपका मॉडल शक्तिशाली है।
लेकिन मेमोरी प्रबंधित करने, कार्यों को शेड्यूल करने और नियम लागू करने वाले OS के बिना — यह सिर्फ सिलिकॉन है।
अधिकांश लोग बिना ऑपरेटिंग सिस्टम के ऐप चला रहे हैं।
यही कारण है कि उनके एजेंट प्रोडक्शन में विफल हो जाते हैं।
3. 2026 में क्या बदला
LangChain ने Terminal Bench 2.0 पर एक ही मॉडल को दो बार चलाया।
एक ही मॉडल। अलग हार्नेस।
→ पुराना हार्नेस: 52.8% स्कोर
→ नया हार्नेस: 66.5% स्कोर
Vercel ने विपरीत दिशा में कदम बढ़ाया।
उन्होंने अपने एजेंट के 80% टूल हटा दिए।
परिणाम? बेहतर प्रदर्शन।
बुरा नहीं।
2026 का असुविधाजनक सत्य:
→ एजेंट कभी भी कठिन हिस्सा नहीं था।
→ हार्नेस है।
अगर 2025 वह वर्ष था जब AI एजेंटों ने साबित किया कि वे कोड लिख सकते हैं…
2026 वह वर्ष है जब हमने पाया कि वातावरण मॉडल से अधिक मायने रखता है।
भाग 2: 5 हार्नेस आर्टिफैक्ट (व्यवहार में हार्नेस वास्तव में कैसा दिखता है)
4. AGENT.md / CLAUDE.md फ़ाइलें
सबसे सार्वभौमिक हार्नेस आर्टिफैक्ट।
आपके कोडबेस में वितरित Markdown फ़ाइलें।
एजेंट प्रत्येक सत्र की शुरुआत में उन्हें पढ़ता है — जैसे टीम में शामिल होने वाले नए इंजीनियर के लिए ऑनबोर्डिंग दस्तावेज़।
उनमें क्या जाता है:
→ प्रोजेक्ट संदर्भ
→ कोडिंग परंपराएँ
→ आर्किटेक्चर निर्णय
→ "हम यहाँ चीज़ें कैसे करते हैं" मार्गदर्शन
→ वर्तमान में क्या प्रगति पर है
OpenAI उन्हें AGENT.md कहता है।
Anthropic उन्हें CLAUDE.md कहता है।
Cursor .cursorrules का उपयोग करता है।
अलग-अलग नाम। एक ही सिद्धांत।
प्रति प्रमुख मॉड्यूल एक फ़ाइल। प्रोजेक्ट के विकसित होने पर अपडेट की जाती है।
उनके बिना: एजेंट हर सत्र अंधा शुरू करता है। उनके साथ: एजेंट हर सत्र सूचित शुरू करता है।
5. JSON फीचर सूचियाँ (प्रगति ट्रैकर)
जब कोई एजेंट कई सत्रों में एक पूरा ऐप बनाता है, तो वह प्रत्येक सत्र एक खाली कॉन्टेक्स्ट विंडो के साथ शुरू करता है।
उसे कैसे पता चलता है कि पहले से क्या हो चुका है?
एक JSON फ़ाइल।
प्रत्येक प्रविष्टि परिभाषित करती है:
→ एक सुविधा
→ यह कैसे सत्यापित करें कि यह काम करता है
→ पास / फेल स्थिति
एजेंट इसे सत्र की शुरुआत में पढ़ता है। सबसे अधिक प्राथमिकता वाली विफल सुविधा चुनता है। इसे लागू करता है। इसे पासिंग के रूप में चिह्नित करता है। कमिट करता है। दोहराता है।
JSON क्यों और Markdown क्यों नहीं?
Anthropic ने पाया कि एजेंटों के JSON को गलती से ओवरराइट करने की संभावना Markdown की तुलना में कम होती है।
छोटा विवरण। 6 घंटे के स्वायत्त रन में बहुत मायने रखता है।
6. सत्र आरंभीकरण रूटीन
हर सत्र एक ही तरह से शुरू होता है।
हर। एक। बार।
Anthropic का 7-चरणीय बूट अनुक्रम:
- कार्यशील निर्देशिका की पुष्टि करें
- git लॉग और प्रगति फ़ाइलें पढ़ें
- सबसे अधिक प्राथमिकता वाली अपूर्ण वस्तु के लिए फीचर सूची जाँचें
- डेव सर्वर शुरू करें
- बुनियादी एंड-टू-एंड सत्यापन चलाएँ
- एक सुविधा लागू करें
- वर्णनात्मक संदेश के साथ कमिट करें + प्रगति अपडेट करें
इसके बिना:
एजेंट अपने पहले 20 मिनट यह पता लगाने में बर्बाद करता है कि पहले से क्या मौजूद है।
हर सत्र पहिया का पुनः आविष्कार है।
इसके साथ:
एजेंट तुरंत सूचित शुरू होता है और सीधे काम पर लग जाता है।
7. स्प्रिंट अनुबंध
एजेंट कोड की एक भी लाइन लिखने से पहले:
दो एजेंट बातचीत करते हैं।
जनरेटर एजेंट प्रस्ताव करता है:
→ वह क्या बनाएगा
→ सफलता कैसे सत्यापित की जाएगी
मूल्यांकनकर्ता एजेंट समीक्षा करता है:
→ क्या प्रस्ताव पूर्ण है?
→ क्या सफलता मानदंड स्पष्ट हैं?
दोनों के सहमत होने के बाद ही कार्यान्वयन शुरू होता है।
यह एक डिज़ाइन समीक्षा है।
सिवाय इसके कि दोनों प्रतिभागी AI हैं।
यह क्यों मायने रखता है?
जो एजेंट एक ही पास में योजना बनाते और निष्पादित करते हैं, वे अविश्वसनीय आउटपुट उत्पन्न करते हैं।
योजना चरण — भले ही AI द्वारा किया गया हो — आउटपुट गुणवत्ता में नाटकीय रूप से सुधार करता है।
8. संरचित कार्य टेम्पलेट
किसी भी कोडिंग से पहले:
हार्नेस वास्तविक कोडबेस का विश्लेषण करता है।
यह एक आधारभूत प्रभाव मानचित्र तैयार करता है:
→ वास्तविक फ़ाइल पथ (काल्पनिक नहीं)
→ वास्तविक प्रतीक नाम जो वास्तव में मौजूद हैं
→ अनुसरण करने के लिए मौजूदा पैटर्न
→ ठोस स्वीकृति मानदंड
फिर कार्यान्वयन शुरू होता है।
यह स्पष्ट लगता है।
लेकिन अधिकांश टीमें इसे छोड़ देती हैं।
एजेंट फ़ाइल संरचनाओं का अनुमान लगाता है। ऐसे API एंडपॉइंट का आविष्कार करता है जो मौजूद नहीं हैं। कुछ ऐसा बनाता है जो कोडबेस में फिट नहीं बैठता।
निष्पादन से पहले आधारभूत संदर्भ → बहुत बेहतर आउटपुट।
भाग 3: तीन शिविर (तीन टीमों ने एक ही दीवार मारी — और तीन अलग-अलग सीढ़ियाँ बनाईं)
9. OpenAI: वातावरण-प्रथम
OpenAI की Codex टीम के पास एक बेतुकी समस्या थी।
1 मिलियन लाइन प्रोडक्शन कोड। शून्य हाथ से लिखा गया।
उस पैमाने पर, आप हर लाइन की कोड-समीक्षा नहीं कर सकते।
इसलिए उन्होंने नहीं की।
इसके बजाय:
उन्होंने वातावरण को इतनी अच्छी तरह से डिज़ाइन किया कि एजेंटों ने पहले स्थान पर समीक्षा योग्य आउटपुट तैयार किया।
उनका दृष्टिकोण:
→ सख्त निर्भरता प्रवाह (प्रकार → कॉन्फ़िग → रेपो → सेवा → रनटाइम → UI)
→ पूरे कोडबेस में AGENT.md फ़ाइलें
→ एजेंट सीधे CI/CD पाइपलाइनों में वायर्ड
दर्शन: वातावरण डिज़ाइन करें। फिर एजेंट को छोड़ दें।
प्रमाण: Sora Android ऐप। 4 इंजीनियर। 28 दिन। Play Store पर #1। 99.9% क्रैश-मुक्त।
Codex ने साप्ताहिक रूप से 70% आंतरिक पुल अनुरोधों को संभाला।
10. Anthropic: कर्ता को न्यायाधीश से अलग करें
Anthropic के पास एक अलग समस्या थी।
जब उन्होंने एजेंट से अपने स्वयं के आउटपुट का मूल्यांकन करने के लिए कहा:
यह आत्मविश्वास से काम की प्रशंसा करता था।
भले ही, एक मानव पर्यवेक्षक के लिए, गुणवत्ता स्पष्ट रूप से औसत दर्जे की थी।
स्व-मूल्यांकन काम नहीं करता।
एजेंट छात्र और शिक्षक दोनों था।
और यह खुद को सीधे A दे रहा था।
उनका समाधान: तीन विशिष्ट एजेंट।
→ योजनाकार — एक 2-वाक्य संकेत को एक पूर्ण उत्पाद विनिर्देश में बदल देता है
→ जनरेटर — एक बार में एक स्प्रिंट सुविधाओं को लागू करता है
→ मूल्यांकनकर्ता — चल रहे ऐप का परीक्षण एक वास्तविक उपयोगकर्ता की तरह करने के लिए ब्राउज़र ऑटोमेशन का उपयोग करता है
अंतर्दृष्टि: एक स्वतंत्र मूल्यांकनकर्ता को संदेहास्पद बनाना, एक जनरेटर को अपने स्वयं के काम के प्रति आलोचनात्मक बनाने की तुलना में कहीं अधिक आसान है।
परिणाम: एकल एजेंट (कोई हार्नेस नहीं): $9, 20 मिनट
→ टूटा हुआ ऐप पूर्ण हार्नेस: $200, 6 घंटे
→ पॉलिश UI के साथ काम करने वाला सॉफ्टवेयर
11. ThoughtWorks: 2×2 फ्रेमवर्क
ThoughtWorks एक अलग कोण से पहुंचा।
वे कोई उत्पाद नहीं बना रहे थे।
वे 50+ इंजीनियरिंग टीमों को एक ही चीज़ों में विफल होते देख रहे थे।
उनकी अंतर्दृष्टि: प्रत्येक हार्नेस नियंत्रण को दो अक्षों पर वर्गीकृत करें।
अक्ष 1: यह कब चलता है?
→ फीडफॉरवर्ड = एजेंट के कार्य करने से पहले (मार्गदर्शक)
→ फीडबैक = एजेंट के कार्य करने के बाद (सेंसर)
अक्ष 2: यह कैसे काम करता है?
→ कम्प्यूटेशनल = नियतात्मक, मिलीसेकंड (लिंटर्स, टाइप चेकर्स, टेस्ट सूट)
→ अनुमानात्मक = LLM का उपयोग करता है, सेकंड (कोड समीक्षा एजेंट, सिमेंटिक विश्लेषण)
2×2:
→ कम्प्यूटेशनल फीडफॉरवर्ड: टाइप सिस्टम, लिंटर्स, आर्किटेक्चरल नियम
→ कम्प्यूटेशनल फीडबैक: टेस्ट सूट, कवरेज विश्लेषण, म्यूटेशन टेस्टिंग
→ अनुमानात्मक फीडफॉरवर्ड: स्पेक दस्तावेज़, बाधा विवरण
→ अनुमानात्मक फीडबैक: LLM कोड समीक्षक, व्यवहार सत्यापनकर्ता
अकेले फीडफॉरवर्ड या फीडबैक काम नहीं करता।
आपको दोनों की आवश्यकता है।
भाग 4: 5 सिद्धांत जिन पर हर शिविर सहमत है (तीन टीमों ने कभी समन्वय नहीं किया। वे यहाँ स्वतंत्र रूप से पहुंचे।)
12. सिद्धांत 1: संदर्भ निर्देशों से बेहतर है
OpenAI: "1,000 पृष्ठों का मैनुअल नहीं, एक नक्शा दें।"
Anthropic: JSON फीचर सूचियाँ और प्रगति फ़ाइलें ताकि एजेंट हमेशा जान सकें कि वे कहाँ हैं।
Red Hat: कोई भी कार्य उत्पन्न करने से पहले वास्तविक कोडबेस का विश्लेषण करें।
ThoughtWorks: "फीडफॉरवर्ड।"
अलग-अलग शब्द। एक ही खोज।
एजेंट को दुनिया की वर्तमान स्थिति दिखाना, उसे अमूर्त रूप से बताने की तुलना में लगातार बेहतर प्रदर्शन करता है कि क्या करना है।
→ वास्तविक फ़ाइल पथों में आधारित
→ कोड जो कोडबेस में फिट बैठता है
→ एक अस्पष्ट विवरण से काम करना
→ काल्पनिक फ़ाइल पथ और आविष्कृत API
सबक: एजेंट कुछ भी टाइप करने से पहले, सुनिश्चित करें कि वह जानता है कि वह वास्तव में कहाँ है।
13. सिद्धांत 2: योजना और निष्पादन को अलग किया जाना चाहिए
OpenAI: मनुष्य वातावरण डिज़ाइन करते हैं, एजेंट निष्पादित करते हैं।
Anthropic: समर्पित योजनाकार एजेंट जनरेटर के किसी भी कोड को छूने से पहले चलता है।
ThoughtWorks: योजना और कार्यान्वयन के बीच अनिवार्य मानव समीक्षा चौकी।
Red Hat: चरण 1 (प्रभाव मानचित्र) और चरण 2 (कार्यान्वयन) के बीच एक कठोर द्वार।
प्रत्येक शिविर ने स्वतंत्र रूप से यह खोजा:
एक एजेंट को एक ही पास में योजना बनाने और निष्पादित करने देना अविश्वसनीय आउटपुट उत्पन्न करता है।
योजना चरण को मानव द्वारा करने की आवश्यकता नहीं है।
लेकिन यह एक अलग चरण होना चाहिए, जिसके आउटपुट की कार्यान्वयन शुरू होने से पहले समीक्षा की जाए।
14. सिद्धांत 3: फीडबैक लूप अपरिहार्य हैं
OpenAI: एजेंट CI/CD और अवलोकन प्रणालियों में वायर्ड।
Anthropic: ब्राउज़र ऑटोमेशन का उपयोग करने वाला समर्पित मूल्यांकनकर्ता एजेंट।
ThoughtWorks: "सेंसर" के रूप में औपचारिक रूप दिया गया। चेतावनी दी कि केवल फीडफॉरवर्ड दृष्टिकोण कभी पुष्टि नहीं करते कि मार्गदर्शक वास्तव में काम करते हैं या नहीं।
एक ही सिद्धांत के तीन दृष्टिकोण:
→ OpenAI स्वचालित परीक्षण और CI का उपयोग करता है
→ Anthropic दूसरे LLM का उपयोग करता है
→ ThoughtWorks कहता है कि दोनों का उपयोग करें, स्तरित
वे इस बात पर असहमत हैं कि फीडबैक कौन प्रदान करता है।
वे इस बात पर असहमत नहीं हैं कि क्या आपको इसकी आवश्यकता है।
फीडबैक के बिना एक हार्नेस अतिरिक्त चरणों वाला सिर्फ एक प्रॉम्प्ट है।
15. सिद्धांत 4: एक बार में एक काम
OpenAI: लक्ष्यों को छोटे बिल्डिंग ब्लॉक्स में तोड़ता है, गहराई-प्रथम काम करता है।
Anthropic: प्रत्येक के बाद कमिट के साथ प्रति-स्प्रिंट एक-सुविधा लागू करता है।
ThoughtWorks: चरणबद्ध जीवनचक्र (पूर्व-एकीकरण → पोस्ट-एकीकरण → सतत निगरानी)।
जो एजेंट एक बार में बहुत अधिक करने की कोशिश करते हैं:
→ संदर्भ से बाहर हो जाते हैं
→ सुसंगतता खो देते हैं
→ चुपचाप आवश्यकताओं को छोड़ देते हैं
Anthropic रूटीन:
प्रगति पढ़ें → एक सुविधा चुनें → लागू करें → कमिट करें → दोहराएँ
बाध्य वृद्धिशीलता हर सफल हार्नेस में सार्वभौमिक है।
16. सिद्धांत 5: कोडबेस ही दस्तावेज़ीकरण है
OpenAI: रेपो में AGENT.md फ़ाइलें एम्बेड करता है।
Anthropic: फीचर सूचियों, प्रगति फ़ाइलों और git इतिहास को एजेंट के निरंतरता तंत्र के रूप में संग्रहीत करता है।
ThoughtWorks: "हार्नेसेबिलिटी" मापता है — कोडबेस एजेंटों के लिए कितना सुपाठ्य है।
कोई भी एजेंट के लिए एक अलग ज्ञानकोष नहीं रखता।
रेपो सत्य का एकमात्र स्रोत है।
यदि कोई परंपरा, बाधा या आर्किटेक्चरल निर्णय कोडबेस में नहीं है — तो एजेंट को इसके बारे में पता नहीं चलेगा।
व्यावहारिक निहितार्थ:
→ कोड संगठन में निवेश करने वाली टीमों को मुफ्त में बेहतर एजेंट प्रदर्शन मिलता है।
→ गंदे रेपो + AI एजेंट = अराजकता, लेकिन पैमाने पर।
भाग 5: विरोधाभास — हटाने के लिए बनाएँ (हार्नेस इंजीनियरिंग में सबसे प्रतिकूल सत्य)
17. हार्नेस क्षय वास्तविक है
जब Anthropic ने Opus 4.5 से Opus 4.6 में अपग्रेड किया:
स्प्रिंट डीकंपोज़िशन — जो आवश्यक था — मृत भार बन गया।
मॉडल की बेहतर योजना ने इसे अनावश्यक बना दिया।
एक हार्नेस घटक जो मार्च में भार वहन कर रहा था, अप्रैल तक ओवरहेड था।
फिर Opus 4.7 आया।
मॉडल ने अपने स्वयं के आउटपुट को सत्यापित करना शुरू कर दिया।
मूल्यांकनकर्ता एजेंट की नौकरी का विवरण सिकुड़ने लगा।
यह हार्नेस क्षय है।
हार्नेस में प्रत्येक घटक एक धारणा को कूटबद्ध करता है कि मॉडल क्या नहीं कर सकता।
जैसे-जैसे मॉडल में सुधार होता है → वे धारणाएँ समाप्त हो जाती हैं → घटक ओवरहेड बन जाता है।
Opus 4.5: स्प्रिंट डीकंपोज़िशन + प्रति-स्प्रिंट मूल्यांकन
Opus 4.6: कोई स्प्रिंट डीकंपोज़िशन नहीं + एकल-पास मूल्यांकन (38% लागत बचाता है)
Opus 4.7: मॉडल स्व-सत्यापन शुरू करता है → मूल्यांकनकर्ता भूमिका और सिकुड़ती है
18. हटाने के लिए बनाएँ
Philipp Schmid की सलाह:
"हटाने के लिए बनाएँ।"
प्रत्येक हार्नेस घटक को हटाने योग्य बनाने के लिए डिज़ाइन करें।
प्रत्येक घटक का समय-समय पर परीक्षण करें, इसे बंद करके और मापें कि क्या आउटपुट गुणवत्ता बदलती है।
यदि यह नहीं बदलती है: इसे हटा दें।
Manus ने 6 महीनों में 5 बार अपने हार्नेस को रिफैक्टर किया। LangChain ने 1 वर्ष में 3 बार पुनर्गठित किया। Vercel ने 80% टूल हटा दिए → बेहतर प्रदर्शन मिला।
ये खराब इंजीनियरिंग के संकेत नहीं हैं।
ये तेजी से सुधरने वाले मॉडलों के ऊपर निर्माण का स्वाभाविक परिणाम हैं।
मृत हार्नेस घटकों को ले जाने से हर एक रन पर टोकन खर्च होते हैं। शून्य अतिरिक्त गुणवत्ता। शुद्ध बर्बादी।
19. लागत वास्तविकता
Anthropic के A/B परीक्षण से ईमानदार संख्याएँ:
→ एकल एजेंट (कोई हार्नेस नहीं): $9, 20 मिनट
→ काम करने वाला UI, टूटी हुई मुख्य कार्यक्षमता
→ पूर्ण हार्नेस (Opus 4.5): $200, 6 घंटे
→ काम करने वाला सॉफ्टवेयर, पॉलिश UI, सही भौतिकी
यह 22x लागत वृद्धि है।
एक काम करने वाले उत्पाद बनाम एक डेमो के लिए जो केवल स्क्रीनशॉट में सही दिखता है।
यह महंगा है या सस्ता, यह पूरी तरह से इस बात पर निर्भर करता है कि आपकी टीम को एक टूटी हुई रिलीज़ की क्या कीमत चुकानी पड़ती है।
लेकिन यहाँ वह है जिसके बारे में कोई बात नहीं करता:
हार्नेस + मॉडल संयोजन विकसित होता है।
$200 का हार्नेस एक मॉडल अपग्रेड के साथ $124 हो गया।
प्रवृत्ति रेखा:
→ बेहतर मॉडल = सरल हार्नेस = सस्ता रन = तेज़ आउटपुट
2026 में जीतने वाले इंजीनियर सबसे अच्छा कोड नहीं लिख रहे हैं।
वे सबसे अच्छी बाधाएँ डिज़ाइन कर रहे हैं।
और फिर उन बाधाओं को फेंकने को तैयार हैं जैसे ही वे अपनी उपयोगिता खो देते हैं।
समापन
वह सब कुछ जो आपने अभी सीखा:
हार्नेस क्या है:
→ 1. एजेंट = मॉडल + हार्नेस
→ 2. मॉडल = CPU। हार्नेस = ऑपरेटिंग सिस्टम।
→ 3. एक ही मॉडल, बेहतर हार्नेस = +13% प्रदर्शन
5 हार्नेस आर्टिफैक्ट:
→ 4. CLAUDE.md / AGENT.md — एजेंटों के लिए ऑनबोर्डिंग दस्तावेज़
→ 5. JSON फीचर सूचियाँ — प्रगति ट्रैकर + टेस्ट सूट एक में
→ 6. सत्र आरंभीकरण रूटीन — हर बार एक ही 7-चरणीय बूट
→ 7. स्प्रिंट अनुबंध — कोडिंग से पहले एजेंट बातचीत करते हैं
→ 8. संरचित कार्य टेम्पलेट — वास्तविक फ़ाइल पथ, वास्तविक पैटर्न
तीन शिविर:
→ 9. OpenAI: वातावरण डिज़ाइन करें, एजेंट को छोड़ दें
→ 10. Anthropic: कर्ता को न्यायाधीश से अलग करें
→ 11. ThoughtWorks: 2×2 फीडफॉरवर्ड/फीडबैक फ्रेमवर्क
5 सार्वभौमिक सिद्धांत:
→ 12. संदर्भ निर्देशों से बेहतर है
→ 13. योजना और निष्पादन को अलग किया जाना चाहिए
→ 14. फीडबैक लूप अपरिहार्य हैं
→ 15. एक बार में एक काम
→ 16. कोडबेस ही दस्तावेज़ीकरण है
विरोधाभास:
→ 17. हार्नेस क्षय — पिछले महीने जो काम करता था, इस महीने नुकसान पहुँचाता है
→ 18. हटाने के लिए बनाएँ — मृत घटकों का परीक्षण करें और हटाएँ
→ 19. लागत वास्तविकता — बेहतर मॉडल = सरल हार्नेस = सस्ता रन
2026 में जीतने वाले इंजीनियर सबसे अच्छा कोड नहीं लिख रहे हैं।
वे सबसे अच्छी बाधाएँ डिज़ाइन कर रहे हैं।
और उन बाधाओं को फेंकने को तैयार हैं जैसे ही वे अपनी उपयोगिता खो देते हैं।
अगर यह उपयोगी था:
→ अपने नेटवर्क के बिल्डर्स तक पहुँचाने के लिए रिपोस्ट करें
→ हर हफ्ते ऐसी और सामग्री के लिए @sairahul1 को फॉलो करें
→ इसे बुकमार्क करें — जब आपके एजेंट गलत व्यवहार करने लगेंगे तो आप इसका संदर्भ लेंगे
मैं AI, उत्पाद बनाने और 2026 में वास्तव में क्या काम कर रहा है, इसके बारे में लिखता हूँ।
