Everything Claude Code (ECC): Claude Code के लिए ओपन-सोर्स एजेंट फ्रेमवर्क

नाम के बावजूद, एवरीथिंग क्लॉड कोड का Anthropic से कोई संबंध नहीं है। यह Claude Code के ऊपर बैठने वाला एक एजेंट सिस्टम और वर्कफ़्लो लेयर है (न कि कोई मॉडल, न ही IDE), जो एक सामान्य कोडिंग एजेंट को आपके मानकों से पहले से वाकिफ एक विशेष इंजीनियरिंग प्लेटफ़ॉर्म में बदल देता है।

इस लेख में, मैं बताऊंगा कि ECC क्या है, इसके हिस्से कैसे साथ काम करते हैं, इसे कैसे इंस्टॉल करें, और किन लोगों को वास्तव में इसका उपयोग करना चाहिए।

पर Claude Code है क्या? हमारे Claude Code 101 कोर्स में दाखिला लें और सीखें कि इसे अपने रोज़मर्रा के डेवलपमेंट वर्कफ़्लोज़ में कैसे इस्तेमाल करें।

Everything Claude Code क्या है?

ECC एक ओपन-सोर्स रेपो है जो इंजीनियरिंग कार्यों के लिए Claude Code को पहले से बने ऑपरेटिंग लेयर के साथ रैप करता है।

प्रोजेक्ट आपको यहां मिलेगा affaan-m/ECC on GitHub। यह MIT-लाइसेंस्ड है, Affaan Mustafa द्वारा मेंटेन किया जाता है, और असली प्रोडक्ट्स पर 10+ महीनों की रोज़ाना Claude Code उपयोग से बनाया गया है।

यह रेपो चार चीज़ों को एक इंस्टॉल में पैकेज करता है:

• एक एजेंट हार्नेस: विशेषीकृत सब-एजेंट्स का सेट (प्लानर, आर्किटेक्ट, कोड रिव्यूअर, सिक्योरिटी रिव्यूअर, बिल्ड-एरर रेज़ॉल्वर, और दर्जन भर और) जिनको Claude Code काम सौंपता है, बजाय इसके कि सब कुछ एक ही कॉन्टेक्स्ट विंडो में करने की कोशिश करे।
• एक स्किल इकोसिस्टम: कुछ सौ छोटे वर्कफ़्लो डिफिनिशन, जो TDD, सिक्योरिटी रिव्यू, फ्रेमवर्क पैटर्न (Django, Spring Boot, Next.js, आदि), भाषा-विशिष्ट कोडिंग मानक, और ML-इंजीनियरिंग कार्यों को कवर करते हैं।
• एक वर्कफ़्लो फ्रेमवर्क: टूल ईवेंट्स पर चलने वाले हुक्स, हमेशा लागू होने वाले नियम, MCP सर्वर कॉन्फ़िग्स, और सेशन मेमोरी जो बातचीतों के बीच बनी रहती है।
• एक कमांड्स लेयर: आम वर्कफ़्लोज़ चलाने के लिए मेंटेंड स्लैश एंट्रीज़, साथ ही पुराने कमांड नामों के लिए बैकवर्ड-कम्पैटिबल शिम फ़ोल्डर।

यह ध्यान रखना ज़रूरी है कि Claude Code अभी भी इंजन है। वही कोड पढ़ता है और टूल्स चलाता है।

ECC का काम उसके आसपास की हर चीज़ है: Claude Code को बताना कि कौन-सा सब-एजेंट यह कार्य संभालेगा, कौन-से वर्कफ़्लो स्टेप्स फॉलो होंगे, आपका स्टैक किन मानकों का उपयोग करता है, और कल की सेशन का कौन-सा संदर्भ साथ ले जाना है।

व्यवहार में, इसका मतलब है कि आपको हर प्रोजेक्ट के लिए Claude Code को फिर से शून्य से कॉन्फ़िगर नहीं करना पड़ता। आप ECC एक बार इंस्टॉल करते हैं, अपने स्टैक के लिए रूल पैक्स कॉपी करते हैं, और आपके पास एक विशेष इंजीनियरिंग प्लेटफ़ॉर्म होता है जो पहले से जानता है कि आगे कैसे बढ़ना है।

Everything Claude Code इतनी लोकप्रिय क्यों हो गई

विकास एक X थ्रेड से शुरू हुआ था।

2026 की शुरुआत में, Mustafa ने The Shorthand Guide to Everything Claude Code पोस्ट किया। कुछ ही दिनों में इसे 10K से ज़्यादा बुकमार्क मिले। फिर उन्होंने रेपो को ओपन-सोर्स किया, और अब ECC 200K स्टार्स और 34+ फोर्क्स पार कर चुका है।

यह क्यों हुआ, इसके कारण यहां हैं:

• एजेंटिक कोडिंग प्रयोग से रोज़मर्रा के उपयोग में आ गई: जैसे-जैसे अधिक डेवलपर्स ने Claude Code का इस्तेमाल किया, वे स्टॉक सिस्टम की सीमाओं से वाकिफ हुए। डेवलपर्स को एक प्री-बिल्ट कॉन्फ़िगरेशन लेयर चाहिए थी जो कोल्ड-स्टार्ट संदर्भ, असंगत कोड रिव्यू आउटपुट्स वगैरह को खत्म करे।
• अच्छे एजेंट प्रॉम्प्ट लिखना जितना लगता है उससे मुश्किल है: ठोस TDD वर्कफ़्लो या ऐसा कोड-रिव्यूअर प्रॉम्प्ट जो कॉन्फिडेंस के आधार पर फ़िल्टर करे—इन्हें सही बनाने में इटरेशन लगता है। बहुत-सी टीमें इसे बदलते मॉडलों के साथ शून्य से बनाना-मेंटेन नहीं करना चाहतीं, इसलिए किसी और के टेस्टेड वर्ज़न का पुन: उपयोग आसान राह है।
• योगदान जमा होते गए: 270+ योगदानकर्ताओं ने भाषा रूल पैक्स (Java, Kotlin, Rust, Perl, PHP), फ्रेमवर्क सपोर्ट (Quarkus, Laravel), अनुवाद, Claude Code से इतर IDE इंटीग्रेशन (Cursor, OpenCode, Zed), और स्किल्स जोड़े।
• बिना फाइन-ट्यूनिंग के विशेषज्ञता देता है: टीम कन्वेंशंस पर मॉडल को फाइन-ट्यून करना ज़्यादातर टीमों के लिए व्यावहारिक नहीं है। रनटाइम पर स्किल्स और एजेंट्स का संरचित सेट करीब-करीब वही असर देता है, और ECC इसे पैकेज करने के अधिक संपूर्ण प्रयासों में से एक है।

तो यह X थ्रेड से शुरू हुआ, और वहां से स्नोबॉल इफ़ेक्ट बन गया।

Everything Claude Code कैसे काम करता है

ECC एक लेयर्ड सिस्टम है।

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

Claude Code

Claude Code आधारभूत मॉडल इंटरफ़ेस है।

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

