Claude Code एजेंट्स: स्वायत्त कोडिंग वर्कफ़्लो के लिए एक व्यावहारिक मार्गदर्शिका

यदि कोई मुझसे पूछे कि Claude Code को ChatGPT या GitHub Copilot से अलग क्या बनाता है, तो मैं भाषा मॉडल से शुरुआत नहीं करूंगा। मैं वर्कफ़्लो से शुरू करूंगा।

कल्पना कीजिए, आप किसी Git रिपॉजिटरी के अंदर एक टर्मिनल खोलते हैं और एक ही प्रॉम्प्ट टाइप करते हैं:

Add request validation to every FastAPI endpoint,
write tests for the new validation logic, update the documentation, 
and commit everything using a descriptive Git commit message.संचालित द्वारा

दर्जनों फॉलो-अप सवाल पूछने के बजाय, Claude Code काम शुरू कर देता है। 

यह आपकी परियोजना को खोजकर API संरचना को समझता है, हर एंडपॉइंट की पहचान करता है, उपयुक्त फाइलें संपादित करता है, टेस्ट बनाता है, किसी भी फेल्योर को ठीक करता है, आपका डॉक्यूमेंटेशन अपडेट करता है, और किए गए बदलावों का सार बताने वाला एक Git कमिट बनाता है।

आपके नजरिए से, यह एक AI से बातचीत करने के बजाय किसी सक्षम सहकर्मी को काम सौंपने जैसा लगता है। 

यही बदलाव Claude Code एजेंट्स को इतना रोमांचक बनाता है।

जिस फीचर से यह संभव होता है, उसे Claude Code सब-एजेंट्स कहा जाता है। एक ही AI सत्र को पूरी रिपॉजिटरी पर तर्क करने के लिए मजबूर करने के बजाय, Claude Code विशेष वर्कर्स लॉन्च कर सकता है जो परियोजना के अलग-अलग हिस्सों की जांच करते हैं, कार्यान्वयन योजनाएँ बनाते हैं, या मुख्य सत्र को रिपोर्ट करने से पहले स्वतंत्र रूप से कोड संशोधित करते हैं। 

हर समस्या को एक ही बातचीत में सुलझाने की कोशिश करने के बजाय, Claude Code काम को विशेष एजेंट्स को सौंप सकता है। 

तीन मुख्य एजेंट प्रकार हैं: 

• Explore, जो परियोजनाओं की जाँच पर केंद्रित है
• Plan, जो कार्यान्वयन योजनाएँ बनाने पर केंद्रित है, और
• General-purpose, जिसका उपयोग कोड संपादित करने और कमांड चलाने के लिए किया जाता है।

मुझे लगा है कि इससे मेरा डेवलपमेंट एप्रोच बदल गया है। “क्या AI यह फ़ंक्शन लिख सकता है?” पूछने के बजाय, अब मैं पूछता हूं, “मैं सबसे बड़ा कौन-सा काम सुरक्षित रूप से सौंप सकता हूं?” 

इस गाइड के अंत तक, आप जानेंगे कि Claude Code एजेंट्स का प्रभावी उपयोग कैसे करें, किस स्थिति में कौन-सा सब-एजेंट उपयुक्त है, CLAUDE.md के साथ स्थायी प्रोजेक्ट मेमोरी कैसे कॉन्फ़िगर करें, और ऐसे स्वायत्त वर्कफ़्लो कैसे बनाएं जो समय बचाएँ पर नियंत्रण आपके हाथ में रहे। 

पूर्वापेक्षाएँ

यह गाइड मानता है कि आप टर्मिनल के उपयोग और cd, ls या dir जैसे मूल कमांड-लाइन कमांड्स से डायरेक्टरी नेविगेट करने में सहज हैं। 

आपको Bash विशेषज्ञ होने की आवश्यकता नहीं है, लेकिन कमांड लाइन से काम करने में सहज होना चाहिए।

आपको ये भी चाहिए:

• आपकी मशीन पर Node.js इंस्टॉल होना
• एक Anthropic API कुंजी
• प्रयोग के लिए कोई Git रिपॉजिटरी
• Python, JavaScript या किसी अन्य प्रोग्रामिंग भाषा की बुनियादी जानकारी

यदि आप Claude Code के लिए पूरी तरह नए हैं, तो सब-एजेंट्स में जाने से पहले Claude Code: A Guide With Practical Examples पढ़ने की भी सलाह देता हूं।

Claude Code एजेंट्स क्या हैं?

Claude Code एजेंट्स स्वायत्त वर्कर्स हैं जो आपकी लोकल रिपॉजिटरी, टर्मिनल और डेवलपमेंट टूल्स का उपयोग करके बहु-चरणीय सॉफ्टवेयर विकास कार्य पूरे करते हैं। 

ChatGPT या Claude Chat के विपरीत, Claude Code फाइलों का निरीक्षण कर सकता है, Bash कमांड्स चला सकता है, सोर्स कोड संपादित कर सकता है, और परिणाम लौटाने से पहले अपने काम का सत्यापन कर सकता है।

अधिकांश AI कोडिंग असिस्टेंट अब भी बातचीत-केंद्रित वर्कफ़्लो का पालन करते हैं। 

आप सवाल पूछते हैं, जवाब मिलता है, और फिर आप तय करते हैं कि आगे क्या करना है। 

SQL क्वेरी लिखने या किसी scikit-learn पाइपलाइन को समझाने के लिए यह ठीक काम करता है, लेकिन जब कोई कार्य 20 फाइलों में फैला हो, कई टर्मिनल कमांड्स की जरूरत हो, या किसी अनजान रिपॉजिटरी को समझने पर निर्भर हो, तो यह तरीका लड़खड़ाने लगता है।

Claude Code उन समस्याओं को अलग तरह से हल करता है। 

