Claude Code आता तीन लूप-इंजिनिअरिंग कमांड्स—/loop, /goal आणि /schedule—सादर करत आहे, ज्यामुळे एखादा कोडिंग एजंट मानवाने प्रत्येक पायरी टाईप न करता स्वतःचे प्रॉम्प्ट सायकल चालवू शकतो. हे फिचर डेव्हलपर्सना पुनरावृत्ती होणारे कोडिंग काम स्वयंचलित करण्याची, टोकनचा खर्च नियंत्रणात ठेवण्याची आणि आतापर्यंत AI-असिस्टेड डेव्हलपमेंटमध्ये प्रचलित असलेली “type-prompt-wait-type-prompt” ही लय टाळण्याची संधी देते.
या नवीन कमांड्स का महत्त्वाच्या आहेत
बहुतेक AI-कोडिंग वर्कफ्लो अजूनही मॅन्युअल संवाद (back-and-forth) वर अवलंबून आहेत: डेव्हलपर एक विनंती लिहितो, मॉडेल कोड परत करते, डेव्हलपर तो वाचतो, पुढे काय विचारायचे याचा निर्णय घेतो आणि ही प्रक्रिया पुन्हा पुन्हा करतो. जेव्हा एखादे छोटे काम—जसे की बिल्ड रन करणे, लिंट वॉर्निंग फिक्स करणे किंवा टेस्ट फेल्युअरवर काम करणे—करण्यासाठी डझनभर फेऱ्यांची गरज असते, तेव्हा ही पद्धत संथ, खर्चिक आणि त्रुटीपूर्ण ठरते.
तीन लूप मोड्स
- /loop – एक हलके (lightweight) आणि स्वतःच्या गतीने चालणारे सायकल. यामध्ये Claude चा तोच इन्स्टन्स प्रत्येक फेरी चालवतो आणि “बिल्ड ग्रीन आहे का?” सारखी साधी अट तपासतो. जेव्हा पडताळणीची पायरी अत्यंत सोपी असते आणि चुकीचा “done” सिग्नल मिळण्याचा धोका कमी असतो, तेव्हा हे सर्वोत्तम काम करते.
- /goal – एक उच्च-अचूकता (high-precision) सायकल. प्रत्येक फेरीत एक दुय्यम मॉडेल पूर्णत्वाची अट तपासते, ज्यामुळे तपासणीचा एक अतिरिक्त स्तर मिळतो. जेव्हा अकाली काम पूर्ण झाल्याचे समजणे महाग पडू शकते—उदा. एखादी सुरक्षा-संवेदनशील (security-critical) सर्व्हिस तैनात करणे—तेव्हा याचा वापर करा.
- /schedule – Anthropic च्या इन्फ्रास्ट्रक्चरवर चालणारे क्लाउड-होस्टेड रूटीन. डेव्हलपरचा लॅपटॉप बंद असला तरीही ही लूप प्रक्रिया सुरू राहते.
या तिन्हींची रचना (architecture) समान आहे: एक skill (एजंटला काय करायचे आहे हे सांगणाऱ्या सूचना), एक verifier (काम खरोखर पूर्ण झाले आहे हे सिद्ध करणारी पडताळणी), guardrails (एजंट कोणत्या टूल्सचा वापर करू शकतो यावरील मर्यादा) आणि state (मागील कृतींची हलकी मेमरी). यापैकी कोणताही भाग वगळल्यास, लूप ही एक अनंत स्व-संमती बनते ज्यामुळे फक्त टोकनचा वापर वाढतो.
सुरक्षित आणि खर्च-नियंत्रित लूप तयार करणे
- Skill परिभाषित करा – एक स्पष्ट आणि निश्चित (deterministic) प्रॉम्प्ट लिहा जो एजंटला नेमकी काय क्रिया करायची आहे ते सांगेल (उदा. “run
npm testआणि आउटपुट कॅप्चर करा”). - Verifier जोडा – स्किलला अशा ठोस टेस्टशी जोडा जी एजंट फसवू शकत नाही, जसे की प्रत्यक्ष टेस्ट रनरचा एक्झिट कोड पार्स करणे किंवा तयार झालेल्या आर्टिफॅक्टचा चेकसम (checksum) तपासणे.
- Guardrails सेट करा – एजंटला कमांड्स किंवा APIs च्या एका व्हाईटलिस्टपुरते मर्यादित ठेवा. यामुळे जेव्हा कामासाठी फक्त फाईल I/O ची गरज असते, तेव्हा तो नेटवर्क सॉकेट उघडणार नाही.
- State कायम ठेवा – एक छोटा JSON ब्लॉब किंवा डेटाबेस एंट्री स्टोअर करा ज्यामध्ये एजंटने आतापर्यंत काय केले आहे याची नोंद असेल. पुढच्या फेरीत ही स्टेट वाचली जाते आणि काम पुन्हा करण्याची गरज पडत नाही.
प्रत्येक लूपसाठी आवश्यक असलेले तीन सुरक्षा उपाय (safety caps)
- Hard stop – टर्न्सची कमाल संख्या किंवा टोकनची एक निश्चित मर्यादा ठरवून द्या. जर लूपने ही मर्यादा ओलांडली, तर ते थांबते आणि “max turns reached” असा रिपोर्ट देते.
- Real stop condition – अशी पडताळणी मेट्रिक वापरा जी मॉडेल बनावट तयार करू शकत नाही, जसे की यशस्वी झालेली टेस्ट सुईट, नॉन-एम्प्टी बिल्ड आर्टिफॅक्ट किंवा ज्ञात व्हॅल्यूशी जुळणारा चेकसम.
- Spend cap – लूपला अशा मॉनिटरिंग लेअरशी जोडा जो रिअल टाइममध्ये टोकनचा वापर पाहतो आणि पूर्वनिर्धारित खर्चाची मर्यादा ओलांडताच प्रक्रिया थांबवतो.
सारांश
Claude Code च्या /loop, /goal आणि /schedule कमांड्स डेव्हलपर्सना टोकनचा खर्च पारदर्शक ठेवून पुनरावृत्ती होणाऱ्या कोडिंग सायकल स्वयंचलित करण्याचा एक व्यावहारिक मार्ग देतात. विश्वासार्ह लूपची गुरुकिल्ली म्हणजे एक मजबूत व्हेरिफायर, कडक गार्डरेल्स आणि रनटाइम व खर्चावर असलेल्या कडक मर्यादा. प्रथम हे सुरक्षा उपाय तयार करा आणि त्यानंतर एजंटला कंटाळवाणी कामे करू द्या—जेणेकरून तुम्ही तुमचा वेळ अशा समस्यांवर खर्च करू शकाल ज्यासाठी अजूनही मानवी बुद्धिमत्तेची गरज आहे.