स्किल्स

स्किल्स पुन: प्रयोज्य वर्कफ़्लो निर्देश हैं, जो Markdown फ़ाइलों के रूप में संग्रहीत होते हैं।

हर स्किल एक छोटे फ़ोल्डर में होती है, जिसमें एक SKILL.md होता है, जो Claude Code को बताता है कि किसी विशेष प्रकार के कार्य को कैसे संभालना है। स्किल विवरण, स्टेप्स, अपेक्षित आउटपुट, और सीमाएँ बताती है। ECC के पास लगभग 260 स्किल्स हैं जो भाषा पैटर्न, टेस्टिंग वर्कफ़्लोज़, फ्रेमवर्क कन्वेंशंस, ML इंजीनियरिंग, और ऑपरेशनल कार्यों को कवर करते हैं।

याद रखने वाली बात यह है कि आप स्किल्स को मैन्युअली रन नहीं करते। Claude Code उन्हें इस आधार पर चुनता है कि आप क्या कर रहे हैं, या आप उन्हें प्रॉम्प्ट में संदर्भित करते हैं।

एजेंट्स

एजेंट्स वे विशेषीकृत सब-एजेंट हैं जिन्हें Claude Code डेलीगेट करता है।

हर एजेंट एक Markdown में परिभाषित होता है—नाम, विवरण, टूल अलाउलिस्ट, और सिस्टम प्रॉम्प्ट जो इसके व्यवहार का दायरा तय करता है। code-reviewer एजेंट केवल फाइलें पढ़ता है और निष्कर्ष रिपोर्ट करता है। planner कोई कोड छुए जाने से पहले इम्प्लीमेंटेशन ब्लूप्रिंट लिखता है। बात समझ में आ गई होगी।

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

MCP इंटीग्रेशंस

MCP (Model Context Protocol) वह तरीका है जिससे Claude Code बाहरी टूल्स और डेटा सोर्सेज से बात करता है।

ECC में MCP सर्वर्स के ज़रिए GitHub, Supabase, Vercel, Railway और अन्य से कनेक्ट करने के लिए कॉन्फ़िग्स हैं। हर सर्वर ऐसे टूल्स एक्सपोज़ करता है जिन्हें Claude Code सेशन के बीच में कॉल कर सकता है। ECC बस उनके काम करने वाले कॉन्फ़िग्स और सिक्योरिटी नियम पैकेज करता है।

डिफ़ॉल्ट रूप से ECC एक ही कनेक्टर सक्षम करता है (chrome-devtools)। बाकी सब ऑप्ट-इन हैं, जिससे टूल-नेम टकराव से बचाव होता है और अटैक सरफेस छोटा रहता है।

मेमोरी लेयर

मेमोरी लेयर ECC को सेशनों के बीच स्टेटफुल बनाती है।

हर बातचीत के Stop ईवेंट पर हुक्स चलते हैं और ~/.claude/sessions/ में एक सेशन सारांश लिख देते हैं। अगला सेशन SessionStart हुक के ज़रिए शुरुआत में प्रासंगिक संदर्भ लोड करता है। आपके पैटर्न्स से मॉडल जो स्किल्स "सीखता" है, उन्हें Continuous Learning v2 सिस्टम में एक्सट्रैक्ट किया जाता है, जहां वे कॉन्फिडेंस स्कोर के साथ इंस्टिंक्ट्स के रूप में स्टोर होते हैं और बाद में फिर से उपयोग किए जा सकते हैं।

सेशन एलियासेस, सीखी हुई स्किल्स, और मेट्रिक्स सभी एकल एजेंट डेटा रूट (डिफ़ॉल्ट ~/.claude, प्रति हार्नेस कॉन्फ़िगरेबल—यदि आप ECC को Claude Code और Cursor दोनों में चलाते हैं) के तहत रहते हैं।

हिस्से साथ में कैसे काम करते हैं

एक सामान्य सेशन कुछ ऐसा दिखता है:

1. सेशन शुरू: एक हुक पिछले सेशन का संदर्भ लोड करता है, साथ ही मौजूदा प्रोजेक्ट के लिए प्रासंगिक स्किल्स और नियम।
2. आप कुछ मांगते हैं: जैसे, "OAuth लॉगिन जोड़ें।"
3. सबसे पहले प्लानर एजेंट चलता है: यह एक ब्लूप्रिंट लिखता है, यानी अभी कोई कोड नहीं।
4. TDD स्किल आती है: Claude Code फेलिंग टेस्ट, न्यूनतम इम्प्लीमेंटेशन, और रिफैक्टर के वर्कफ़्लो का पालन करता है।
5. MCP टूल्स कॉल होते हैं: शायद GitHub MCP संबंधित PRs लाए, या Supabase MCP स्कीमा जाँचे।
6. अंत में कोड-रिव्यूअर एजेंट चलता है: यह अपने अलग कॉन्टेक्स्ट विंडो में डिफ़ का ऑडिट करता है और रिपोर्ट करता है।
7. सेशन समाप्त: एक Stop हुक सारांश लिखता है, नए पैटर्न्स को इंस्टिंक्ट्स में निकालता है, और अगली बार के लिए स्टोर करता है।

मॉडल अब भी Claude Code ही है। ECC बस हर चरण में कौन-सी स्किल, कौन-सा एजेंट, और कौन-सा टूल इस्तेमाल होगा, इसका संयोजन करता है।

Everything Claude Code में स्किल्स

स्किल्स वह प्राथमिक तरीका हैं जिनसे ECC Claude Code को बताता है कि क्या करना है।

एक स्किल एक फ़ोल्डर है जिसमें SKILL.md फ़ाइल होती है। Markdown विवरण, स्टेप्स, सीमाएँ, अपेक्षित आउटपुट, और जहां यह लागू होती है, वे सभी परिभाषित करता है। यह बस एक सादा टेक्स्ट फ़ाइल है जिसे मॉडल रनटाइम पर पढ़ता है।

और यह जानबूझकर ऐसा है। ECC कुछ भी “रीट्रेन” नहीं कर रहा, यह उन निर्देशों को लोड कर रहा है जिन्हें Claude उसी क्षण पढ़ता और फॉलो करता है।

स्किल्स रेपो रूट पर skills/ डायरेक्टरी में रहती हैं। इंस्टॉल के बाद, ये ~/.claude/skills/ में कॉपी हो जाती हैं। Claude Code उन्हें उस फ़ोल्डर के डायरेक्ट चिल्ड्रन के रूप में लोड करता है।

हर स्किल फ़ोल्डर का वही बुनियादी लेआउट होता है:

• SKILL.md - वर्कफ़्लो परिभाषा

• वैकल्पिक सपोर्टिंग फ़ाइलें (टेम्पलेट्स, स्क्रिप्ट्स, उदाहरण)

• टैगिंग और डिस्कवरी के लिए वैकल्पिक metadata.yaml