क्योंकि यह सीधे आपकी Git रिपॉजिटरी के अंदर काम करता है, यह निर्णय लेने से पहले कोड की जांच कर सकता है। आपको चैट विंडो में फाइलें पेस्ट करने के लिए कहने के बजाय, यह खुद प्रोजेक्ट पढ़ता है और ज़रूरी संदर्भ जुटाता है।

मान लीजिए आप कहते हैं:

Replace every custom customer ID validator with Pydantic models, 
update the FastAPI endpoints, rewrite the affected pytest tests, 
and summarize the migration.संचालित द्वारा

एक पारंपरिक चैटबॉट शायद उदहारण कोड बना देगा और अधिक जानकारी मांगेगा। 

Claude Code रिपॉजिटरी में खोज करता है, मौजूदा वैलिडेशन लॉजिक की पहचान करता है, संबंधित फाइलों को संपादित करता है, टेस्ट सूट चलाता है, अपने द्वारा लाए गए किसी भी रिग्रेशन को ठीक करता है, और पूरे हुए काम की रिपोर्ट देता है।

सवालों के जवाब देने से उद्देश्यों को पूरा करने की ओर यह बदलाव ही Claude Code के साथ एजेंटिक कोडिंग को रोज़मर्रा के विकास में अलग महसूस कराता है।

एजेंट लूप कैसे काम करता है? 

हर Claude Code एजेंट एक ही निर्णय चक्र का अनुसरण करता है: जानकारी पढ़ना, अगला कदम तय करना, कार्य करना, फिर प्रक्रिया दोहराने से पहले परिणाम का मूल्यांकन करना। 

लूप साधारण है, लेकिन इसे दर्जनों बार दोहराने से एजेंट एक असफल प्रयास के बाद रुकने के बजाय गलतियों से उबर सकता है।

कल्पना कीजिए कि आप Claude Code से फेल हो रहे टेस्ट सूट को ठीक करने के लिए कहते हैं। वर्कफ़्लो आमतौर पर कुछ ऐसा दिखता है:

डायग्राम दिखाता है कि Claude Code फेल हो रहे टेस्ट्स को ठीक करते समय कैसे काम करता है

मुझे लगता है कि Claude Code को समझने का यह सबसे आसान मानसिक मॉडल है। 

एजेंट एक ही चरण में पूरी समस्या हल करने की कोशिश नहीं कर रहा। यह पिछले कदम के बाद क्या हुआ, उसके आधार पर छोटे-छोटे निर्णयों की श्रृंखला बना रहा है।

एक सब-एजेंट भी बिल्कुल यही लूप फ़ॉलो करता है, लेकिन यह अपने अलग-थलग संदर्भ के अंदर करता है। 

यह फर्क मायने रखता है क्योंकि एक टूल कॉल एक ही कार्रवाई करता है, जबकि एक सब-एजेंट मुख्य सत्र को रिपोर्ट करने से पहले किसी एक लक्ष्य की ओर काम करते हुए दर्जनों तर्क कदम लगा सकता है।

Claude Code सब-एजेंट्स का उपयोग क्यों करता है? 

Claude Code सब-एजेंट्स का उपयोग करता है क्योंकि बड़ी रिपॉजिटरीज़ शायद ही कभी एक ही कार्य संदर्भ में समा पाती हैं। Python सेवाओं, React ऐप्लिकेशंस, SQL माइग्रेशन्स और Terraform कॉन्फ़िगरेशन वाले मोनोरिपो में इतनी जानकारी होती है कि एक एजेंट को एक साथ उस पर तर्क नहीं करना चाहिए। 

रिपॉजिटरी को एक विशाल कार्य की तरह मानने के बजाय, Claude Code केंद्रित जाँच-पड़ताल को विशेष वर्कर्स को सौंप देता है। 

एक Explore एजेंट ऑथेंटिकेशन का विश्लेषण कर सकता है, दूसरा डेटाबेस मॉडल्स की जाँच कर सकता है, जबकि तीसरा API रूट्स की समीक्षा कर सकता है। ऑर्केस्ट्रेटर इन निष्कर्षों को मिलाकर अगला कदम तय करता है।

इस आर्किटेक्चर का एक व्यावहारिक फायदा और है: कई जाँचें समानांतर में होती हैं। 

आप खुद हर डायरेक्टरी पढ़ने या किसी एक एजेंट के पूरी रिपॉजिटरी का निरीक्षण करने का इंतज़ार करने के बजाय, कई सब-एजेंट्स एक ही समय में अलग-अलग क्षेत्रों का अन्वेषण कर सकते हैं।

आप इस पैटर्न को आगे के ट्यूटोरियल में बार-बार देखेंगे। Explore एजेंट्स जानकारी इकट्ठी करते हैं, Plan एजेंट्स कार्यान्वयन को व्यवस्थित करते हैं, और जनरल-पर्पज़ एजेंट्स वास्तविक विकास कार्य करते हैं।

यदि आप Claude Code से परे स्वायत्त AI प्रणालियाँ कैसे काम करती हैं, इसका व्यापक परिचय चाहते हैं, तो DataCamp का लेख LLM Agents Explained: Architecture, Frameworks, and Use Cases उत्कृष्ट वैचारिक अवलोकन देता है।

आप Claude Code कैसे इंस्टॉल और सेट अप करते हैं? 

Claude Code एजेंट्स का उपयोग शुरू करने से पहले, हमें एक कार्यशील इंस्टॉलेशन चाहिए। 

खुशकिस्मती से, शुरुआत करने में कुछ ही मिनट लगते हैं।

Claude Code इंस्टॉल करना

Claude Code एक npm पैकेज के रूप में वितरित किया जाता है, इसलिए आपकी मशीन पर Node.js इंस्टॉल होना चाहिए। निर्देशों के लिए, मैं Node.js और npm की स्थापना पर npm डॉक्युमेंटेशन का पालन करने की सलाह देता हूं।

Claude Code को ग्लोबली इंस्टॉल करें:

npm install -g @anthropic-ai/claude-code

