परिचय: वह एजेंट जिसे हर कोई चाहता है, बिना किसी प्रचार के
कोडिंग एजेंटों के बारे में बात यह है कि उनमें से अधिकांश आपके बॉस, आपके सह-पायलट और आपके थेरेपिस्ट बनने की कोशिश करते हैं—फिर सिर्फ कोड लिखना भूल जाते हैं। प्लेबुक इस तरह जाती है: एक दर्जन वेक्टर स्टोर जोड़ें, कुछ ऑर्केस्ट्रेशन पिक्सी डस्ट छिड़कें, एक ब्राउज़र में बांधें, फिर इसे एक दिन कहें। यह अच्छी तरह से डेमो करता है। यह उस पल भी टूट जाता है जब आप इसे शुक्रवार को शाम 4:52 बजे एक अस्थिर एकीकरण परीक्षण को ठीक करने के लिए कहते हैं।
4.5 के साथ एक हल्का कोडिंग एजेंट बनाना—आश्चर्य की बात है—वास्तव में सीधा है यदि आप एक सार्वभौमिक सॉफ़्टवेयर बटलर के सपने का पीछा करना बंद कर देते हैं और बस एक ऐसा उपकरण बनाते हैं जो कोड पढ़ता है, योजना बनाता है, संपादित करता है, चलाता है और दोहराता है। "एआई डेवलपर्स की जगह ले रहा है" पर कोई उपदेश नहीं। कोई रूबे गोल्डबर्ग पाइपलाइन नहीं। बस एक तंग लूप जो स्पष्ट चीजों को अच्छी तरह से करता है।
यह बिना किसी संपूर्ण एआई संचालन विभाग को घसीटे वहां पहुंचने के लिए एक कैसे-करें गाइड है। हम मस्तिष्क के लिए 4.5, हाथों के लिए एक फ़ाइल सिस्टम और शेल और अल्पकालिक ध्यान के लिए एक छोटी सी मेमोरी का उपयोग करेंगे। बस इतना ही। हल्के का मतलब है कि आप इसे एक बैठक में समझ सकते हैं, इसे स्थानीय रूप से चला सकते हैं, और इस पर भरोसा कर सकते हैं क्योंकि हर कदम निरीक्षण योग्य है। जो, यदि आपने हाल ही में इस स्थान पर कुछ भी उपयोग किया है, तो लगभग विध्वंसक है।
न्यूनतम एजेंट के लिए 4.5 क्यों काम करता है
4.5 में वह स्वभाव है जो आप वास्तव में कोड के लिए चाहते हैं: निर्देश पालन के साथ सावधान, डिफ्स पढ़ने में आश्चर्यजनक रूप से सभ्य, और आपके द्वारा नहीं मांगे गए ढांचे को मतिभ्रम करने के लिए अत्यधिक उत्सुक नहीं। मॉडल एक संपूर्ण प्रॉम्प्ट उपन्यास की मांग किए बिना चरणबद्ध तर्क में सक्षम है। वह संयोजन—तर्क और संयम—इसे एक कोडिंग एजेंट लूप के लिए आदर्श बनाता है:
- अवलोकन: वर्तमान फ़ाइलें, त्रुटि लॉग और परीक्षण पढ़ें।
- योजना: तर्क के साथ ठोस संपादन का प्रस्ताव करें।
- अभिनय: फ़ाइलें पैच करें, कमांड चलाएं।
- चिंतन: आउटपुट का मूल्यांकन करें, दोहराएं या बंद करें।
आप इसे किसी भी रेपो पर बोल्ट कर सकते हैं और दोपहर में मूल्य प्राप्त कर सकते हैं। चाल इसे "एआई प्लेटफॉर्म" में बदलने की इच्छा का विरोध करना है। यदि आप एजेंट को हल्का रखते हैं, तो 4.5 आपके रास्ते में आए बिना भारी भार उठाता है।
हल्का वास्तुकला: पांच टुकड़े, कोई नाटक नहीं
यहां आपको आवश्यक पूरा स्टैक है:
- कोर लूप: एक प्रक्रिया जो 4.5 को कॉल करती है और इसके टूल-उपयोग संदेशों की व्याख्या करती है।
- उपकरण: एक छोटा सेट—read_file, write_file, list_dir, run_tests (या run_cmd), search_code।
- संदर्भ बिल्डर: रेपो मेटाडेटा और हाल के डिफ्स के साथ एक छोटा, नुकीला प्रॉम्प्ट इकट्ठा करें।
- अल्पकालिक मेमोरी: एक रोलिंग वार्तालाप विंडो प्लस योजना और बाधाओं के लिए एक स्पष्ट स्क्रैचपैड।
- गार्डरेल: टोकन, समय और फ़ाइल लिखने की सीमाएं; एक ड्राई-रन मोड; और रोलबैक स्नैपशॉट।
बस इतना ही। आप इसे टर्मिनल में हेडलेस चला सकते हैं या यदि आवश्यक हो तो इसे न्यूनतम यूआई में लपेट सकते हैं। इसका कारण यह काम करता है उबाऊ है: प्रत्येक क्रिया देखी और सत्यापित की जाती है। एजेंट एक बदलाव का प्रस्ताव करता है, डिफ दिखाता है, परीक्षण चलाता है, आउटपुट पढ़ता है, और या तो जारी रखता है या बंद कर देता है। बीच में कोई रहस्य मांस नहीं है।
एजेंट कैसे बनाएं (बिना प्लॉट खोए)
चरण 1: अनुबंध को परिभाषित करें—प्रॉम्प्ट और उपकरण
आपका एजेंट मॉडल के साथ अपने अनुबंध जितना ही अच्छा है। सिस्टम प्रॉम्प्ट को छोटा, सख्त और लगातार व्यावहारिक रखें।
सिस्टम प्रॉम्प्ट, डिस्टिल्ड:
- आप एक कोडिंग एजेंट हैं। आपका काम उपयोगकर्ता कार्य को संतुष्ट करने के लिए रेपो में छोटे, सही बदलाव करना है।
- एक छिपे हुए स्क्रैचपैड में जोर से सोचें; केवल योजनाओं और डिफ्स को उपयोगकर्ता के सामने उजागर करें।
- न्यूनतम डिफ्स, वर्किंग टेस्ट और वृद्धिशील प्रगति पसंद करें।
- जब अनिश्चित हों, तो एक प्रयोग का प्रस्ताव करें और इसे चलाएं।
- कभी भी फ़ाइलें या कमांड न बनाएं—संपादित करने से पहले सूची और पढ़ें।
उपकरण स्कीमा (इसके बारे में ज्यादा न सोचें):
- read_file(path, offset?, length?)
- write_file(path, content, create_if_missing=false)
- run_cmd(command, timeout=60, cwd=repo_root)
- search_code(query, path=repo_root, max_results=50)
वैकल्पिक अच्छाइयां: git_diff और git_revert(sha) यदि आप हाथों से मुक्त रोलबैक चाहते हैं। आप एक वेक्टर स्टोर छोड़ सकते हैं; अधिकांश उपयोगी कार्य काम करने वाली मेमोरी में कुछ फ़ाइलों और एक त्वरित खोज पर निर्भर करते हैं।
चरण 2: संदर्भ को दुबला रखें
संदर्भ स्टफिंग एजेंट डिजाइन का कार्गो कल्ट है। अपने पूरे मोनोरपो को प्रॉम्प्ट में न डालें। इसके बजाय:
- रेपो सारांश: एक पैराग्राफ README डाइजेस्ट; एंट्री पॉइंट; टेस्ट रनर कमांड।
- सक्रिय फ़ाइलें: केवल वे फ़ाइलें जिन्हें एजेंट स्पर्श करने की योजना बना रहा है—आवश्यकतानुसार उन्हें चंक्स में पढ़ें।
- कार्य: उपयोगकर्ता लक्ष्य, कुरकुरी तरह से वाक्यांशित: "tests/foo_test.py में विफल परीक्षण FooTest.test_bar को ठीक करें।"
- बाधाएं: रनटाइम सीमाएं, फ़ाइल लिखने की श्वेतसूची, शैली नियम और यदि लागू हो तो सिमेंटिक संस्करण अपेक्षाएं।
- हाल का इतिहास: अंतिम दो डिफ और उनके परीक्षण परिणाम। और कुछ नहीं।
4.5 search_code और read_file के माध्यम से जरूरत पड़ने पर अधिक संदर्भ लाने में पूरी तरह से सक्षम है। उसे नक्शा दें, क्षेत्र नहीं।
चरण 3: लूप (अवलोकन → योजना → अभिनय → चिंतन)
- अवलोकन: निर्देशिकाओं को सूचीबद्ध करके, विफल परीक्षण, परीक्षण के तहत कोड और त्रुटि लॉग को पढ़कर प्रारंभ करें। को दो या तीन बुलेट में विफलता के लक्षणों को संक्षेप में बताने के लिए कहें।
- योजना: को इसके साथ एक योजना प्रस्तावित करें:
- निरीक्षण या संपादित करने के लिए फ़ाइलें
- प्रयास करने के लिए न्यूनतम डिफ्स
- मान्य करने के लिए एक परीक्षण कमांड
- अभिनय: write_file के माध्यम से प्रस्तावित डिफ लागू करें। डिफ को अक्षरशः दिखाएं। परीक्षण चलाएं।
- चिंतन: stdout/stderr को वापस फ़ीड करें। से पूछें: आगे बढ़ें, रोल बैक करें या बंद करें? यदि योजना बदलती है, तो वास्तविक आउटपुट का हवाला देते हुए एक वाक्य औचित्य की आवश्यकता होती है।
- निकास: परीक्षण पास होने पर, या एन पुनरावृत्तियों के बाद, जो भी पहले आए, बंद करें।
यह महिमा मंडित जोड़ी प्रोग्रामिंग है जहां आप वास्तव में जोड़ी को ईमानदार रखते हैं।
चरण 4: गार्डरेल जो आपके सप्ताहांत को बचाते हैं
- श्वेतसूची लिखें: केवल src/, lib/ या स्पष्ट रूप से स्वीकृत पथों के भीतर लिखने की अनुमति दें।
- डिफ आकार सीमा: प्रति चरण 200-500 लाइनों तक संपादन कैप करें। यदि बड़ा है, तो उप-चरणों में विभाजित करें।
- कमांड अनुमति सूची: परीक्षण धावक, लिंटर और कुछ देव स्क्रिप्ट। नेटवर्क पर प्रतिबंध लगाएं। आप पुनरुत्पादन क्षमता चाहते हैं, न कि वाइल्ड-वेस्ट कर्ल।
- टाइमआउट और पुन: प्रयास: लघु टाइमआउट, एक पुन: प्रयास अधिकतम—अंतहीन पुन: चलाने वाले लूप वह जगह हैं जहां एजेंट मरने जाते हैं।
- ड्राई रन मोड: प्रस्तावित डिफ प्रिंट करें लेकिन लिखें नहीं। कोड समीक्षा के लिए बढ़िया।
यदि आप उन्हें स्पष्ट करते हैं तो 4.5 नियमों का पालन करेगा। यदि आप नहीं करते हैं, तो आश्चर्यचकित न हों जब यह 2017 के किसी ब्लॉग पोस्ट के अनुरूप होने के लिए आपके पूरे रेपो को पुनर्गठित करके "मदद" करने का प्रयास करता है।
चरण 5: मेमोरी जो वास्तव में उपयोगी है
अल्पकालिक मेमोरी 80% समस्या का समाधान करती है। रखना:
- वर्तमान परिकल्पना और योजना के लिए एक स्क्रैचपैड।
- इस सत्र में छुई गई फ़ाइलों की एक सूची।
4.5 को सुसंगत रूप से तर्क करने के लिए इतना पर्याप्त है। दीर्घकालिक मेमोरी—कार्य लॉग, एम्बेडिंग—आवर्ती कोडबेस के लिए सहायक हो सकती है, लेकिन इसे वैकल्पिक चीनी के रूप में मानें। यदि आपका एजेंट 500MB वेक्टर इंडेक्स के बिना किसी परीक्षण को ठीक नहीं कर सकता है, तो यह एक एजेंट नहीं है—यह एक निर्भरता है।
न्यूनतम कार्यान्वयन स्केच
स्यूडोकोड शब्दों में, आप इस एजेंट को कुछ सौ लाइनों में कार्यान्वित कर सकते हैं:
- initialize: रेपो मेटाडेटा, बाधाओं और मॉडल क्लाइंट लोड करें
- observe: विफल परीक्षण, फ़ाइलें, लॉग पढ़ें
- plan = model.propose_plan(context)
- while not done and steps < MAX:
- diff = model.propose_patch(plan)
- show(diff); maybe approve
- out = run_cmd(plan.test_cmd)
- reflect = model.evaluate(out)
- if reflect == pass: done = true
- else if reflect == rollback: git_revert(last_commit)
- else: plan = model.revise_plan(out)
आप लापता भागों को नोटिस करेंगे: एजेंटों का प्रबंधन करने वाले कोई एजेंट नहीं, कोई "प्रतिनिधि" नहीं, कोई अलग "योजनाकार मॉडल" और "निष्पादक मॉडल" नहीं। यदि आप इसे रूबे गोल्डबर्ग तंत्र से तोड़फोड़ नहीं करते हैं तो 4.5 दोनों काम ठीक कर सकता है।
प्रॉम्प्टिंग जो बहुत कोशिश नहीं करती है
खराब प्रॉम्प्ट चतुर होने की कोशिश करते हैं। अच्छे प्रॉम्प्ट उबाऊ और विशिष्ट होते हैं। यहां आपके मुख्य निर्देश ब्लॉक के लिए एक समझदार कंकाल है:
- लक्ष्य: सटीक कोडिंग कार्य और सफलता मानदंड बताएं।
- संदर्भ: परियोजना संरचना, प्रवेश बिंदु और परीक्षण कमांड।
- बाधाएं: श्वेतसूची लिखें, डिफ आकार सीमा, कोई नेटवर्क नहीं।
- शैली प्राथमिकताएं: भाषा संस्करण, स्वरूपक, लिंटर नियम।
- प्रक्रिया: अवलोकन → योजना → अभिनय → चिंतन; डिफ दिखाएं; परीक्षण चलाएं; एन चरणों तक दोहराएं; परीक्षण पास होने पर बंद करें।
इस संरचना के साथ, 4.5 को 100-लाइन रोल-प्ले परिदृश्य की आवश्यकता नहीं होगी। यह बस काम करता है।
व्यावहारिक उदाहरण: एक विफल परीक्षण ठीक करें
मान लीजिए कि tests/time_test.py में एक परीक्षण विफल हो रहा है क्योंकि parse_time("09:00") 32400 के बजाय 5400 लौटाता है। एजेंट का लूप इस तरह दिखना चाहिए:
- अवलोकन: time.py और time_test.py पढ़ें; pytest -k parse_time चलाएं।
- योजना: परिकल्पना—सेकंड बनाम मिनट गणित बग; parse_time को संपादित करने का प्रस्ताव; इकाई किनारा मामला जोड़ें।
- अभिनय: parse_time पैच करें, अग्रणी-शून्य घंटे के लिए एक परीक्षण जोड़ें; परीक्षण चलाएं।
- चिंतन: यदि परीक्षण अभी भी विफल होते हैं, तो त्रुटि पढ़ें, गणित या regex समायोजित करें, पुन: चलाएं।
न्यूनतम सफल पैच दो-लाइन परिवर्तन हो सकता है। यही तो बात है। छोटे संपादन, तेज चक्र, वास्तविक प्रगति।
जहां हल्का रसोई सिंक को मात देता है
- विलंबता: एक मॉडल, एक लूप, कोई ऑर्केस्ट्रेशन ओवरहेड नहीं।
- पारदर्शिता: प्रत्येक चरण ऑडिट योग्य है। आप इसे डिफ कर सकते हैं, आप इसे वापस कर सकते हैं, आप इसे पुन: चला सकते हैं।
- नियंत्रण: गार्डरेल क्षति को स्थानीय रखते हैं। एजेंट आपके बुनियादी ढांचे में भटक नहीं सकता।
- लागत: कम कॉल, कम संदर्भ, अनुमानित टोकन।
- यूएक्स: आप इसे समझते हैं। आपके टीम के साथी इसे समझते हैं। आपका भविष्य का स्व आपसे नफरत नहीं करेगा।
और ट्रेड-ऑफ:
- चौड़ाई: एक हल्का कोडिंग एजेंट एक ही पास में आपके पांच-भाषा मोनोरपो को रिफैक्टर नहीं करेगा। न ही इसे करना चाहिए।
- पहल: यह बहु-सप्ताह के रोडमैप का आविष्कार नहीं करेगा। आप इसे कार्य देते हैं।
- स्टेटफुलनेस: एक बड़ी मेमोरी परत के बिना, यह डिजाइन द्वारा दूर के इतिहास को भूल जाता है। यह एक विशेषता है जब तक कि यह एक बग न हो।
कोडिंग एजेंटों के लिए 4.5 का स्वीट स्पॉट
4.5 इसमें चमकता है:
- डिफ और लॉग के बारे में पढ़ना और तर्क करना।
- सुसंगत, न्यूनतम कोड परिवर्तन का उत्पादन।
- बाधाओं का पालन करना और अनिश्चितता के बारे में स्पष्ट होना।
यह इसमें कम महान है:
- एपीआई व्यवहार का अनुमान लगाना जिसे वह पढ़ नहीं सकता है।
- भारी उपकरण कोरियोग्राफी (यहां आवश्यक नहीं)।
- मानव मार्गदर्शन के बिना लंबे समय तक बहु-फ़ाइल रिफैक्टर।
अंतिम बिंदु महत्वपूर्ण है। मजबूत परिणाम प्राप्त करने का सबसे अच्छा तरीका एजेंट को बड़ा बनाना नहीं है—यह कार्य को छोटा बनाना है। स्कोपिंग के लिए अपने मस्तिष्क का उपयोग करें, और उस दायरे के भीतर निष्पादन के लिए 4.5 का उपयोग करें।
आईडीई एकीकरण पर एक शब्द
पचास टॉगल के साथ इसे सीधे एक आईडीई फलक में बेक करने की इच्छा का विरोध करें। सादे पाठ डिफ्स के साथ एक टर्मिनल-आधारित लूप पर भरोसा करना और डिबग करना आसान है। यदि आप संपादक चीनी चाहते हैं, तो इसे बेवकूफ रखें:
- लूप शुरू/बंद करने के लिए कमांड।
- एक स्प्लिट व्यू में डिफ दिखाएं।
- लिखने के लिए अनुमोदन प्रॉम्प्ट (वैकल्पिक लेकिन बुद्धिमान)।
आप बाद में एकीकृत कर सकते हैं। पहले, इसे काम करें।
Sider.AI, कम मात्रा में उपयोग किया गया, वास्तव में मदद करता है यदि आप मचान को फिर से आविष्कार किए बिना इस तरह के लूप को चलाने के लिए एक व्यावहारिक वातावरण चाहते हैं, तो Sider.AI वास्तव में काम करता है—कम से कम तब जब आप इसका उपयोग उस चीज़ के लिए करते हैं जिसमें यह अच्छा है। यह बातचीत और डिफ को साफ रखता है, आपको कमांड चलाने देता है, और आपको कुछ भव्य "स्वायत्त एजेंट ढांचे" को मजबूर नहीं करता है। चाल अपने स्वयं के नियमों को बनाए रखना है: छोटे प्रॉम्प्ट, तंग लूप, दृश्यमान डिफ। रास्ते से हट जाता है, जो इससे दुर्लभ है। सामान्य नुकसान (और बेवकूफ दिखने से कैसे बचें)
- अतिभारित संदर्भ: यदि आपका प्रॉम्प्ट फिरौती नोट की तरह पढ़ता है, तो आप इसे गलत कर रहे हैं। मांग पर फ़ाइलें प्राप्त करें।
- समय से पहले रिफैक्टरिंग: एजेंट मॉड्यूल को पुनर्गठित करने का सुझाव देता है? पहले इसे परीक्षण पास कराएं। बाद में रिफैक्टर करें।
- मतिभ्रमित फ़ाइलें: एक नए पथ पर किसी भी write_file से पहले list_dir और read_file की आवश्यकता होती है।
- अनंत पुन: चलाने वाले लूप: चरणों को कैप करें। प्रत्येक नई परिकल्पना के लिए औचित्य की मांग करें।
- एक विशाल डिफ: परिवर्तन विभाजित करें। छोटे डिफ तेजी से विफल होते हैं और उनके बारे में तर्क करना आसान होता है।
बिना पैरानोइया के सुरक्षा और सुरक्षा
- स्थानीय निष्पादन: एक सैंडबॉक्स वाली निर्देशिका में चलाएं। डिफ़ॉल्ट रूप से कोई नेटवर्क नहीं।
- निर्भरता अलगाव: एक स्थानीय venv या कंटेनर का उपयोग करें। संस्करणों को पिन करें।
- रहस्य: एजेंट को उनकी आवश्यकता नहीं है। यदि कोई कमांड टोकन की मांग करता है, तो रुकें और पूछें।
- ऑडिटिंग: प्रत्येक योजना, डिफ और कमांड को एक लॉग में बनाए रखें।
यह कैसे पता चलेगा कि यह काम कर रहा है
- लीड टाइम सिकुड़ जाता है: बगफिक्स जिसमें एक घंटा लगता था अब दस मिनट लगते हैं।
- कम मोटी-उंगली की गलतियाँ: डिफ छोटे हो जाते हैं, परीक्षण हरे हो जाते हैं।
- आप इस पर भरोसा करते हैं: आप हर कार्रवाई पर मंडराना बंद कर देते हैं क्योंकि इसने आपको जलाया नहीं है।
- टीम के साथी इसका उपयोग करते हैं: सफलता की परिभाषा यह है कि अन्य लोग एक बैठक के बिना इसे अपनाते हैं।
ध्यान से ऊपर उठाना
यदि आपको वास्तव में स्केल करना है, तो इसे अनुशासन के साथ करें:
- समानांतर मस्तिष्क नहीं, समानांतर उप-कार्य: काम को विभाजित करें, अलग-अलग निर्देशिकाओं में कई हल्के लूप चलाएं, और हरे होने पर मर्ज करें।
- एपिसोडिक मेमोरी, मस्तिष्क डंप नहीं: सफल पैच और लक्षणों से लेकर फिक्स मैपिंग तक स्टोर करें। शल्य चिकित्सा से पुनः प्राप्त करें।
- आवधिक "बड़े" पास: रिफैक्टर के लिए मानव-निर्देशित सत्र आरक्षित करें; एजेंट सहायता करता है, नेतृत्व नहीं करता।
न्यूनतम संदर्भ कार्यान्वयन (स्केच)
स्थानांतरित होने के लिए पायथन-ish स्यूडोकोड:
- def init(self, repo_root, model):
- self.history = [] # अंतिम दो डिफ और परीक्षण आउटपुट
- "repo": summarize_repo(self.root),
- "constraints": {"write_whitelist": ["src/", "tests/"], "max_diff_lines": 300, "no_network": True},
- "history": self.history[-2:],
- plan = self.model("propose_plan", self.context(task))
- diff = self.model("propose_patch", {"plan": plan})
- out = run_cmd(plan.test_cmd)
- eval = self.model("evaluate", {"output": out, "plan": plan})
- self.history.append({"diff": diff, "out": tail(out)})
एक मानव-आकार का अंत
उद्योग स्वायत्त डेवलपर एजेंटों का वादा करता रहता है। हमें वास्तव में एक ईमानदार सहायक की आवश्यकता है जो पढ़े, योजना बनाए, संपादित करे, चलाए और बंद करे। 4.5 इसमें अच्छा है, बशर्ते आप इसे ऐसे ढांचे के नीचे न दबाएं जो ज्यादातर खुद को सही ठहराने के लिए मौजूद हैं। हल्का एक समझौता नहीं है—यह बिंदु है। लूप बनाएं, गार्डरेल जोड़ें, और टूल को वह एक चीज़ करने दें जो टूल ने हमेशा की है जब आप उन्हें सरल रखते हैं: काम को छोटा बनाएं।
निष्कर्ष: उबाऊ शॉर्टकट जो जीतता है
यहां 4.5 के साथ एक हल्के कोडिंग एजेंट के लिए आपकी चेकलिस्ट दी गई है:
- एक लूप, एक मॉडल, छोटे उपकरण।
- तंग संदर्भ: कार्य, कुछ फ़ाइलें, अंतिम आउटपुट।
- न्यूनतम डिफ, लगातार परीक्षण, हार्ड कैप।
- स्थानीय, सैंडबॉक्स निष्पादन; कोई नेटवर्क नहीं।
- वैकल्पिक संपादक चीनी; कभी आवश्यक नहीं।
यदि आप तिरछी नज़र से देखते हैं, तो यह संदिग्ध रूप से अच्छे सॉफ़्टवेयर इंजीनियरिंग की तरह दिखता है, बस तेज़। और यही पंचलाइन है। यहाँ आप जो सबसे चतुर काम कर सकते हैं, वह "स्वायत्तता" का पीछा करना नहीं है—यह अनुशासन को संहिताबद्ध करना है। आप एजेंट से जितना कम पूछते हैं, उतना ही अधिक आपको मिलता है।
सामान्य प्रश्न
Q1: मैं 4.5 के साथ एक हल्का कोडिंग एजेंट बनाना कैसे शुरू करूं?
एक छोटा उपकरण सेट (पढ़ें, लिखें, खोजें, चलाएं) परिभाषित करें, एक सख्त सिस्टम प्रॉम्प्ट लिखें, और एक अवलोकन → योजना → अभिनय → चिंतन लूप को कार्यान्वित करें। संदर्भ को छोटा रखें और वास्तविक लॉग और डिफ को फ़ीड करें— 4.5 तब सबसे अच्छा प्रदर्शन करता है जब कार्य संकीर्ण होता है और प्रतिक्रिया ठोस होती है।
Q2: क्या मुझे 4.5 कोडिंग एजेंट के लिए वेक्टर डेटाबेस या मेमोरी लेयर की आवश्यकता है?
नहीं। अधिकांश कार्यों के लिए, अल्पकालिक मेमोरी प्लस search_code पर्याप्त है। दीर्घकालिक मेमोरी तभी जोड़ें जब आप बार-बार एक ही रेपो पर जाते हैं और यह साबित कर सकते हैं कि यह एजेंट को गूंगा बनाए बिना टोकन बचाता है।
Q3: 4.5 कोडिंग एजेंट के लिए कौन से गार्डरेल आवश्यक हैं?
लिखने योग्य पथों को श्वेतसूची में डालें, डिफ आकार को कैप करें, कमांड को प्रतिबंधित करें और प्रत्येक क्रिया को लॉग करें। ये सरल सीमाएं एजेंट को अनुमानित रखती हैं और रोलबैक को उबाऊ बनाती हैं—एक अच्छे तरीके से।
Q4: क्या एक हल्का एजेंट बहु-फ़ाइल रिफैक्टर को संभाल सकता है?
हाँ, यदि आप काम को छोटे चरणों में विभाजित करते हैं और लूप को तंग रखते हैं। 4.5 रिफैक्टर का प्रबंधन कर सकता है, लेकिन आप स्कोप का मार्गदर्शन करते हैं; अन्यथा आपको एक विशाल, भंगुर डिफ मिलेगा जिसे आप समीक्षा नहीं करना चाहेंगे।
Q5: 4.5 कोडिंग एजेंट के साथ Sider.AI कहां फिट बैठता है?
Sider.AI एक साफ-सुथरे कार्यक्षेत्र के रूप में उपयोगी है: बातचीत, डिफ और कमांड एक ही स्थान पर, भारी एजेंट ढांचे को मजबूर किए बिना। इसका उपयोग अपना लूप चलाने के लिए करें, न कि इसे फिर से बनाने के लिए। 