स्किल्स दो तरीकों से एजेंट व्यवहार को प्रभावित करती हैं। पहला, Claude Code सेशन शुरू में उन्हें पढ़ता है और रेफरेंस के लिए उपलब्ध रखता है। दूसरा, मॉडल आपकी मांग के आधार पर प्रासंगिक स्किल चुनता है। यदि आप कहते हैं "पहले फेलिंग टेस्ट लिखें," तो TDD स्किल सक्रिय हो जाती है। यदि आप कहते हैं "इसे SQL इंजेक्शन के लिए रिव्यू करें," तो सिक्योरिटी रिव्यू स्किल सक्रिय हो जाती है।

ECC लगभग 260 स्किल्स के साथ आता है। रेंज दिखाने के लिए कुछ उदाहरण:

• frontend-patterns: React और Next.js कन्वेंशंस। कॉम्पोनेंट संरचना, हुक उपयोग, सर्वर बनाम क्लाइंट कॉम्पोनेंट फैसले, स्टेट मैनेजमेंट पैटर्न।

• django-patterns, django-tdd, django-security, django-verification: पूरा Django स्टैक चार स्किल्स में विभाजित। एक आर्किटेक्चर के लिए, एक टेस्ट साइकिल के लिए, एक OWASP-स्टाइल ऑडिट्स के लिए, एक शिपिंग-से-पहले वेरिफ़ाई लूप के लिए।

• architect (architect एजेंट के साथ पेयर्ड): सिस्टम डिज़ाइन रिव्यू। स्किल परिभाषित करती है कि आर्किटेक्चर रिव्यू में क्या-क्या कवर होगा, कौन-से आर्टिफैक्ट्स बनेंगे, और कौन-से ट्रेड-ऑफ़्स सामने लाने हैं।

• tdd-workflow: रेड-ग्रीन-रिफैक्टर साइकिल। फेलिंग टेस्ट लिखें, उसे पास कराने के लिए न्यूनतम कोड लिखें, रिफैक्टर करें, कवरेज वेरिफाई करें। स्किल क्रम लागू कराती है।

• security-review: OWASP टॉप 10 ऑडिट चेकलिस्ट, हार्डकोडेड क्रेडेंशियल डिटेक्शन, इनपुट वेलिडेशन रिव्यू, और डिपेंडेंसी वल्नरेबिलिटी जाँच। स्किल तय करती है क्या स्कैन करना है और क्या फ़्लैग करना है।

Everything Claude Code में एजेंट्स

एजेंट्स अपनी अलग कॉन्टेक्स्ट विंडो वाले विशेष पर्सोना हैं।

हर एक agents/ फ़ोल्डर में एक Markdown फ़ाइल है—नाम, विवरण, टूल अलाउलिस्ट, और सिस्टम प्रॉम्प्ट के साथ। सिस्टम प्रॉम्प्ट एजेंट का काम तय करता है। टूल अलाउलिस्ट नियंत्रित करता है कि वह क्या कर सकता है (फाइलें पढ़ना, bash चलाना, MCP सर्वर्स कॉल करना, कोड लिखना)। Claude Code आपके लिए किसी टास्क को ऑटोमेटिकली किसी एजेंट को डेलीगेट कर देता है।

ECC में 66 एजेंट्स हैं। वे कुछ श्रेणियों में ग्रुप होते हैं।

प्लानिंग एजेंट्स किसी भी कोड के लिखे जाने से पहले चलते हैं।

planner एजेंट किसी फीचर रिक्वेस्ट को इम्प्लीमेंटेशन ब्लूप्रिंट में तोड़ता है: किन फ़ाइलों में बदलाव, किन इंटरफेसेज़ को परिभाषित करना, कौन-से टेस्ट लिखना, किन एज केसों को संभालना। architect एजेंट इससे उच्च स्तर पर जाता है: सिस्टम डिज़ाइन, डेटा मॉडल निर्णय, सर्विस बाउंड्रीज़। ये एजेंट केवल कोड पढ़ते हैं और प्लान लिखते हैं।

कोडिंग एजेंट्स इम्प्लीमेंटेशन का काम करते हैं।

tdd-guide टेस्ट-फर्स्ट साइकिल लागू कराता है। भाषा-विशिष्ट रेज़ॉल्वर्स जैसे go-build-resolver, pytorch-build-resolver, और kotlin-build-resolver अपने-अपने इकोसिस्टम में बिल्ड एरर्स ठीक करते हैं। refactor-cleaner अनुपयोगी कोड हटाता है।

आर्किटेक्चर एजेंट्स संरचनात्मक निर्णयों की समीक्षा करते हैं।

architect डिज़ाइन कवर करता है, database-reviewer क्वेरी पैटर्न और स्कीमा विकल्पों को, और mle-reviewer प्रोडक्शन ML पाइपलाइंस (डेटा कॉन्ट्रैक्ट्स, इवैल कवरेज, सर्विंग, मॉनिटरिंग) का ऑडिट करता है।

QA एजेंट्स बने हुए काम की पुष्टि करते हैं।

code-reviewer क्वालिटी और सिक्योरिटी के लिए डिफ़्स का कॉन्फिडेंस थ्रेशोल्ड के साथ ऑडिट करता है। security-reviewer OWASP-स्टाइल पास चलाता है। e2e-runner Playwright एंड-टू-एंड टेस्ट्स संभालता है। भाषा रिव्यूअर्स (typescript-reviewer, python-reviewer, go-reviewer, rust-reviewer, आदि) भाषा-विशिष्ट जाँचें संभालते हैं।

इन सबको अलग-अलग एजेंट्स में बाँटने का कारण है कॉन्टेक्स्ट आइसोलेशन।

जब code-reviewer चलता है, उसे केवल डिफ़ और रिव्यू स्किल के साथ एक नई कॉन्टेक्स्ट विंडो मिलती है। वह प्लानिंग नोट्स या बातचीत का इतिहास नहीं देखता। वह सिर्फ रिव्यू करता है। यह फोकस एक जनरल एजेंट से बेहतर आउटपुट देता है, जो एक ही कॉन्टेक्स्ट में प्लान, कोड, टेस्ट, और रिव्यू सब करता है—जैसा कि ज़्यादातर एड-हॉक Claude Code सेटअप्स में हो जाता है।

ECC में संदर्भ और मेमोरी प्रबंधन

ECC सेशनों के बीच सब कुछ नहीं भूलता, जैसा Claude Code करता है।

ECC में मेमोरी हुक्स की एक प्रणाली है जो सही समय पर फाइलें लिखती और फिर सही समय पर उन्हें वापस लोड करती है। ये बस डिस्क पर सादी Markdown और JSON फाइलें हैं।

तीन चीजें बनी रहती हैं:

1. सेशन सारांश सेशन के अंत में लिखे जाते हैं: आखिरी संदेश के बाद एक Stop हुक चलता है, पूरा ट्रांसक्रिप्ट लेता है, और ~/.claude/sessions/ में सारांश लिखता है। सारांश में क्या काम हुआ, क्या निर्णय हुए, क्या बाकी है—सब शामिल होता है। अगला सेशन इसे SessionStart हुक के दौरान पढ़ता है ताकि Claude को पता रहे कि चीजें कहां छूटी थीं।
2. इंस्टिंक्ट्स आपके सेशनों से निकाले गए पैटर्न हैं: Continuous Learning v2 सिस्टम देखता है कि आप क्या करते हैं और क्या काम करता है, फिर कॉन्फिडेंस स्कोर, एक्शन, सपोर्टिंग एविडेंस, और उदाहरणों के साथ व्यक्तिगत इंस्टिंक्ट्स लिखता है। /instinct-status चलाकर देखें क्या सीखा गया है। /evolve चलाकर संबंधित इंस्टिंक्ट्स को नई स्किल में क्लस्टर करें।
3. लॉग फाइलें ऑपरेशनल लेयर को ट्रैक करती हैं: जैसे हुक एक्जीक्यूशंस, स्किल रन, MCP कॉल्स, लागत, त्रुटियां। ये ~/.claude/metrics/ और ~/.claude/session-data/ के तहत रहती हैं। डीबगिंग और रेपो के साथ शिप होने वाले डैशबोर्ड GUI के लिए उपयोगी।

यदि आपको लगता है कि यह कोई बड़ी बात नहीं, तो यहां दो-एक कारण हैं जो आपको और सोचने पर मजबूर करेंगे:

• लंबे समय तक चलने वाले प्रोजेक्ट्स: छह महीने का रिफैक्टर हर सोमवार रीसेट नहीं होता। पिछले हफ्ते के निर्णय, ट्रेड-ऑफ़्स, और ज्ञात मुद्दे उस सारांश में होते हैं जो सेशन स्टार्ट पर लोड होता है।
• दोहराई गई व्याख्याओं की जरूरत नहीं: आप हर बार अपना स्टैक, अपने कन्वेंशंस, या "याद रखें हमने Postgres चुना है, Oracle नहीं" फिर से पेस्ट नहीं करते।
• कॉन्टेक्स्ट-विंडो सीमाओं के आसपास काम करना: एक मिलियन-टोकन विंडो के साथ भी, छह महीने का प्रोजेक्ट इतिहास नहीं समा सकता। सारांश ज़रूरी बातों को संकुचित कर देते हैं। पूरी हिस्ट्री डिस्क पर रहती है, मॉडल को प्रासंगिक हिस्सा मिलता है।

आप एनवायरनमेंट वेरिएबल्स से लोडेड संदर्भ ट्यून कर सकते हैं। ECC_SESSION_START_MAX_CHARS यह कैप करता है कि स्टार्ट पर कितना सारांश लोड होगा (डिफ़ॉल्ट 8,000 कैरेक्टर्स)। ECC_SESSION_START_CONTEXT=off इसे लो-कॉन्टेक्स्ट सेटअप्स के लिए डिसेबल करता है। ECC_SESSION_RETENTION_DAYS नियंत्रित करता है कि सेशन कितने दिनों तक प्रूनिंग से पहले टिके रहें।

यदि आप एक ही मशीन पर Claude Code और Cursor दोनों में ECC चलाते हैं, तो ECC_AGENT_DATA_HOME सेट करें ताकि उनकी मेमोरी अलग रहे। अन्यथा वे एक-दूसरे की सेशन फाइलें ओवरराइट कर देंगे।

Everything Claude Code में MCP सपोर्ट

MCP वह तरीका है जिससे Claude Code किसी भी चीज़ को कॉल करता है जो न फ़ाइल है न शेल कमांड।

Model Context Protocol Anthropic का मानक है जो भाषा मॉडलों को बाहरी टूल्स से जोड़ता है। एक MCP सर्वर अलग प्रोसेस के रूप में चलता है और टाइप्ड ऑपरेशंस का सेट एक्सपोज़ करता है: "यह Notion पेज पढ़ो" या "GitHub पर एक PR खोलो"। Claude Code उन ऑपरेशंस को फ़ंक्शन कॉल्स की तरह कॉल करता है।

ECC के साथ mcp-configs/mcp-servers.json में सामान्य सेवाओं—GitHub, Supabase, Vercel, Railway, Linear, आदि—के लिए MCP कॉन्फ़िग्स आते हैं। हर एंट्री में सर्वर शुरू करने का कमांड, आवश्यक एनवायरनमेंट वेरिएबल्स, और ECC द्वारा लागू सिक्योरिटी नियम शामिल हैं।

यह जानना फ़ायदेमंद है कि ECC इन्हें ऑटो-एनेबल नहीं करता।

जून 2026 की MCP कनेक्टर पॉलिसी ने डिफ़ॉल्ट-एनेबल्ड सर्वर्स को एक (chrome-devtools) तक घटा दिया। बाकी सब ऑप्ट-इन हैं। आप या तो एंट्री को अपने प्रोजेक्ट की .mcp.json में कॉपी करते हैं, या Claude Code के /mcp कमांड से एनेबल करते हैं। इसका कारण आंशिक रूप से व्यावहारिक है (लंबे MCP टूल नाम कुछ गेटवे तोड़ते हैं) और आंशिक रूप से सुरक्षा का चुनाव (हर MCP सर्वर संभावित अटैक सरफेस है)।

व्यवहार में यह सपोर्ट कुछ यूं दिखता है:

• बाहरी इंटीग्रेशंस: .mcp.json में GitHub एंट्री डालें, एक टोकन दें, और Claude Code बिना कॉपी-पेस्ट के इश्यू पढ़ सकता है, PR खोल सकता है, और CI स्टेटस देख सकता है।

• टूल कॉलिंग: स्किल्स और एजेंट्स MCP टूल्स को नाम से संदर्भित करते हैं। उदाहरण के लिए, एक डिप्लॉयमेंट स्किल Vercel MCP को कॉल कर सकती है, और एक डेटाबेस रिव्यू एजेंट Supabase MCP को।

• प्रोजेक्ट ऑटोमेशन: आप MCP सर्वर्स को हुक्स के साथ मिलाकर सेशनों के पार स्थायी ऑटोमेशन पा सकते हैं। PR-ओपन हुक एक रिव्यू एजेंट शुरू कर सकता है जो GitHub MCP से डिफ़ लाता है और Linear MCP से टिकट अपडेट करता है।

यदि आप किसी भी MCP की अपनी कॉपी पहले से चलाते हैं जिन्हें ECC बंडल करता है, तो ECC_DISABLED_MCPS को कॉमा-सेपरेटेड लिस्ट पर सेट करें। ECC इंस्टॉल और सिंक के दौरान उन्हें स्किप कर देगा, ताकि एक ही सर्वर नाम पर डुप्लिकेट्स की लड़ाई न हो।

AgentShield और सुरक्षा फ़ीचर्स

सिक्योरिटी वह चीज़ है जो ECC को प्रतिस्पर्धा से अलग करती है।