इसके बाद, Anthropic Console से एक Anthropic API कुंजी बनाएँ और उसे अपने वातावरण में जोड़ें।

macOS या Linux पर:

export ANTHROPIC_API_KEY="your_api_key_here"

Windows PowerShell पर:

$env:ANTHROPIC_API_KEY="your_api_key_here"

यह जाँचने के लिए कि सब कुछ सही से इंस्टॉल हुआ है, चलाएँ:

claude --version

यदि Claude Code अपना इंस्टॉल्ड वर्ज़न प्रिंट करता है, तो आप तैयार हैं।

इस बिंदु पर, यह पक्का कर लेना भी उपयोगी है कि Git उपलब्ध है, क्योंकि कई Claude Code वर्कफ़्लोज़ में रिपॉजिटरी इतिहास पढ़ना, कमिट बनाना या बदलावों की तुलना करना शामिल होता है। 

यदि आपके पास Git नहीं है, तो शुरू करने के लिए Git इंस्टॉलेशन निर्देश का पालन करें।

आगे बढ़ने से पहले दोनों कमांड सफलतापूर्वक चलनी चाहिए।

आपका पहला Claude Code सत्र

Claude Code इंस्टॉल होने के साथ, cd my-project का उपयोग कर किसी भी Git प्रोजेक्ट में जाएँ।

फिर Claude Code लॉन्च करें: claude।

कोड लिखने को कहने से पहले, कुछ मिनट इस बात को समझने में लगाएँ कि यह रिपॉजिटरी को कैसे एक्सप्लोर करता है। मैं आमतौर पर ऐसे प्रॉम्प्ट से शुरू करता हूँ:

• "यह रिपॉजिटरी क्या करती है?"
• "आर्किटेक्चर समझाइए।"
• "हर TODO कमेंट ढूँढिए।"
• "कौन-से मॉड्यूल्स में कोर बिज़नेस लॉजिक है?"
• "ऑथेंटिकेशन कैसे इम्प्लीमेंट किया गया है?"

ये सवाल नए फीचर्स नहीं बनाते, लेकिन वे Claude Code को वही संदर्भ देते हैं जो कोई नया टीममेट कोड लिखने से पहले जुटाता है। 

मुझे लगा है कि 2–3 मिनट एक्सप्लोरेशन में लगाना सीधे फीचर रिक्वेस्ट पर कूदने की तुलना में बेहतर इम्प्लीमेंटेशन्स देता है।

अगला कदम CLAUDE.md के साथ स्थायी प्रोजेक्ट मेमोरी कॉन्फ़िगर करना है। मेरे अनुभव में, कोई भी एकल फाइल लंबे समय में Claude Code के काम की गुणवत्ता पर इससे बड़ा असर नहीं डालती।

CLAUDE.md Claude Code के लिए सबसे महत्वपूर्ण फाइल क्यों है?

CLAUDE.md एक स्थायी निर्देश फ़ाइल है जो Claude को आपके पसंद और आपकी परियोजना के काम करने के तरीके के बारे में किसी कार्य पर तर्क शुरू करने से पहले बताती है। 

हर बार नया सत्र खोलते समय अपना टेक स्टैक, कोडिंग नियम और डेवलपमेंट वर्कफ़्लो दोबारा समझाने के बजाय, आप उन्हें एक बार दस्तावेज़ित करते हैं और हर भविष्य का एजेंट उसी साझा संदर्भ पर काम करता है।

जब लोग पहली बार Claude Code एजेंट्स के बारे में जानते हैं, तो वे आमतौर पर प्रॉम्प्ट्स पर ध्यान केंद्रित करते हैं। मुझे लगता है यह उल्टा है। 

एक अच्छी तरह लिखा CLAUDE.md आपके परिणामों की गुणवत्ता के लिए प्रॉम्प्ट शब्दांकन को बार-बार सँवारने से ज़्यादा करता है, क्योंकि हर एजेंट आपकी परियोजना की एक जैसी समझ से शुरू करता है।

सोचिए कि आप किसी नए इंजीनियर को कैसे ऑनबोर्ड करेंगे। 

आप शायद उन्हें सीधे एक Jira टिकट नहीं थमाएँगे। आप रिपॉजिटरी समझाएँगे, उन्हें टेस्ट सूट कैसे चलाना है दिखाएँगे, कुछ कोडिंग नियम बताएँगे, और कोडबेस के उन हिस्सों के बारे में चेतावनी देंगें जिन्हें छूना नहीं चाहिए। 

CLAUDE.md बिल्कुल यही उद्देश्य पूरा करता है।

जैसे ही आप Claude Code के स्वायत्त वर्कफ़्लोज़ का इस्तेमाल शुरू करते हैं, इसका लाभ और भी स्पष्ट हो जाता है।

एक एजेंट जिससे स्वतंत्र रूप से काम करने की उम्मीद हो, उसे विश्वसनीय प्रोजेक्ट संदर्भ चाहिए। 

इसके बिना, Claude Code समय जानकारी दोबारा खोजने में लगाता है या ऐसे अनुमान लगाता है जो आपकी टीम के मानकों से मेल न खाएँ।

अपने CLAUDE.md में क्या डालना चाहिए?

एक अच्छा CLAUDE.md आपकी परियोजना डॉक्यूमेंटेशन या README.md का विकल्प नहीं है। यह उन निर्देशों का संग्रह है जिनकी Claude Code को कोड पढ़ते, फीचर्स लिखते और डेवलपमेंट टूल्स चलाते समय बार-बार जरूरत पड़ती है।

मैं आमतौर पर इसे पाँच खंडों में व्यवस्थित करता हूँ: प्रोजेक्ट की झलक, टेक स्टैक, कोडिंग नियम, सामान्य कमांड्स, और जिन डायरेक्टरीज़ से बचना है। मैं हर एक पर संक्षेप में जाऊँगा।

प्रोजेक्ट ओवरव्यू

शुरुआत इस छोटे से वर्णन से करें कि प्रोजेक्ट वास्तव में क्या करता है।

