परिचय: तो एजंट ज्याची सगळी आवड आहे, परंतु हायपशिवाय
कोडिंग एजंटाबद्दलची गोष्ट अशी आहे की बहुवेला ते तुमचे बॉस, तुमचे सह-चालक आणि तुमचे मनोविश्लेषक होण्याचा प्रयत्न करतात—नंतर फक्त कोड लिहिणे विसरतात. याचे पारंपारिक मार्गदर्शन असे आहे: अनेक व्हेक्टर स्टोअर्स जोडा, काही ऑर्केस्ट्रेशन कौशल्याचा वापर करा, ब्राउझर जोडा आणि मग काम संपले समजा. हे प्रदर्शन चांगले होते. पण ते अवघड होते जेव्हा तुम्ही त्याला शुक्रवारी संध्याकाळी ४:५२ वाजता एखादा अप्रत्याशित इंटिग्रेशन टेस्ट दुरुस्त करण्यास सांगता.
Claude 4.5 वापरून एक हलका कोडिंग एजंट बनवणे—हा आश्चर्य म्हणजे—खरंच सोपा आहे जर तुम्ही सार्वत्रिक सॉफ्टवेअर बटलरच्या स्वप्नाचा पाठलाग थांबवून फक्त असा एक टूल तयार करता जो कोड वाचते, योजना आखते, संपादित करते, चालवते, आणि पुन्हा करतो. “AI विकसकांची जागा घेईल” यावर काही उपदेश नाही. कोणतेही गुंतागुंतीचे पाईपलाईन्स नाहीत. फक्त एक सुसंगत प्रक्रिया जी स्पष्ट गोष्टी चांगल्या प्रकारे करते.
ही कशी करावी या बद्दलची मार्गदर्शक आहे ज्यासाठी तुम्हाला संपूर्ण AI ऑपरेशन्स विभाग सामावून घ्यावा लागत नाही. आपण Claude 4.5 डोक्याला वापरू, फाईल सिस्टम आणि शेल हातांसाठी, आणि लहान मेमरी अल्पकालीन लक्षासाठी. एवढेपण. हलकी बनावट म्हणजे तुम्ही एका सत्रात ते समजू शकता, स्थानिकरित्या चालवू शकता, आणि प्रत्येक टप्पा तपासण्यास शक्य असल्यामुळे त्यावर विश्वास ठेवू शकता. जे, जर तुम्ही अलीकडे यासारखे काही वापरले असेल, तर ते जवळजवळ खोडकर आहे.
Claude 4.5 का मिनिमल एजंटसाठी कार्य करते
Claude 4.5 मध्ये कोडसाठी लागणारे योग्य स्वभाव आहे: सूचनांचे पालन काळजीपूर्वक करते, बदल (diffs) वाचण्यात आश्चर्यकारकपणे चांगले, आणि ज्या फ्रेमवर्कची मागणी केली नाही ती कल्पना करत नाही. हा मॉडेल टप्प्याटप्प्याने विचार करण्यास सक्षम आहे आणि संपूर्ण प्रॉम्प्टची गरज नाही. ही संयुती—चर्चा आणि संयम—Claude 4.5 ला कोडिंग एजंटच्या लूपसाठी आदर्श बनवते:
- निरीक्षण: चालू फाइल्स, त्रुटी लॉग आणि टेस्ट वाचा.
- योजना: कारणांसह ठोस संपादने प्रस्तावित करा.
- क्रिया: फाइल्स दुरुस्त करा, कमांड चालवा.
- पुनरावलोकन: आउटपुटचे मूल्यांकन करा, पुनरावृत्ती करा किंवा थांबा.
हे कोणत्याही रेपोवर लावू शकता आणि दुपारी मधेच परिणाम मिळवू शकता. याचा चांगला फायदा म्हणजे याला 'AI प्लॅटफॉर्म' मध्ये रूपांतरित करू नका. जर तुम्ही एजंट हलका ठेवला, तर Claude 4.5 जबाबदाऱ्या परिपूर्णपणे पार पाडेल आणि तुमच्या मार्गात येणार नाही.
हलकी आर्किटेक्चर: पाच भाग, कोणतेही नाटक नाही
तुम्हाला पूर्ण स्टॅक हवे आहे:
- कोर लूप: एक प्रक्रिया ज्यात Claude 4.5 कॉल केला जातो आणि त्याच्या टूल-युज मेसेजेसचे विश्लेषण केले जाते.
- टूल्स: एक लहान संच - read_file, write_file, list_dir, run_tests (किंवा run_cmd), search_code.
- कंटेक्स्ट बिल्डर: रेपो मेटाडेटा आणि अलीकडील diffs सह एक लहान, लक्ष केंद्रित प्रॉम्प्ट तयार करा.
- शॉर्ट-टर्म मेमरी: चालू संभाषण विंडो आणि योजना व निर्बंधांसाठी स्पष्ट स्क्रॅचपॅड.
- गार्डरेल्स: टोकन, वेळ, आणि फाइल लिहिण्याच्या मर्यादा; ड्राय-रन मोड; आणि रोलबॅक स्नॅपशॉट.
फक्त एवढच. तुम्ही टर्मिनलमध्ये हेडलेस चालवू शकता किंवा आवश्यक असल्यास एक लहान UI देऊ शकता. हे काम का करते ते खूप सोपे आहे: प्रत्येक क्रिया निरीक्षणीय आणि सत्यापनीय आहे. एजंट बदल सुचवतो, diff दाखवतो, चाचण्या चालवतो, आउटपुट वाचतो आणि पुढे सुरू ठेवतो किंवा थांबतो. यामध्ये काही अदृश्य प्रक्रियेचा समावेश नाही.
एजंट बनवण्याची पद्धत (कथानक गमावू नका)
पहिले पाऊल: करार निश्चित करा—प्रॉम्प्ट आणि टूल्स
तुमचा एजंट हा मॉडेलशी त्याच्या कराराइतकाच चांगला असतो. सिस्टम प्रॉम्प्ट लहान, कठोर, आणि अत्यंत व्यावहारिक ठेवा.
सिस्टम प्रॉम्प्ट, संक्षेप:
- तुम्ही एक कोडिंग एजंट आहात. तुमचे काम वापरकर्त्याच्या टास्कसाठी रेपोमध्ये लहान, अचूक बदल करणे आहे.
- गुप्त स्क्रॅचपॅडमध्ये विचार मोकळा करा; वापरकर्त्याला फक्त योजना आणि diffs दाखवा.
- किमान diffs, कार्यरत चाचण्या, व प्रगती आवडीत ठेवा.
- अशक्य असल्यास, प्रयोग प्रस्तावित करा आणि चालवा.
- कधीही फाइल्स किंवा कमांड्स बनावट करू नका—लिहिण्यापूर्वी लिस्ट आणि वाचा.
टूल स्कीमा (जास्त विचार करू नका):
- 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) जर तुम्हाला स्वयंचलित रोलबॅक्स पाहिजेत. तुम्ही व्हेक्टर स्टोअर टाळू शकता; बहुतेक उपयुक्त टास्क केवळ कामाच्या मेमरीतील काही फाइल्स आणि जलद शोधावर अवलंबून असतात.
दुसरे पाऊल: कंटेक्स्ट राखा सूक्ष्म
कंटेक्स्ट भरणे हे एजंट डिझाइनमधील एक गैरप्रकार आहे. संपूर्ण मोनोरिपो प्रॉम्प्टमध्ये टाकू नका. त्याऐवजी:
- रेपो सारांश: एक परिच्छेदाच्या README सारांश; प्रवेश बिंदू; टेस्ट रनर कमांड.
- सक्रिय फाइल्स: केवळ त्या फाइल्स ज्या एजंटला संपादित करायच्या आहेत—आवश्यकतेनुसार त्यांना तुकड्यांमध्ये वाचा.
- टास्क: वापरकर्त्याचा उद्देश, स्पष्ट स्वरूपात: “tests/foo_test.py मध्ये अपयशी टेस्ट FooTest.test_bar दुरुस्त करा.”
- मर्यादा: रनटाइम मर्यादा, फाइल लिहिण्याची यादी, शैली नियम, आणि सेमँटिक व्हर्जनिंग अपेक्षा (जर लागू असेल).
- अलीकडील इतिहास: मागील दोन diffs आणि त्यांच्या टेस्ट निकालांसह. काहीही अधिक नाही.
Claude 4.5 प्रोम्प्टमध्ये आवश्यक तेव्हा search_code आणि read_file वापरून अधिक संदर्भ मिळवू शकते. त्याला नकाशा द्या, जमीन नाही.
तिसरे पाऊल: लूप (निरीक्षण → योजना → क्रिया → पुनरावलोकन)
- निरीक्षण: डिरेक्टरीज लिस्ट करा, अपयशी टेस्ट, कोड आणि त्रुटी लॉग वाचा. Claude ला दोन-तीन बिंदूंत अपयशाची लक्षणे सारांशित करण्यास सांगा.
- योजना: Claude ला खालीलांसाठी योजना सुचवा:
- निरीक्षण/संपादन करण्यास फाइल्स
- कोणत्या किमान diffs प्रयत्न करायची आहेत
- क्रिया: write_file द्वारे सुचवलेला diff लागू करा. diff स्पष्टपणे दाखवा. चाचण्या चालवा.
- पुनरावलोकन: stdout/stderr परत फीड करा. Claude ला विचारा: पुढे जा, रोलबॅक करा, की थांबा? जर योजना बदलली तर प्रत्यक्ष आउटपुट संदर्भ देऊन एक वाक्य स्पष्टीकरण आवश्यक आहे.
- बाहेर पडणे: चाचण्या उत्तीर्ण झाल्यावर किंवा N पुनरावृत्त्यांपुढे थांबा, जे आधी झाले तरी चालेल.
हे एक विलक्षण जोडपे प्रोग्रामींग आहे ज्यात वास्तवात तुम्ही याला प्रामाणिक ठेवता.
चौथं पाऊल: गंमत वाचवणारे गार्डरेल्स
- लिखाणाची यादी: केवळ src/, lib/, किंवा स्पष्टपणे मान्य केलेल्या मार्गांवरच लिहिण्याची परवानगी.
- diff आकार मर्यादा: प्रत्येक टप्प्यात २००–५०० ओळींपर्यंत बदलांची मर्यादा. अधिक असल्यास उपटप्प्यांमध्ये विभागा.
- कमांड परवानगी यादी: टेस्ट रनर्स, लिन्टर्स, आणि काही विकास स्क्रिप्टस. नेटवर्क बंद करा. तुम्हाला पुनरुत्पादनियता हवी आहे, स्वातंत्र्य नाही.
- टाइमआउट आणि पुनःप्रयत्न: लहान टाइमआउट, जास्तीतजास्त एक पुनःप्रयत्न—अमर्याद पुनरावृत्ती एजंटच्या मृत्यूचे कारण.
- ड्राय रन मोड: प्रस्तावित diff मुद्रित करा पण लिहू नका. कोड पुनरावलोकनासाठी उत्तम.
Claude 4.5 नियमांचे पालन करेल जर तुम्ही ते स्पष्ट केले. जर नाही तर हे अपेक्षा करू नका की तो एखाद्या २०१७ च्या ब्लॉगपोस्टसारख्या सर्व रेपो पुनर्रचना करून मदत करेल.
पाचवे पाऊल: खुप उपयोगी मेमरी
शॉर्ट-टर्म मेमरी समस्या ८०% सोडवते. ठेवा:
- सध्याच्या अनुमान आणि योजनेचा स्क्रॅचपॅड.
- या सत्रात संपादित केल्या गेलेल्या फाइल्सची यादी.
- मागील दोन कमांड आउटपुट्स.
यासाठी Claude 4.5 चांगले विचार करू शकते. लाँग-टर्म मेमरी—टास्क लॉग, एम्बेडिंग—वारंवार कोडबेसेससाठी उपयुक्त, पण ऐच्छिक आहे. जर तुमचा एजंट ५००MB वेक्टर इंडेक्सशिवाय टेस्ट दुरुस्त करू शकत नसेल, तर ते एजंट नाही—ती dependency आहे.
किमान क्रियान्वयन आराखडा
प्स्यूडोकॉडमध्ये, हा एजंट काहीशे ओळींच्या आत साधारणपणे लिहिता येतो:
- इनिशियलाइझ करा: रेपो मेटाडेटा, निर्बंध आणि मॉडेल क्लायंट लोड करा
- निरीक्षण करा: अपयशी टेस्ट, फायली, लॉग्स वाचा
- योजना = model.propose_plan(context)
- जमलेल्या नसल्यास आणि पावले MAX पेक्षा कमी असतील तेव्हांपर्यंत:
- diff = model.propose_patch(plan)
- diff दाखवा; कदाचित मान्यता द्या
- आउट = run_cmd(plan.test_cmd)
- reflect = model.evaluate(out)
- जर reflect == pass तर: done = true
- else if reflect == rollback: git_revert(last_commit)
- else: plan = model.revise_plan(out)
तुम्ही पाहाल की काही भाग गायब आहेत: एजंट्सना एजंट्सच्या व्यवस्थापनाची गरज नाही, 'delegate' नाहीत, 'planner' आणि 'executor' मॉडेल्स वेगळे नाहीत. Claude 4.5 या दोन्ही कामे छान पार पाडतो जर तुम्ही याला विनाकारण जटिलता आणली नाही.
प्रॉम्प्ट जे खूप जास्त प्रयत्न करत नाही
वाईट प्रॉम्प्ट्स हुशार बनण्याचा प्रयत्न करतात. चांगले प्रॉम्प्ट्स कंटाळवाणे आणि विशिष्ट असतात. तुमच्या मुख्य सूचना ब्लॉकसाठी ही एक सुरक्षित जाळी आहे:
- उद्दिष्ट: नेमकी कोडिंग टास्क व त्याची यशस्वी निकषे सांगा.
- कंटेक्स्ट: प्रोजेक्ट संरचना, प्रवेश बिंदू, व टेस्ट कमांड.
- मर्यादा: लिखाणासाठी यादी, diff आकार मर्यादा, नेटवर्क बंद.
- शैली पसंती: भाषा आवृत्ती, फॉर्मॅटर, लिन्टर नियम.
- प्रक्रिया: निरीक्षण → योजना → क्रिया → पुनरावलोकन; diffs दाखवा; चाचण्या चालवा; N टप्प्यांपर्यंत पुनरावृत्ती; चाचण्या पास झाल्यावर थांबा.
Claude 4.5 या संरचनेसह १०० ओळींच्या भूमिकाप्रमाणे परिस्थितीची गरज नाही. तो सहज काम करतो.
व्यावहारिक उदाहरण: अपयशी टेस्ट दुरुस्त करा
समजा, tests/time_test.py मध्ये एक टेस्ट अपयशी होत आहे कारण parse_time("09:00") ५४०० (seconds) परत देते, जेथून अपेक्षित होते ३२४००. एजंटचा लूप असे दिसेल:
- निरीक्षण: time.py आणि time_test.py वाचा; pytest -k parse_time चालवा.
- योजना: अपयशाची अनुमान—सेकंद विरुद्ध मिनिट गणिताची चूक; parse_time संपादित करण्याची सूचना; युनिट एज केस जोडा.
- क्रिया: parse_time दुरुस्त करा, लीडिंग-झिरो तासासाठी चाचणी जोडा; चाचण्या चालवा.
- पुनरावलोकन: जर चाचण्या अजूनही अपयशी असतील, त्रुटी वाचा, गणित किंवा regex समायोजित करा, पुन्हा चालवा.
किमान यशस्वी दुरुस्ती दोन ओळींचा बदल असू शकतो. याचाच हेतू आहे. लहान बदल, जलद चक्र, प्रत्यक्ष प्रगती.
जिथे हलकी प्रणाली "kitchen sink" पेक्षा श्रेष्ठ आहे
- प्रतिसाद वेळ: एक मॉडेल, एक लूप, कोणतीही अतिरिक्त ऑर्केस्ट्रेशन नाही.
- पारदर्शकता: प्रत्येक टप्पा तपासता येतो. तुम्ही diff करू शकता, रोलबॅक करू शकता, वा पुन्हा चालवू शकता.
- नियंत्रण: गार्डरेल्स नुकसान सीमित ठेवतात. एजंट तुमच्या इन्फ्रास्ट्रक्चरपासून दूर राहतो.
- खर्च: कमी कॉल्स, कमी कंटेक्स्ट, अंदाजित टोकन्स.
- वापरकर्ता अनुभव: तुम्हाला ते समजते. तुमच्या सहकार्यांना समजते. तुमच्या भविष्यातील स्वतःला हे आवडेल.
आणि त्याचे तोटे:
- व्याप्ती: हलका कोडिंग एजंट तुमचा पाच-भाषांचा मोनोरिपो एकाच वेळी पुनर्रचना करणार नाही. तसेच करावेही नाही.
- प्रेरणा: तो बहुसप्ताहिक रोडमॅप तयार करणार नाही. तुम्ही टास्क द्या.
- स्थिती सध्य: मोठी मेमरी नसल्यामुळे दूरच्या इतिहासाला विसरतो. तो ते एक फिचर आहे तोपर्यंत तो बग नाही.
Claude 4.5 चा कोडिंग एजंटसाठी गोडबिंदू
Claude 4.5 हे:
- diffs आणि लॉग्स वाचण्यात व विचार करण्यात चमकतो.
- सुसंगत, कमी कोड बदल तयार करण्यात.
- निर्बंधांचे पालन करण्यात आणि अनिश्चिततेबाबत स्पष्ट राहण्यात.
हे कमी छान करते:
- API वर्तनाचा अंदाज लावणे जे वाचू शकत नाही.
- जड टूल समन्वय (इथे गरज नाही).
- माणसाच्या मार्गदर्शनाशिवाय मोठ्या मल्टी-फाइल पुनर्रचना.
हा शेवटचा मुद्दा महत्त्वाचा आहे. चांगले निकाल मिळवण्याचा सर्वोत्तम मार्ग म्हणजे अजून मोठा एजंट बनवणे नव्हे—टास्क लहान करणे आहे. तुमचा मेंदू वापरा स्कोपिंगसाठी, आणि Claude 4.5 वापरा त्या स्कोपमध्ये अंमलबजावणीसाठी.
IDE इंटिग्रेशन बद्दल एक शब्द
हे थेट IDE पॅनेलमध्ये पन्नास टॉगलसहित समाकलित करण्याचा मोह टाळा. एक टर्मिनल-आधारित लूप आणि साधे टेक्स्ट diffs अधिक सोपे आणि विश्वसनीय खात्रीशीर आहेत. जर तुम्हाला एडिटर साखर हवी असेल, तर ती सादी ठेवा:
- लूप सुरू/थांबवण्यासाठी कमांड्स.
- स्प्लिट व्ह्यू मध्ये diffs दाखवा.
- लिखाणासाठी मान्यता प्रॉम्प्ट (ऐच्छिक पण शहाणपणाचे).
तुम्ही नंतर समाकलित करू शकता. प्रथम, ते कार्यान्वित करा.
Sider.AI, मर्यादित वापर हा खरोखर मदत करतो जर तुम्हाला हा लूप रींवेंट केल्याशिवाय चालवायची प्रामाणिक वातावरण हवा असेल, तर Sider.AI खरंच कार्य करते—किमान जेव्हा तुम्ही ते जे चांगले करते त्यासाठी वापरता. ते संभाषण आणि diffs सुव्यवस्थित ठेवते, तुम्हाला कमांड्स चालवण्याची अनुमती देते, आणि तुम्हाला एखाद्या भव्य “स्वायत्त एजंट फ्रेमवर्क” वर जबरदस्ती करत नाही. युक्ती म्हणजे तुमचे स्वतःचे नियम ठेवा: लहान प्रॉम्प्ट्स, घट्ट लूप्स, दिसणारे diffs. Sider मार्गात येत नाही, जे फारसे नसते. सामान्य चुका (आणि कसे लाजिरवाणं होण्यापासून बचावायचे)
- अत्यधिक भरलेला कंटेक्स्ट: तुमचा प्रॉम्प्ट पाळीपत्रासारखा दिसत असल्यास, तुम्ही चुकीचा रीतीने करत आहात. आवश्यकतेनुसार फाइल्स मिळवा.
- अकालीन पुनर्रचना: एजंट मॉड्यूल पुनर्रचनेची सूचना करत आहे? आधी चाचण्यांनुसार यशस्वी करा. नंतर बदल करा.
- कल्पित फाइल्स: write_file करण्यापूर्वी list_dir आणि read_file आवश्यक आहे.
- अमर्याद पुनरावृत्ती लूप्स: पावले मर्यादित करा. प्रत्येक नवीन अनुमानासाठी स्पष्टीकरण मागा.
- एक प्रचंड diff: बदलांचे विखुरलेले टप्पे करा. लहान diffs जलद अयशस्वी होतात आणि त्यावर तर्क करता येतो.
संरक्षण आणि सुरक्षा भितीशिवाय
- स्थानिक कार्यान्वयन: सॅन्डबॉक्सड डायरेक्टरीमध्ये चालवा. डिफॉल्टमध्ये नेटवर्क नाही.
- डिपेंडेंसी वेगळेपण: स्थानिक venv किंवा कंटेनर वापरा. आवृत्त्या ठाम करा.
- गुपिते: एजंटला त्यांची गरज नाही. जर एखाद्या कमांडसाठी टोकन आवश्यक असेल, थांबा आणि विचारा.
- ऑडिटिंग: प्रत्येक योजना, diff, आणि कमांड लॉगमध्ये जतन करा.
कसे समजावे की ते कार्यरत आहे
- लीड वेळ कमी होते: ज्यांना एका तास लागायचा तो आता दहा मिनिटांत होतो.
- कमी चुका: diffs लहान होतात, चाचण्या हिरव्या होतात.
- तुम्ही त्यावर विश्वास ठेवता: तुम्ही प्रत्येक क्रियेवर लक्ष ठेवणे थांबता कारण त्याने तुम्हाला धोका दिला नाही.
- सहकारी वापरतात: यशाची व्याख्या म्हणजे ते कुठल्याही मीटिंगशिवाय स्वीकारले जाते.
काळजीपूर्वक प्रमाण वाढवणे
जर तुम्हाला खरोखर वाढवायचे असेल, तर शिस्तीने करा:
- सहभागी उपकार्ये, एकाच वेळी अनेक मेंदू नव्हे: काम विभागा, स्वतंत्र डायरेक्टरीजमध्ये अनेक हलके लूप चालवा, आणि ग्रीन झाल्यावर मर्ज करा.
- एपिसोडिक मेमरी, मेंदूचा गोळा नव्हे: यशस्वी पॅचेस आणि समस्यांचे नकाशे साठवा. शस्त्रक्रियेत पुनर्प्राप्त करा.
- नियतकालीन “मोठे” पास: पुनर्रचनेसाठी मानवी मार्गदर्शित सत्र राखा; एजंट मदत करतो, नाही की नेतृत्व.
किमान संदर्भ अंमलबजावणी (स्केच)
Python-सारखे प्स्यूडोकोड जे सुरुवात करण्यासाठी:
- def init(self, repo_root, model):
- self.history = [] # मागील दोन diffs आणि टेस्ट आउटपुट
- "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)})
मानवी आकाराचा शेवट
उद्योग सतत स्वयंचलित विकसक एजंट्सची हमी देतो. पण आपल्याला खरोखर हवे ते आहे एक प्रामाणिक सहाय्यक जो वाचतो, योजना आखतो, संपादित करतो, चालवतो, आणि थांबतो. Claude 4.5 ते छान करतो, जर तुम्ही त्याला अशा फ्रेमवर्कच्या खाली न शेकत ज्याचा बहुतेक उद्देश स्वतःचा न्याय देणे आहे. हलकीच एक तडजोड नाही—ती एक उद्दिष्ट आहे. लूप तयार करा, गार्डरेल्स जोडा, आणि टूल्सना ते एकच काम करा जे ते नेहमीच करतात जेव्हा तुम्ही त्यांना सोपे ठेवता: काम कमी करा.
निष्कर्ष: कंटाळवाणे शॉर्टकट ज्याने विजय मिळवला
हे तुमच्यासाठी Claude 4.5 हा हलका कोडिंग एजंट तयार करण्यासाठी तपासणी यादी आहे:
- एक लूप, एक मॉडेल, लहान टूल्स.
- घट्ट कंटेक्स्ट: टास्क, काही फायली, शेवटचे आउटपुट्स.
- किमान diffs, वारंवार चाचण्या, कठोर मर्यादा.
- स्थानिक, सॅन्डबॉक्सड कार्यान्वयन; नेटवर्क नाही.
- ऐच्छिक संपादक साखर; कधीही आवश्यक नाही.
जर तुम्ही थोडा ताण घेता, तर हे अत्यंत विश्वसनीय सॉफ्टवेअर अभियांत्रिकीप्रमाणे दिसते, फक्त वेगवान. आणि हा मुद्दा आहे. येथे सर्वात हुशार गोष्ट म्हणजे “स्वायत्ततेच्या” मागे न धावता शिस्तीचे नियम ठरवणे. जेवढे कमी तुम्ही एजंटकडून मागता, तेवढे जास्त तुम्हाला मिळते.
वारंवार विचारले जाणारे प्रश्न
Q1: मी Claude 4.5 वापरून हलका कोडिंग एजंट कसा सुरू करू?
लहान टूलसेट (वाचा, लिहा, शोधा, चालवा) ठरवा, कठोर सिस्टम प्रॉम्प्ट लिहा, आणि निरीक्षण → योजना → क्रिया → पुनरावलोकन लूप अंमलात आणा. कंटेक्स्ट लहान ठेवा आणि वास्तविक लॉग्स व diffs द्या—Claude 4.5 उत्तम काम करतो जेव्हा टास्क सीमित आणि फीडबॅक ठोस असतो.
Q2: Claude 4.5 कोडिंग एजंटसाठी मला व्हेक्टर डेटाबेस किंवा मेमरी लेयरची गरज आहे का?
नाही. बर्याच टास्कसाठी, अल्पकालीन मेमरी आणि search_code पुरेसे आहे. दीर्घकालीन मेमरी फक्त तेव्हा जोडा जेव्हा तुम्ही वारंवार तेच रेपो पाहता आणि ते टोकन्स वाचवते असं सिद्ध करू शकता, परंतु एजंट कमी हुशार करण्याशिवाय नाही.
Q3: Claude 4.5 कोडिंग एजंटसाठी कोणते गार्डरेल्स अत्यावश्यक आहेत?
लिखाणाजोग्या मार्गांची यादी, diff आकार मर्यादा, कमांड प्रतिबंध, आणि प्रत्येक कृतीची नोंद येथे. हे सोप्या मर्यादा एजंटला पूर्वसूचित ठेवतात व रोलबॅक्स कंटाळवाणे पण सुरक्षित करतात.
Q4: हलका एजंट मल्टि-फाइल पुनर्रचना हाताळू शकतो का?
होय, जर तुम्ही काम लहान टप्प्यांमध्ये विभागले आणि लूप घट्ट ठेवला. Claude 4.5 पुनर्रचना करू शकतो, पण तुम्ही स्कोप मार्गदर्शन करा; नाहीतर तुम्हाला एक प्रचंड, कमजोर diff मिळेल ज्याला तुम्हाला पाहण्याची इच्छा होणार नाही.
Q5: Sider.AI चे Claude 4.5 कोडिंग एजंटसह स्थान काय आहे?
Sider.AI एक स्वच्छ कार्यक्षेत्र म्हणून उपयुक्त आहे: संभाषणे, diffs, आणि कमांड्स एका ठिकाणी, बिना जड एजंट फ्रेमवर्कने बळजबरी न करता. तुमचा लूप त्या मध्ये चालवा, त्याला पुनःनिर्मित करू नका. 