AgentShield ECC के साथ आने वाला एक स्टैंडअलोन सिक्योरिटी ऑडिटर है। यह Claude Code कॉन्फ़िगरेशंस को वल्नरेबिलिटीज़, मिसकॉन्फ़िगरेशंस, एरर्स, और इंजेक्शन जोखिमों के लिए स्कैन करता है। यह एक अलग npm पैकेज (ecc-agentshield) के रूप में चलता है, लेकिन यह ECC से /security-scan स्किल के ज़रिए जुड़ा है, ताकि आप इसे Claude Code सेशन के अंदर से चला सकें।

स्कैन पाँच श्रेणियों को कवर करता है:

• सीक्रेट्स डिटेक्शन: हार्डकोडेड क्रेडेंशियल्स, API कीज़, टोकन्स के 14 पैटर्न।
• परमिशन ऑडिटिंग: हर एजेंट और स्किल किन टूल्स और पाथ्स तक पहुंच सकती है, और क्या वे ग्रांट्स बहुत व्यापक तो नहीं।
• हुक इंजेक्शन विश्लेषण: क्या हुक्स का दुरुपयोग कर मनमाने कमांड चलाए जा सकते हैं।
• MCP सर्वर जोखिम प्रोफाइलिंग: हर कनेक्टेड MCP सर्वर क्या पढ़, लिख, या कॉल कर सकता है, और इससे कहां एक्सपोज़र बनता है।
• एजेंट कॉन्फ़िग रिव्यू: प्रॉम्प्ट इंजेक्शन वेक्टर्स, टूल अलाउलिस्ट का अत्यधिक ग्रांट, मिसिंग कंस्ट्रेंट्स।

आप इसे इस कमांड से चला सकते हैं, इंस्टॉलेशन की जरूरत नहीं:

npx ecc-agentshield scan

आउटपुट एक लेटर ग्रेड (A से F) और फाइंडिंग्स की सूची होती है, गंभीरता के अनुसार सॉर्टेड। क्रिटिकल फाइंडिंग्स पर एग्जिट कोड 2 रहता है।

यहां कुछ फ़्लैग्स हैं जिन्हें जानना उपयोगी है:

• -fix सुरक्षित मुद्दों के लिए ऑटो-फिक्सेस लागू करता है (एक्सपोज़्ड सीक्रेट्स हटाना, अत्यधिक व्यापक परमिशन्स को टाइट करना…)

• -opus स्कैन को तीन Claude Opus 4.X एजेंट्स के ज़रिए रेड-टीम / ब्लू-टीम / ऑडिटर पाइपलाइन में चलाता है। अटैकर एक्सप्लॉइट चेन्स ढूंढने की कोशिश करता है। डिफेंडर प्रोटेक्शंस का मूल्यांकन करता है। ऑडिटर दोनों को समेकित कर प्रायोरिटाइज़्ड रिस्क रिपोर्ट बनाता है।

• -stream विश्लेषण लाइव स्ट्रीम करता है, जो धीमी कॉन्फ़िग्स पर उपयोगी है।

Opus-पाइपलाइन अप्रोच AgentShield को एक जनरिक लिंटर से अलग करता है। एडवर्सेरियल एजेंट्स ऐसे तरीकों की तलाश करते हैं जिनसे ज्ञात-OK कॉम्पोनेंट्स को जोड़कर कुछ एक्सप्लॉइटेबल बनाया जा सके—यही ज़्यादातर असली एजेंट अटैक्स की जड़ होती है।

रेपो के अनुसार AgentShield 102 स्टैटिक एनालिसिस नियम और 1,282 इंटरनल टेस्ट्स को 98% कवरेज पर रिपोर्ट करता है। आंकड़ों की नवीनतम रिलीज़ के मुकाबले जांच करना उचित है, पर यह स्पष्ट है कि यह 50-लाइन का स्क्रिप्ट नहीं है।

आउटपुट फॉर्मैट्स में टर्मिनल (कलर-ग्रेडेड), JSON (CI के लिए), Markdown, और HTML शामिल हैं। एक GitHub Action भी है और एक अलग ECC Tools GitHub App भी जो PRs पर AgentShield चलाता है।

ज़्यादातर टीमों के लिए जो प्रोडक्शन में Claude Code का उपयोग करती हैं, केवल AgentShield ही ECC इंस्टॉल करने का सबसे ठोस कारण है—चाहे आप बाकी फ्रेमवर्क न भी उपयोग करें।

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

ECC के दो इंस्टॉल पथ हैं।

सबसे आम टूटी-फूटी सेटअप वह है जिसमें प्लगइन इंस्टॉल को मैनुअल इंस्टॉल के ऊपर स्टैक कर दिया जाता है। दोनों ही वही फाइलें, वही जगह कॉपी करते हैं, और आपके पास डुप्लिकेट्स हो जाते हैं। तो सबसे पहले: केवल एक ही पथ चुनें।

इंस्टॉल से पहले, सुनिश्चित करें कि आपके पास Claude Code v2.1.0 या बाद का वर्ज़न इंस्टॉल है:

claude --version

Claude संस्करण

प्लगइन मैनेजर के ज़रिए इंस्टॉलेशन

यह ज़्यादातर उपयोगकर्ताओं के लिए अनुशंसित पथ है।

Claude Code के अंदर से चलाएं:

/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

प्लगइन इंस्टॉलेशन

पहला कमांड ECC रेपो को मार्केटप्लेस के रूप में रजिस्टर करता है। दूसरा कमांड प्लगइन इंस्टॉल करता है।

एक चेतावनी यह है कि प्लगइन सिस्टम नियम वितरित नहीं करता। नियम वे हमेशा-फॉलो होने वाले दिशानिर्देश हैं (कोडिंग स्टाइल, git वर्कफ़्लो, टेस्टिंग स्टैंडर्ड्स, भाषा-विशिष्ट पैटर्न), और Claude Code की प्लगइन स्पेक में ये नहीं आते। आपको प्लगइन इंस्टॉल के बाद उन्हें मैन्युअली कॉपी करना होता है।

git clone https://github.com/affaan-m/ECC.git
cd ECC
mkdir -p ~/.claude/rules/ecc
cp -r rules/common ~/.claude/rules/ecc/
cp -r rules/python ~/.claude/rules/ecc/

rules/common के साथ एक ऐसा भाषा पैक कॉपी करें जिसका आप वास्तव में उपयोग करते हैं। ऊपर दिए उदाहरण में, मैंने Python नियम कॉपी किए हैं। सब कुछ कॉपी न करें, क्योंकि ज़्यादा नियमों का मतलब है हर सेशन में ज़्यादा संदर्भ लोड होना—और अधिकांश आपके प्रोजेक्ट पर लागू नहीं होंगे।

कॉनफ़िगरेशन फाइल्स के ज़रिए इंस्टॉलेशन

यदि आप पूरा नियंत्रण चाहते हैं, या आपके सेटअप पर प्लगइन इंस्टॉल काम नहीं करता, तो यह तरीका अपनाएं।

git clone https://github.com/affaan-m/ECC.git
cd ECC
npm install
./install.sh --profile full

Windows पर:

.\install.ps1 --profile full
# or
npx ecc-install --profile full