Customer analytics platform built with FastAPI.
The application serves machine learning predictions through REST APIs.
Production deployments run through GitHub Actions.संचालित द्वारा

ये तीन पंक्तियाँ तुरंत Claude Code को बताती हैं कि यह एक सामान्य Python रिपॉजिटरी के बजाय FastAPI, GitHub Actions और मशीन लर्निंग ऐप्लिकेशन के साथ काम कर रहा है।

टेक्नोलॉजी स्टैक

अगला, बस उन मुख्य लाइब्रेरीज़ और फ्रेमवर्क्स की सूची दें जो प्रोजेक्ट को परिभाषित करते हैं।

Python 3.12
FastAPI
Pydantic v2
SQLAlchemy
PostgreSQL
Pytest
Ruffसंचालित द्वारा

जब वर्ज़न मायने रखें, मैं हमेशा वर्ज़न नंबर शामिल करता हूँ। 

Pydantic v2 के लिए अनुशंसित तरीका Pydantic v1 से भिन्न है, और Claude Code को यह अनुमान नहीं लगाना चाहिए कि आप कौन-सा API उपयोग कर रहे हैं। 

यदि आप कोई पुराना पैकेज उपयोग कर रहे हैं, तो यह और भी महत्वपूर्ण है, ताकि यह गलत धारणाओं पर न बने।

कोडिंग नियम

यह खंड वे नियम कैप्चर करता है जिन्हें आप खुद को बार-बार दोहराते पाते हैं।

Always use type hints.
Prefer dependency injection.
Write tests for every new feature.
Keep business logic separate from API routes.
Reuse existing utility functions before creating new ones.संचालित द्वारा

ध्यान दें कि ये व्यावहारिक इंजीनियरिंग नियम हैं, न कि केवल शैली वरीयताएँ। 

Claude Code आमतौर पर मौजूदा फाइलों से फॉर्मेटिंग का अनुमान लगा सकता है, लेकिन यह अपने आप नहीं जानेगा कि आपकी टीम हर एंडपॉइंट में डिपेंडेंसी इंजेक्शन की अपेक्षा करती है या हर फीचर के साथ एक pytest टेस्ट होना चाहिए।

सामान्य कमांड्स

Claude Code अक्सर अपने काम का सत्यापन डेवलपमेंट कमांड्स चलाकर करता है। आपकी टीम जिन सटीक कमांड्स का उपयोग करती है, वे देने से अनावश्यक ट्रायल-एंड-एरर से बचा जा सकता है। 

यह task जैसे विशेष एक्शन्स या CI स्क्रिप्ट्स कुछ भी हो सकता है।

pytest
Run one test file:
pytest tests/test_api.py
Lint:
ruff check .
Format:
ruff format .
Start the development server:
uvicorn app.main:app --reloadसंचालित द्वारा

यह खंड विशेष रूप से कस्टम स्क्रिप्ट्स, Docker वर्कफ़्लोज़, या poetry, uv, या tox जैसे टूल्स वाली रिपॉजिटरीज़ में उपयोगी है।

बचने योग्य फाइलें और डायरेक्टरीज़

हर रिपॉजिटरी में ऐसी फाइलें होती हैं जिन्हें स्वत: नहीं बदला जाना चाहिए।

उदाहरण शामिल हैं:

Never edit generated files.
Do not modify Alembic migrations.
Avoid changing Terraform configuration unless requested.
Do not update dependency versions automatically.संचालित द्वारा

मुझे लगा है कि यह खंड लगभग किसी भी अन्य से अधिक गलतियों को रोकता है। Claude Code को जेनरेटेड कोड को न छूने को कहना एक वाक्य, दर्जनों अनावश्यक फाइल बदलावों की समीक्षा करने से कहीं सस्ता है।

एक उदाहरण CLAUDE.md

यहाँ एक Python API प्रोजेक्ट के लिए एक सरल उदाहरण दिया गया है। 

ध्यान दें कि मैं Markdown फॉर्मेटिंग का उपयोग चीज़ों को अधिक मनुष्य-पठनीय बनाने और Claude को अधिक संदर्भ देने के लिए कैसे करता हूँ।

# Project Overview

Customer analytics platform built with FastAPI.

## Technology

- Python 3.12
- FastAPI
- PostgreSQL
- SQLAlchemy
- Pydantic v2
- Pytest
- Ruff

## Coding Standards

- Use type hints everywhere.
- Write tests for new features.
- Prefer dependency injection.
- Keep business logic separate from API routes.

## Common Commands

pytest
ruff check .
ruff format .

## Avoid Editing

generated/
alembic/versions/
terraform/संचालित द्वारा

अपना पहला संस्करण परफेक्ट बनाने की चिंता न करें। 

मेरा अपना CLAUDE.md कई बार बदला है, जैसे-जैसे मुझे दोहराए जाने लायक निर्देश दिखे जिन्हें दस्तावेज़ित करना उचित था। इसे सोर्स कोड की तरह मानें, न कि ऐसा दस्तावेज़ जो कभी नहीं बदलता। 

यदि आप प्रभावी निर्देश फाइलें लिखने में गहराई से जाना चाहते हैं, तो DataCamp का Writing the Best CLAUDE.md: A Complete Guide for Claude Code बड़े उदाहरणों और अधिक उन्नत पैटर्न को कवर करता है।

क्या आपको प्रोजेक्ट-लेवल या यूज़र-लेवल CLAUDE.md उपयोग करना चाहिए?

Claude Code स्थायी निर्देशों के लिए दो स्कोप सपोर्ट करता है। अंतर समझने से परियोजना के नियम आपकी व्यक्तिगत प्राथमिकताओं से अलग रहते हैं।

प्रोजेक्ट-लेवल CLAUDE.md

प्रोजेक्ट-लेवल फाइल रिपॉजिटरी के अंदर रहती है।

	my-project/
	│
	├── CLAUDE.md
	├── app/
	├── tests/
	└── pyproject.tomlसंचालित द्वारा