यह आपके ~/.claude/ डायरेक्टरी में एजेंट्स, स्किल्स, कमांड्स, हुक्स, और नियमों को कॉपी करता है। कोई प्लगइन लेयर शामिल नहीं। सब कुछ डिस्क पर फाइल्स के रूप में रहता है जिन्हें Claude Code सेशन स्टार्ट पर पढ़ता है।

कुछ प्रोफाइल विकल्प जो जानने लायक हैं:

• -profile minimal: केवल नियम, एजेंट्स, कमांड्स, और कोर स्किल्स—हुक्स के बिना।

• -profile core: डिफ़ॉल्ट वर्किंग सेट। हुक्स शामिल।

• -profile full: रेपो की हर चीज़।

आप --modules या --with के साथ विशिष्ट कॉम्पोनेंट्स भी इंस्टॉल कर सकते हैं:

./install.sh --target claude --modules hooks-runtime
npx ecc install --profile minimal --target claude --with capability:machine-learning

यदि आप सुनिश्चित नहीं हैं कि कौन-से कॉम्पोनेंट्स आपके काम के लिए उपयुक्त हैं, पैक किए गए सलाहकार से पूछें:

npx ecc consult "security reviews" --target claude

यह मिलते-जुलते कॉम्पोनेंट्स और सटीक इंस्टॉल कमांड्स लौटाता है।

इंस्टॉलेशन सत्यापित करना

देखें क्या इंस्टॉल हुआ है:

/plugin list ecc@ecc

प्लगइन इंस्टॉलेशन सत्यापन

यह प्लगइन से उपलब्ध एजेंट्स, कमांड्स, और स्किल्स दिखाता है। मैन्युअल इंस्टॉल्स के लिए, लाइफसाइकल रैपर का उपयोग करें:

node scripts/ecc.js list-installed
node scripts/ecc.js doctor

doctor मिसिंग फाइल्स, टूटे हुक्स, और वर्ज़न मिसमैच की जांच करता है। यदि कुछ फ़्लैग करे, तो चलाएं:

node scripts/ecc.js repair

यह पक्का करने के लिए कि Claude Code नए प्लगइन को देख रहा है, एक सेशन खोलें और कोई स्लैश कमांड आज़माएं:

/ecc:plan "Add user authentication"

ECC प्लान आउटपुट

प्लगइन इंस्टॉल के लिए नेमस्पेस्ड /ecc: प्रीफ़िक्स आवश्यक है। मैन्युअल इंस्टॉल के लिए शॉर्ट फॉर्म (/plan) काम करता है।

यदि कुछ डुप्लिकेट या टूटा हुआ लगे, तो ऊपर से फिर से इंस्टॉल न करें। पहले node scripts/uninstall.js --dry-run चलाएं ताकि दिखे क्या हटेगा, फिर node scripts/uninstall.js से क्लीन-अप करें। ECC केवल वही फाइलें हटाता है जिन्हें उसने इंस्टॉल किया था, इसलिए असंबंधित कॉन्फ़िग अपरिवर्तित रहती है।

स्किल्स, कमांड्स, और वर्कफ़्लोज़ के साथ काम करना

ECC में आपका अधिकांश काम कमांड्स के बजाय स्किल्स के ज़रिए चलता है।

कारण यह है कि commands/ फ़ोल्डर अभी भी बैकवर्ड कम्पैटिबिलिटी के लिए मेंटेन है, पर नया वर्कफ़्लो डेवलपमेंट पहले skills/ में होता है।

यहां कुछ उपयोग पैटर्न हैं जो आपके रोज़मर्रा के काम का अधिकांश भाग कवर कर देंगे।

स्किल इनवोकेशन ज़्यादातर निहित (इम्प्लिसिट) होता है

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

जब आप स्पष्ट होना चाहें, तो प्रॉम्प्ट में स्किल का संदर्भ दें: "नया एंडपॉइंट जोड़ने के लिए django-tdd स्किल का उपयोग करें।" या कोई कमांड चलाएं जो उसे रैप करता है:

/code-review
/security-scan

/ecc:plan "Add OAuth login"

प्लगइन इंस्टॉल्स के लिए /ecc: प्रीफ़िक्स आवश्यक है। मैनुअल इंस्टॉल्स शॉर्ट फॉर्म (/plan, /code-review) इस्तेमाल करते हैं।

ECC प्लानिंग चरण आउटपुट

फ़ाइल टार्गेटिंग वर्कफ़्लो का हिस्सा है

अधिकांश एजेंट्स और स्किल्स एक विशिष्ट स्कोप पर काम करते हैं: कोई फ़ाइल, डायरेक्टरी, डिफ़, PR। आप स्कोप सेट करते हैं—प्रॉम्प्ट में फ़ाइल का ज़िक्र कर, इन्वोक करने से पहले उसे अपने एडिटर में खोलकर, या एजेंट को किसी पाथ पर पॉइंट कर:

/code-review src/auth/
/python-review services/billing/payment.py

एजेंट स्कोप उठा लेता है, केवल ज़रूरी फाइलें लोड करता है, और अपनी अलग कॉन्टेक्स्ट विंडो में रन करता है।

शेल इंटीग्रेशन Claude Code के bash टूल से चलता है

स्किल्स किसी भी वास्तविक एक्जीक्यूशन के लिए शेल में जा सकती हैं, जैसे टेस्ट्स चलाना, बिल्ड करना, लिंटिंग, या कोई CLI कॉल करना। TDD स्किल pytest या go test चलाती है। बिल्ड-फिक्स एजेंट असली एरर्स देखने के लिए वास्तविक बिल्ड चलाता है। सिक्योरिटी-स्कैन स्किल npx ecc-agentshield scan चलाती है और आउटपुट पार्स करती है।

स्किल यह परिभाषित करती है कि कौन-से शेल कमांड कब चलेंगे। हुक्स भी टूल ईवेंट्स पर शेल कमांड चला सकते हैं (हर एडिट के बाद टाइपचेक चलाना, सेव से पहले console.log पर चेतावनी देना)।

MCP प्रबंधन अधिकांशतः ऑप्ट-इन है

इंस्टॉल के बाद, ECC डिफ़ॉल्ट रूप से ठीक एक MCP सर्वर एनेबल करता है (chrome-devtools)। और जोड़ने के लिए, mcp-configs/mcp-servers.json से एंट्रीज़ अपने प्रोजेक्ट की .mcp.json में कॉपी करें, फिर Claude Code के /mcp कमांड से एनेबल करें। /mcp इंटरफ़ेस एनेबलिंग, डिसेबलिंग, और री-ऑथेंटिकेटिंग संभालता है।

यदि आप ECC द्वारा बंडल किए MCP सर्वर्स की अपनी कॉपी चलाते हैं, तो सेट करें:

export ECC_DISABLED_MCPS="github,supabase"

ECC का इंस्टॉलर और सिंक फ़्लो उन्हें स्किप कर देगा, ताकि एक ही टूल नामों पर दो सर्वर्स की टक्कर न हो।

वर्कफ़्लोज़ आपस में चेन होते हैं