इस फाइल की हर बात केवल उसी रिपॉजिटरी पर लागू होती है। मैं इसका उपयोग टेक्नोलॉजी विकल्पों, टेस्टिंग कमांड्स, कोडिंग नियमों, डायरेक्टरी संरचना, और रिपॉजिटरी-विशिष्ट नियमों के लिए करता हूँ। 

क्योंकि यह फाइल सोर्स कोड के साथ रहती है, परियोजना को क्लोन करने के बाद हर योगदानकर्ता को एक जैसे निर्देश मिलते हैं। इसे ऐसे मानें जैसे हर एजेंट को शुरू होने से पहले एक मैनुअल देना।

यूज़र-लेवल CLAUDE.md

Claude Code एक वैश्विक कॉन्फ़िगरेशन फाइल भी सपोर्ट करता है।

यह फाइल प्रोजेक्ट से प्रोजेक्ट तक आपके साथ रहती है। मैं इसे अपनी व्यक्तिगत ऑपरेटिंग मैनुअल की तरह मानता हूँ, न कि प्रोजेक्ट डॉक्यूमेंटेशन की तरह।

उदाहरण के लिए, मेरी यूज़र-लेवल फाइल में ऐसे निर्देश हो सकते हैं:

Explain architectural trade-offs.
Suggest performance improvements when appropriate.
Default to Python examples unless another language is requested.
Keep explanations concise.संचालित द्वारा

ये वरीयताएँ इस बात से स्वतंत्र रूप से समझ में आती हैं कि मैं FastAPI, React या PyTorch के साथ काम कर रहा हूँ।

दोनों फाइलें साथ कैसे काम करती हैं

एक विवरण जिसने मुझे शुरुआत में भ्रमित किया, वह यह है कि ये फाइलें परस्पर अनन्य नहीं हैं। 

यूज़र-लेवल CLAUDE.md पहले लोड होती है, फिर प्रोजेक्ट-लेवल CLAUDE.md रिपॉजिटरी-विशिष्ट निर्देश जोड़ती है।

मैं इसे एक पदानुक्रम की तरह देखता हूँ। 

ग्लोबल फाइल बताती है कि मुझे कैसे काम करना पसंद है। प्रोजेक्ट फाइल बताती है कि यह रिपॉजिटरी कैसे काम करती है। 

मिलकर, वे हर एजेंट को तर्क शुरू करने से पहले व्यक्तिगत प्राथमिकताएँ और प्रोजेक्ट संदर्भ दोनों देती हैं।

किसी कार्य को शुरू करने से पहले Claude Code यूज़र-लेवल प्राथमिकताओं को प्रोजेक्ट-विशिष्ट निर्देशों के साथ जोड़ता है।

Claude Code सब-एजेंट्स के तीन प्रकार कौन-से हैं?

Claude Code अलग-अलग विकास कार्यों के लिए अलग-अलग टूल्स की जरूरत होने के कारण तीन विशेष सब-एजेंट प्रकारों का उपयोग करता है। 

जो एजेंट रिपॉजिटरी की जाँच कर रहा है उसे फाइलें संपादित करने की अनुमति की जरूरत नहीं होती, जबकि कोई फीचर लागू करने वाला एजेंट शायद Bash, Git और आपके टेस्ट सूट तक पहुँच चाहता होगा।

जब मैंने पहली बार Claude Code का उपयोग शुरू किया, तो मैं हर बार जनरल-पर्पज़ एजेंट की ही ओर झुकता था, क्योंकि वह सबसे सक्षम विकल्प लगता था। 

कुछ समय बाद, मुझे एहसास हुआ कि मैं समय और टोकन्स दोनों में ज़रूरत से ज़्यादा खर्च कर रहा था। अधिकांश वर्कफ़्लो तेज़ हो जाते हैं यदि आप पहले एक्सप्लोर करें, फिर प्लान करें, और अंत में इम्प्लीमेंट करें।

तीनों Claude Code सब-एजेंट्स की तुलना

नाम भले ही काफी वर्णनात्मक हों, लेकिन हर एजेंट बड़े वर्कफ़्लो में एक अलग भूमिका निभाता है।

Claude Code Explore एजेंट क्या है?

Claude Code Explore एजेंट एक रीड-ओनली अन्वेषक है जो किसी रिपॉजिटरी की जाँच करता है और बिना किसी फाइल को बदले जो पाता है उसका सार बताता है।

यह वह एजेंट है जिसका मैं किसी अनजान प्रोजेक्ट को खोलते समय सबसे ज़्यादा इस्तेमाल करता हूँ। खुद दर्जनों Python मॉड्यूल्स या JavaScript कंपोनेंट्स स्क्रॉल करने के बजाय, मैं Explore एजेंट से कहता हूँ कि किसी सबसिस्टम का काम समझाए और मुझे महत्वपूर्ण फाइलों की ओर इंगित करे।

अच्छे उपयोग के मामले शामिल हैं:

• जहाँ ऑथेंटिकेशन इम्प्लीमेंट है, उसे ढूँढना
• किसी रिक्वेस्ट को कई सेवाओं के पार ट्रेस करना
• लॉगिंग या एरर हैंडलिंग का ऑडिट करना
• डिप्रिकेटेड APIs ढूँढ़ना
• किसी पैकेज या डायरेक्टरी का सार बताना
• डुप्लिकेटेड बिज़नेस लॉजिक की पहचान करना

क्योंकि Explore एजेंट्स फाइलें संपादित नहीं कर सकते या शेल कमांड्स नहीं चला सकते, वे समानांतर में चलाने के लिए सबसे सुरक्षित होते हैं।

थोरोनैस स्तर चुनना

Explore एजेंट्स अलग-अलग जाँच गहराइयों का समर्थन करते हैं।

यदि मुझे केवल किसी फंक्शन का पता लगाना है, तो मैं सबसे तेज़ सेटिंग का उपयोग करता हूँ। यदि मैं कई पैकेजों में फैले रिफैक्टर की तैयारी कर रहा हूँ, तो एक मिनट और इंतज़ार कर गहरी जाँच करवाना आम तौर पर खुद अपनी लागत वसूल लेता है।

Claude Code Plan एजेंट क्या है?

Claude Code Plan एजेंट अनुरोधित बदलाव का विश्लेषण करता है और रिपॉजिटरी में कोई संशोधन किए बिना एक कार्यान्वयन रणनीति तैयार करता है।

मैं लगभग कभी यह चरण नहीं छोड़ता। एक मिनट अतिरिक्त योजना की समीक्षा करना, इम्प्लीमेंटेशन के बीच में यह पता लगाने से कहीं सस्ता है कि कोई दूसरा सबसिस्टम उस कोड पर निर्भर है जिसे आप बदल रहे हैं।

एक सामान्य योजना में शामिल होते हैं:

• कौन-सी फाइलें बदलनी चाहिए
• अनुशंसित इम्प्लीमेंटेशन क्रम
• निर्भरताएँ और इंटीग्रेशन पॉइंट्स
• टेस्टिंग रणनीति
• जोखिम या धारणाएँ

योजना की समीक्षा करने के बाद, आप इसे और परिष्कृत कर सकते हैं या सीधे किसी जनरल-पर्पज़ एजेंट को सौंप सकते हैं।

DataCamp का Claude Code Plan Mode: Design Review-First Refactoring Loops इस समीक्षा-प्रथम वर्कफ़्लो को और विस्तार से बताता है।

जनरल-पर्पज़ Claude Code एजेंट क्या है?

एक जनरल-पर्पज़ एजेंट फाइलें पढ़ सकता है, सोर्स कोड संपादित कर सकता है, Bash कमांड्स चला सकता है, टेस्ट चला सकता है, और अनुरोधित उद्देश्य पूरा होने तक काम जारी रख सकता है।

यही एजेंट वास्तव में सॉफ़्टवेयर बनाता है। इसे अन्य एजेंट्स जैसा ही रिपॉजिटरी संदर्भ प्राप्त होता है, लेकिन साथ ही इसे बदलाव करने और अपने काम का सत्यापन करने की अनुमति भी होती है।

सामान्य कार्यों में शामिल हैं:

• नए फीचर्स लागू करना
• कई मॉड्यूल्स का रिफैक्टरिंग
• निर्भरताओं का माइग्रेशन
• डॉक्यूमेंटेशन अपडेट करना
• कई पैकेजों में बदलावों का समन्वय

जनरल-पर्पज़ एजेंट्स अधिक टोकन्स खर्च करते हैं क्योंकि वे काफी अधिक काम करते हैं। 

यही एक और कारण है कि मुझे Explore → Plan → Implement पैटर्न पसंद है। 

सस्ते एजेंट शुरुआती प्रश्नों का उत्तर दे देते हैं, और अधिक महंगा इम्प्लीमेंटेशन काम तब तक टालते हैं जब तक आगे का रास्ता स्पष्ट न हो।

इस बिंदु तक, हमने वे हिस्से कवर कर लिए हैं जो Claude Code एजेंट्स को सफल बनाते हैं: CLAUDE.md के जरिए स्थायी प्रोजेक्ट मेमोरी और जाँच-पड़ताल, योजना और इम्प्लीमेंटेशन के लिए विशेष सब-एजेंट्स। 

अगला, हम इन्हें एक साथ जोड़ेंगे और पूर्ण एजेंटिक वर्कफ़्लो बनाएँगे जिन्हें आप अपने प्रोजेक्ट्स में उपयोग करना शुरू कर सकते हैं।

अपना पहला Claude Code एजेंट वर्कफ़्लो चलाना

Claude Code से अधिकतम लाभ पाने का सबसे अच्छा तरीका है इसे अलग-अलग घटकों के लिए कहने की बजाय एक उद्देश्य देना।

मैंने एक सरल वर्कफ़्लो अपनाया है जो Python प्रोजेक्ट्स, डेटा साइंस रिपॉजिटरीज़, और वेब ऐप्लिकेशंस में अच्छा काम करता है:

1. रिपॉजिटरी एक्सप्लोर करें।
2. एक योजना बनाएं।
3. योजना की समीक्षा करें।
4. बदलाव लागू करें।
5. परिणाम सत्यापित करें।

यह प्रक्रिया अनिवार्य नहीं है, लेकिन यह बताती है कि अनुभवी इंजीनियर्स बड़े बदलावों से कैसे निपटते हैं। 

रिपॉजिटरी को समझने में एक मिनट लगाना, बाद में अनावश्यक संपादनों को ठीक करने में कई मिनट बचा देता है। 

एक अधिक ठोस प्रॉम्प्ट बनाना—यहाँ तक कि उसे बेहतर करने में एक घंटा लगाना—बाद में आपके कई घंटे बचा सकता है।

वर्कफ़्लो 1: अनजान कोडबेस को एक्सप्लोर करें

जब आप कोई नई रिपॉजिटरी विरासत में लेते हैं या महीनों बाद किसी प्रोजेक्ट पर लौटते हैं, तो Explore एजेंट सबसे अच्छा शुरुआती बिंदु है। 

डायरेक्टरीज़ को हाथ से पढ़ने के बजाय, Claude Code से आर्किटेक्चर की जाँच करने और महत्वपूर्ण बातों का सार बताने को कहें।

उदाहरण के लिए:

Use an Explore agent to explain how authentication works. 
Identify the main modules involved, summarize the request flow, 
and highlight any technical debt or TODO comments.संचालित द्वारा

परिणाम कॉपी किए गए सोर्स कोड की दीवार नहीं होगा। इसके बजाय, आमतौर पर आपको ऑथेंटिकेशन फ्लो, संबंधित फाइलें, और ध्यान देने योग्य क्षेत्रों का संक्षिप्त विवरण मिलेगा। 