आप स्किल्स को एक-एक कर के नहीं चलाते। एक सामान्य फीचर वर्कफ़्लो कुछ ऐसा दिखता है:

/ecc:plan "Add OAuth login with Google"
# planner agent writes a blueprint

# tdd-workflow skill activates as you implement
# tests fail, code gets written, tests pass

/code-review
# code-reviewer agent audits the diff

/security-scan
# AgentShield checks the new code and config

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

Everything Claude Code बनाम प्रतिद्वंद्वी कॉन्फ़िगरेशन फ्रेमवर्क्स

ECC Claude Code के लिए एकमात्र कॉन्फ़िगरेशन लेयर नहीं है। कुछ और भी हैं जो समान काम अलग समझौतों के साथ करते हैं।

श्रेणी पहले साफ़ करना जरूरी है। ECC उन अन्य कॉन्फ़िगरेशन फ्रेमवर्क्स से टकराता है जो Claude Code के ऊपर बैठते हैं। यह उन हार्नेस से प्रतिस्पर्धा नहीं करता जिनके साथ यह चलता है (Cursor, Codex, OpenCode, Zed) या स्टैंडअलोन एजेंट प्लेटफ़ॉर्म्स (OpenHands, LangGraph, CrewAI) से—जो अलग श्रेणियों के टूल हैं।

तीन प्रतिद्वंद्वी अक्सर सामने आते हैं।

BMAD-Method एक एजाइल SDLC फ्रेमवर्क है जिसमें विशेषज्ञ रोल-आधारित एजेंट्स (Analyst, PM, Architect, Scrum Master, Developer, QA) हैं। यह Claude Code, Cursor, और Windsurf पर npx bmad-method install के ज़रिए चलता है। यह शुरुआती प्लानिंग चरण में चमकता है—किसी धुंधले आइडिया को PRD, आर्किटेक्चर डॉक, और डीकॉम्पोज्ड स्टोरीज़ में बदल देता है, किसी भी कोड से पहले। एक्ज़ीक्यूशन टूलिंग ECC से हल्की है। कोई सिक्योरिटी स्कैनर नहीं और कोई MCP कैटलॉग नहीं। भाषा-विशिष्ट पैटर्न भी कम हैं।

SuperClaude एक हल्का Markdown-आधारित कॉन्फ़िग फ्रेमवर्क है। लगभग 30 स्लैश कमांड्स, 20 एजेंट्स, और दो-एक बिहेवियरल मोड्स। इसे pip install SuperClaude से इंस्टॉल करें। यह डिजाइन से ECC से सरल है—कोई सिक्योरिटी स्कैनिंग नहीं और कोई ऑर्केस्ट्रेशन रनटाइम नहीं। पर Claude Code से आगे कोई इन-बिल्ट मेमोरी लेयर भी नहीं है। यदि आप एक काम करने वाला CLAUDE.md और अच्छी तरह टेस्टेड प्रॉम्प्ट्स का सेट चाहते हैं, तो SuperClaude अच्छा चुनाव है।

claude-flow / Ruflo (जिसका नाम 2026 की शुरुआत में Claude Flow से बदला गया) एक मल्टी-एजेंट स्वॉर्म ऑर्केस्ट्रेटर है। यह SPARC मेथडोलॉजी (specification, pseudocode, architecture, refinement, completion) का उपयोग करता है और 60-100+ विशेष एजेंट्स की क्वीन-लीड हायरार्की को पैरेलल में चलाता है। इसमें AgentDB के ज़रिए पर्सिस्टेंट मेमोरी है और यह Claude, GPT, Gemini, और Ollama पर काम करता है। इन्फ़्रास्ट्रक्चर ECC से भारी है, और यह पैरेलल एजेंट काम के लिए बना है, न कि सिंगल-सेशन प्रोडक्टिविटी के लिए।

यदि आप कमिट करने से पहले और विकल्प देखना चाहते हैं, तो awesome-claude-code Claude Code संसाधनों (एजेंट्स, स्किल्स, प्लगइन्स, MCP सर्वर्स, कॉन्फ़िग्स) की क्यूरेटेड डायरेक्टरी है। अधिकांश समुदाय की डिस्कवरी यहीं होती है।

संक्षेप में, यदि आप एजाइल-स्टाइल प्लानिंग चाहते हैं तो BMAD चुनें, हल्का कॉन्फ़िग लेयर चाहिए तो SuperClaude, पैरेलल मल्टी-एजेंट काम चाहिए तो Ruflo, और यदि आप सिक्योरिटी टूलिंग और इन-बिल्ट मेमोरी पर्सिस्टेंस के साथ एक संपूर्ण इंजीनियरिंग प्लेटफ़ॉर्म चाहते हैं तो ECC चुनें।

कौन Everything Claude Code का उपयोग करे?

ECC सभी के लिए नहीं है। यदि आप हफ़्ते में कुछ बार छोटे कामों के लिए ही Claude Code का उपयोग करते हैं, तो यह फ्रेमवर्क बहुत कम लाभ के लिए बहुत ज़्यादा ओवरहेड लगेगा। एक 100-लाइन का CLAUDE.md आपकी अधिकांश वास्तविक ज़रूरतें पूरी कर देगा।

ECC का फायदा तब होता है जब आप उस बिंदु से आगे बढ़ चुके हों।

यहां वे परिदृश्य हैं जब यह वनीला Claude Code से बेहतर फिट बैठता है:

• एआई इंजीनियर्स जो एजेंटिक सिस्टम बनाते हैं: यदि आप एजेंट वर्कफ़्लोज़ डिज़ाइन या डिप्लॉय कर रहे हैं, ECC एक काम करने वाला रेफरेंस है। एजेंट प्रॉम्प्ट्स, स्किल डिफिनिशंस, हुक कॉन्फ़िग्स पढ़ें, और जो काम करे उसे अपनाएं।
• डेवलपर प्रोडक्टिविटी के शौक़ीन: यदि आप अपने टूलिंग, डॉटफाइल्स, एडिटर सेटअप, शेल पर समय लगाते हैं, तो ECC Claude Code के लिए वैसा ही निवेश है। आप जितना ज़्यादा उपयोग करेंगे, उतना ज़्यादा लाभ मिलेगा।
• टीमें जो Claude Code को दैनिक इन्फ्रास्ट्रक्चर की तरह चलाती हैं: यदि आपकी टीम रोज़ाना कोड रिव्यू, प्लानिंग, रिफैक्टरिंग, या फीचर्स शिप करने के लिए Claude Code का उपयोग करती है, तो स्थिरता और ऑनबोर्डिंग पर बचाया गया समय जुड़ता जाता है। नए टीम सदस्य वही एजेंट्स और वही वर्कफ़्लोज़ पाते हैं।
• कोई भी जो जटिल एजेंट वर्कफ़्लोज़ बना रहा है: मल्टी-स्टेप पाइपलाइंस, सब-एजेंट ऑर्केस्ट्रेशन, MCP चेनिंग, पर्सिस्टेंट कॉन्टेक्स्ट—कुछ नाम भर। ECC ने इन अधिकांश समस्याओं को पहले ही सुलझा लिया है, और पैटर्न्स पुन: प्रयोज्य हैं, भले आप पूरा इंस्टॉल न करें।

यहां वे हैं जिन्हें ECC नहीं चुनना चाहिए:

• कैज़ुअल Claude Code उपयोगकर्ता: हफ्ते में कुछ सेशन "यह स्क्रिप्ट डिबग करने में मदद करें" के लिए—इसके लिए 60+ एजेंट्स, 260+ स्किल्स और मेमरी लेयर की ज़रूरत नहीं। सेटअप ओवरहेड वर्थ नहीं।

• सरल, एक-बार के कोडिंग कार्य: त्वरित स्क्रिप्ट्स, छोटे फिक्स, डेमो ऐप्स, थ्रोअवे प्रोटोटाइप्स। वनीला Claude Code इन्हें अच्छे से संभालता है, और ECC जोड़ने से बिना खास मूल्य के घर्षण बढ़ता है।

• टीमें जिनके पास पहले से कार्यशील सेटअप है: यदि आपका CLAUDE.md बढ़िया ट्यून है और वर्कफ़्लो स्थिर है, तो ECC पर शिफ्ट करने में माइग्रेशन समय लगेगा। जो हिस्से पसंद आएं उन्हें अपनाएं, बाकी छोड़ दें।

यदि आप अनिश्चित हैं, तो सुरक्षित कदम है—रेपो पढ़ें, दो-तीन एजेंट्स और स्किल्स कॉपी करें जो रोचक लगें, और अभी पूरे इंस्टॉल को स्किप करें।

ECC के लाभ और सीमाएँ

अब मैं ECC की कुछ ताकतों और कमजोरियों पर चलूंगा। निर्णय लेने से पहले दोनों जानना ज़रूरी है..

लाभ

• बड़ा स्किल लाइब्रेरी: लगभग 260 स्किल्स जो TDD, सिक्योरिटी ऑडिट्स, फ्रेमवर्क पैटर्न्स, भाषा मुहावरे, ML इंजीनियरिंग, डिप्लॉयमेंट, आदि कवर करती हैं। भले आप कुछ इंस्टॉल न करें, रेपो अच्छे स्किल डिफिनिशन लिखने का कामकाजी रेफरेंस है।
• वर्कफ़्लो रीयूज़: आपको कोड रिव्यू, प्लानिंग, रिफैक्टरिंग, और टेस्टिंग के टेस्टेड प्रॉम्प्ट्स मिलते हैं। खासकर कोड-रिव्यूअर एजेंट का प्रॉम्प्ट, जिसे वे लोग भी उद्धृत करते हैं जो ECC इस्तेमाल नहीं करते पर प्रॉम्प्ट उधार लेते हैं।
• स्थायी मेमोरी: सेशन सारांश और क्रॉस-सेशन कॉन्टेक्स्ट जैसी चीजें बॉक्स से बाहर काम करती हैं। अधिकतर अन्य Claude Code कॉन्फ़िग्स मेमोरी को छूते भी नहीं।
• मज़बूत MCP सपोर्ट: GitHub, Supabase, Vercel, Railway आदि के लिए प्री-बिल्ट कॉन्फ़िग्स।
• AgentShield: अकेला सिक्योरिटी स्कैनर ही ECC इंस्टॉल करने का कारण है—चाहे आप और कुछ न लें। कुछ ही अन्य Claude Code कॉन्फ़िग्स में इसके आसपास कुछ होता है।
• MIT के तहत ओपन सोर्स: कोर पर कोई पेवॉल नहीं। होस्टेड GitHub App और ECC Pro टियर अलग हैं।
• क्रॉस-प्लेटफ़ॉर्म: Claude Code, Cursor, Codex, OpenCode, Zed, Gemini, और अन्य पर काम करता है। यदि आप स्विच करें या कई चलाएं, तब भी वही एजेंट्स और स्किल्स उपयोग कर सकते हैं।

सीमाएँ

• लर्निंग कर्व: 60+ एजेंट्स, 260+ स्किल्स, तीन इंस्टॉल पथ, चार प्रोफाइल प्रकार, और एनवायरनमेंट वेरिएबल्स की एक परत। पहला हफ्ता ज्यादातर यह समझने में जाएगा कि क्या लोड है और हर कॉम्पोनेंट क्या करता है।

• सेटअप जटिलता: प्लगइन बनाम मैन्युअल इंस्टॉल, प्लगइन से नियम न वितरित होने की समस्या, पुराने Claude Code वर्ज़न्स में डुप्लिकेट-हुक्स की समस्या, MCP एनेबल/डिसेबल फ़्लो, मल्टी-हार्नेस उपयोग के लिए एजेंट डेटा होम वेरिएबल। अधिकांश दस्तावेज़ित हैं, पर काम तो है।

• मेंटेनेंस ओवरहेड: रेपो नियमित रूप से अपडेट होता है। कैटलॉग काउंट्स रिलीज़ों के बीच शिफ्ट होते हैं और स्किल नाम बदलते हैं।

• Claude Code इकोसिस्टम पर निर्भरता: ECC Claude Code की प्लगइन स्पेक, हुक सिस्टम, और MCP सपोर्ट पर निर्भर है। जब Claude Code उन्हें बदलता है, ECC को साथ चलना पड़ता है।

• कई उपयोग मामलों के लिए ओवर-इंजीनियरिंग: अधिकांश टीमों के लिए, 60-200 लाइनों का एक अच्छा CLAUDE.md ECC की 80% सुविधाएँ कवर कर देता है। बाकी 20% मूल्यवान है—पर तभी जब आप उसका उपयोग करें।

यह फ्रेमवर्क अभी के लिए सबसे संपूर्ण Claude Code कॉन्फ़िगरेशन लेयर है। पर "सबसे संपूर्ण" और "सभी के लिए आवश्यक" एक ही बात नहीं हैं।

निष्कर्ष

यदि आप Claude Code रोज़ाना उपयोग करते हैं, तो ECC देखने लायक है। यदि नहीं, तो भी रेपो पढ़ने लायक है—एजेंट वर्कफ़्लोज़ कैसे बनाए जाएँ जो व्यवहार में न टूटें, इसका कामकाजी रेफरेंस है।

किसी भी तरह, ECC यह स्पष्ट संकेत है कि सॉफ़्टवेयर डेवलपमेंट सिंगल-शॉट चैट सेशन्स के बजाय प्रोग्रामेबल एजेंट पाइपलाइंस की ओर बढ़ रहा है। इसे अच्छी तरह करने के फ्रेमवर्क अभी नए हैं, और ECC अब तक के सबसे संपूर्ण प्रयासों में से एक है। यह आखिरी नहीं होगा—और यही बात मायने रखती है।

यदि आप जनरेटिव AI और एजेंटिक कोडिंग में नए हैं, तो हमारे Generative AI Concepts कोर्स में दाखिला लें। यह आपको भविष्य के लिए मजबूत नींव देगा।