मैं अक्सर उस सार को अगले कार्य के शुरुआती बिंदु के रूप में उपयोग करता हूँ, नए सिरे से प्रॉम्प्ट लिखने के बजाय।

वर्कफ़्लो 2: इम्प्लीमेंट करने से पहले योजना बनाएं

एक बार जब आप रिपॉजिटरी समझ लेते हैं, तो कोड लिखने से पहले किसी Plan एजेंट से इम्प्लीमेंटेशन डिज़ाइन करने को कहें। 

यह अपनाने की सबसे आसान आदतों में से एक है, और इसने मुझे कई ऐसे रिफैक्टर्स से बचाया है जो गलत दिशा में जा सकते थे।

प्रॉम्प्ट कुछ ऐसा हो सकता है:

Create an implementation plan for adding role-based access control.
Identify the files that should change, potential risks,
dependencies, and a recommended implementation order.
Do not modify any code.संचालित द्वारा

आगे बढ़ने से पहले योजना की समीक्षा करें। यदि सब कुछ उचित लगे, तो आप उस योजना को सीधे किसी जनरल-पर्पज़ एजेंट को दे सकते हैं। 

यदि नहीं, तो दर्जनभर फाइलों में किए बदलावों को पलटने की तुलना में एक डिज़ाइन दस्तावेज़ को समायोजित करना बहुत आसान है।

इस चरण का लाभ उठाने का एक बढ़िया तरीका है दूसरे Claude Code सत्र का उपयोग करके पहले वाले के काम की समीक्षा कराना। एक सरल प्रॉम्प्ट कुछ ऐसा हो सकता है:

This is my current goal: to add role-based access control to this repository. 
Take a look at this existing implementation plan and do an adversarial review.
Once done, create a report that summarizes the strong and weak points of the plan.संचालित द्वारा

वर्कफ़्लो 3: रिपॉजिटरी एक्सप्लोरेशन को समानांतर करें

Claude Code की मेरी पसंदीदा विशेषताओं में से एक यह है कि एक्सप्लोरेशन क्रमिक होने की आवश्यकता नहीं है। यदि आपकी परियोजना में कई स्वतंत्र सबसिस्टम हैं, तो आप उन्हें एक ही समय में जाँच सकते हैं।

उदाहरण के लिए, आप एक Explore एजेंट को API लेयर की जाँच के लिए, दूसरे को डेटाबेस मॉडल्स की समीक्षा के लिए, और तीसरे को मशीन लर्निंग पाइपलाइन की जाँच के लिए लॉन्च कर सकते हैं। 

जबकि ये एजेंट स्वतंत्र रूप से काम करते हैं, ऑर्केस्ट्रेटर उनके निष्कर्षों को एक ही उत्तर में समाहित कर देता है।

मैं हर कार्य के लिए समानांतर एजेंट्स का उपयोग नहीं करता, लेकिन बड़े मोनोरिपो या कई सेवाओं वाली परिपक्व ऐप्लिकेशंस के लिए ये बेहतरीन होते हैं। एक लंबी जाँच का इंतज़ार करने के बजाय, आप अक्सर रिपॉजिटरी को बहुत तेज़ी से समझ लेते हैं क्योंकि परियोजना के कई हिस्सों का एक साथ विश्लेषण हो रहा होता है।

इसे करने का सबसे अच्छा तरीका है एक बड़े एजेंट का उपयोग करके कई एजेंट्स का ऑर्केस्ट्रेशन करना। 

यह एजेंटिक ऑर्केस्ट्रेशन समानांतर काम करवाने का शानदार तरीका है, बिना कई सत्रों के जिन्हें एक साझा संदर्भ में जोड़ना पड़े। 

एक अच्छा प्रॉम्प्ट कुछ ऐसा दिख सकता है:

I want you to look at the following components: 
Inspect the API layer, review the DB models, and examine the ML pipeline. 
Look for weaknesses. 
I want this done in parallel, so spawn subagents using Opus/Sonnet models 
in order to do this work and have each generate a concise report and share out 
one master document that outlines the work needed to be done.संचालित द्वारा

Claude Code एजेंट्स के लिए सर्वश्रेष्ठ अभ्यास

Claude Code के साथ लोग जिन अधिकांश समस्याओं का सामना करते हैं, वे मॉडल के कारण नहीं होतीं। वे अस्पष्ट प्रॉम्प्ट्स, गायब प्रोजेक्ट संदर्भ, या ऐसी समस्या को सुलझाने के लिए कहने से होती हैं जिसे वह पूरी तरह से समझता नहीं है।

Claude Code का नियमित उपयोग करने के बाद, ये वे आदतें हैं जिनका मेरे परिणामों पर सबसे बड़ा प्रभाव पड़ा है।

ऐसे प्रॉम्प्ट लिखें जिन्हें एजेंट निष्पादित कर सकें

जब उद्देश्य, स्कोप और सफलता के मानदंड स्पष्ट हों, Claude Code सबसे अच्छा प्रदर्शन करता है। 

अंतिम लक्ष्य को व्यापक शब्दों में बताने के बजाय, एजेंट को ठीक-ठीक बताइए कि उसे कौन-सी रिपॉजिटरी देखनी है, कौन-सी फाइलें बदलनी हैं, और आपको कैसे पता चलेगा कि कार्य पूरा हो गया है।

उदाहरण के लिए:

❌ अस्पष्ट API में सुधार करें।

✅ विशिष्ट FastAPI ऑथेंटिकेशन एंडपॉइंट्स को Pydantic v2 वैलिडेशन पर अपडेट करें, संबंधित pytest टेस्ट्स जनरेट या अपडेट करें, टेस्ट सूट चलाएँ, और हर संशोधित फाइल का सार बताइए।

दूसरा प्रॉम्प्ट Claude Code को एक स्पष्ट उद्देश्य, सीमाएँ और सफलता जाँचने का तरीका देता है। यह आमतौर पर कम फॉलो-अप प्रॉम्प्ट्स और कम मैनुअल सफ़ाई की ओर ले जाता है।

संदर्भ को समस्या बनने से पहले संभालें

लंबी बातचीतें अंततः इतना संदर्भ जमा कर लेती हैं कि Claude Code मौजूदा कार्य पर तर्क करने की बजाय पिछले विमर्शों को याद रखने में टोकन्स खर्च करने लगता है।

जब ऐसा हो, तो महत्वपूर्ण संदर्भ को संरक्षित रखते हुए बातचीत का सार निकालने के लिए /compact का उपयोग करें। मेरे अनुभव में, प्रदर्शन स्पष्ट रूप से घटने का इंतजार करने के बजाय जल्दी कॉम्पैक्ट करना बेहतर है।

एक अच्छा CLAUDE.md यहाँ भी मदद करता है, क्योंकि प्रोजेक्ट नियम हर सत्र में दोहराने की जरूरत नहीं पड़ती। Claude Code वह संदर्भ अपने आप लोड करता है, जिससे आपके द्वारा कहा गया काम करने के लिए अधिक समय बचता है।

संदर्भ प्रबंधन, टेस्ट-ड्रिवन डेवलपमेंट और प्रॉम्प्ट डिज़ाइन पर और सलाह के लिए देखें Claude Code Best Practices: Planning, Context Transfer, TDD।

टोकन लागत के बारे में सोचें

हर कार्य को जनरल-पर्पज़ एजेंट की जरूरत नहीं होती।

यदि आपको केवल यह पता लगाना है कि कोई फंक्शन कहाँ परिभाषित है, तो Explore एजेंट आमतौर पर तेज़ और सस्ता होता है। 

यदि आप किसी बड़े आर्किटेक्चरल बदलाव की समीक्षा कर रहे हैं, तो Plan एजेंट अक्सर बिना रिपॉजिटरी बदले पर्याप्त जानकारी दे देता है।

जनरल-पर्पज़ एजेंट्स को उन कार्यों के लिए सुरक्षित रखें जिन्हें वास्तव में निष्पादन की आवश्यकता है—जैसे फाइलें संपादित करना, Bash कमांड्स चलाना या टेस्ट चलाना। कार्य के अनुसार एजेंट मिलाने से रनटाइम और टोकन उपयोग दोनों नियंत्रित रहते हैं।

जानें कि कब एजेंट्स का उपयोग न करें

Claude Code एजेंट्स कुछ ओवरहेड लाते हैं क्योंकि संदर्भ और टोकन का आदान-प्रदान होता है। 

वे रिपॉजिटरी की जाँच करते हैं, कार्य पर तर्क करते हैं, और अपने काम का सत्यापन करते हैं। बहुत छोटे बदलावों के लिए, यह ओवरहेड हमेशा सार्थक नहीं होता।

शायद आपको इन कामों के लिए एजेंट की जरूरत नहीं:

• किसी एकल वेरिएबल का नाम बदलना।
• किसी Markdown फाइल में टाइपो ठीक करना।
• किसी Python एरर मैसेज की व्याख्या करना।
• किसी त्वरित SQL सवाल का जवाब देना।

इन स्थितियों में, एक सामान्य Claude Code बातचीत या यहाँ तक कि मैनुअल संपादन अक्सर तेज़ होता है। मैं आम तौर पर एजेंट लॉन्च करने से पहले अपने आप से एक सवाल पूछता हूँ: क्या मैं यह काम खुद करने की तुलना में इसे समझाने में अधिक समय लगाऊँगा? यदि जवाब हाँ है, तो मैं इसे सरल रखता हूँ।

अंतिम विचार

Claude Code एजेंट्स सॉफ्टवेयर विकास के दौरान AI की भूमिका बदल देते हैं। अलग-थलग स्निपेट्स जनरेट करने के बजाय, वे अपेक्षाकृत कम निगरानी में रिपॉजिटरी की जाँच, इम्प्लीमेंटेशन डिज़ाइन, कोड में संशोधन, टेस्ट चलाना, और बहु-चरणीय उद्देश्यों पर काम कर सकते हैं।

सबसे बड़ा सबक जो मैंने सीखा है, वह यह है कि बेहतर वर्कफ़्लो, बेहतर प्रॉम्प्ट्स से ज़्यादा मायने रखते हैं। 

एक स्पष्ट CLAUDE.md, कुछ मिनटों का रिपॉजिटरी एक्सप्लोरेशन, और सोची-समझी इम्प्लीमेंटेशन योजना, सीधे कोड जनरेशन पर कूदने की तुलना में लगातार बेहतर परिणाम देती है।

जैसे-जैसे आप Claude Code के साथ अधिक समय बिताएँगे, आप शायद अपना खुद का वर्कफ़्लो विकसित करेंगे। मेरा अब भी लगभग हर बार एक ही तरह शुरू होता है: पहले एक्सप्लोर, दूसरे नंबर पर प्लान, और अंत में इम्प्लीमेंट।

यह एक सरल आदत है, लेकिन इसने मुझे अनगिनत समीक्षा चक्रों से बचाया है और स्वायत्त वर्कफ़्लोज़ पर मुझमें पहले की तुलना में कहीं अधिक भरोसा जगाया है।

यदि आप स्वायत्त प्रणालियों के पीछे के व्यापक विचारों के बारे में और सीखना चाहते हैं, तो मैं निम्नलिखित संसाधनों की सिफारिश करता हूँ:

• Introduction to AI Agents 
• Introduction to Claude Models 
• Claude Code Hooks: A Practical Guide to Workflow Automation 
• Claude Agent SDK Tutorial: Create Agents Using Claude Sonnet 4.5 
• How to Build Claude Code Plugins 
• Claude Code 2.1: A Guide With Practical Examples 
• Model Context Protocol (MCP): A Guide With Demo Project 
• AI Agents with Hugging Face smolagent