Claude Code डीप डाइव: आर्किटेक्चर, गवर्नेंस और इंजीनियरिंग प्रैक्टिसेस

0. TL;DR

यह लेख क्लॉड कोड (Claude Code) के छह महीने के गहन उपयोग और दो खातों पर प्रति माह $40 खर्च करने से सीखे गए सबक पर आधारित है। मुझे उम्मीद है कि यह सभी के लिए कुछ मूल्यवान इनपुट प्रदान करेगा।

शुरुआत में, मैंने इसे एक चैटबॉट (ChatBot) के रूप में इस्तेमाल किया, लेकिन जल्द ही एहसास हुआ कि चीजें गलत हो रही हैं: कॉन्टेक्स्ट (Context) गड़बड़ हो गया, टूल्स (Tools) बढ़ गए लेकिन प्रभावशीलता कम हो गई, और नियम लंबे होने के बावजूद अनदेखा किए गए। क्लॉड कोड (Claude Code) पर शोध करने के बाद, मुझे एहसास हुआ कि यह प्रॉम्प्ट (Prompt) की समस्या नहीं थी, बल्कि एक सिस्टम डिज़ाइन (system design) की समस्या थी।

मैं चर्चा करना चाहता हूं: क्लॉड कोड (Claude Code) अंदर से कैसे काम करता है, कॉन्टेक्स्ट (Context) गड़बड़ क्यों होता है और इसे कैसे नियंत्रित किया जाए, स्किल्स (Skills) और हुक्स (Hooks) को कैसे डिज़ाइन किया जाए, सबएजेंट्स (Subagents) का सही उपयोग, प्रॉम्प्ट कैशिंग (Prompt Caching) का आर्किटेक्चरल (architectural) प्रभाव, और वास्तव में उपयोगी CLAUDE.md कैसे लिखा जाए।

इसे समझने का सबसे सीधा तरीका यह है कि क्लॉड कोड (Claude Code) को छह परतों में विभाजित किया जाए:

केवल एक परत को मजबूत करने से असंतनाव पैदा होता है। यदि CLAUDE.md बहुत लंबा है, तो यह कॉन्टेक्स्ट (Context) को दूषित करता है; बहु बहुत से टूल्स (Tools) भ्रम पैदा करते हैं; बहुत से सबएजेंट्स (Subagents) स्थिति में बहाव (state drift) लाते हैं; सत्यापन (verification) को छोड़ने से यह पता लगाना मुश्किल हो जाता है कि चीजें कहां विफल हुईं।

1. यह अंदर से कैसे काम करता है

क्लॉड कोड (Claude Code) का मूल "उत्तर देना" नहीं है, बल्कि एक दोहराव वाला एजेंटिक लूप (agentic loop) है:

1Collect Context → Take Action → Verify Result → [Finish or Loop]
2     ↑                    ↓
3  CLAUDE.md          Hooks / Permissions / Sandbox
4  Skills             Tools / MCP
5  Memory

मैंने महसूस किया कि बाधाएं शायद ही कभी मॉडल के पर्याप्त स्मार्ट न होने के कारण होती हैं, बल्कि उसे गलत कॉन्टेक्स्ट (Context) देने या यह जांचने का कोई तरीका न होने के कारण होती हैं कि आउटपुट सही है या उसे वापस रोलबैक (roll back) किया जा सकता है।

ध्यान केंद्रित करने के लिए पाँच परतें:

इन परतों को देखने से समस्या निवारण आसान हो जाता है। अस्थिर परिणाम? कॉन्टेक्स्ट (Context) लोडिंग क्रम की जांच करें। ऑटोमेशन (automation) नियंत्रण से बाहर? नियंत्रण परत की जांच करें। लंबे सत्रों में गुणवत्ता में गिरावट? मध्यवर्ती उत्पादों ने कॉन्टेक्स्ट (Context) को दूषित कर दिया; प्रॉम्प्ट्स (Prompts) को ट्वीक (tweak) करने से बेहतर है एक नया सत्र शुरू करना।

2. अवधारणात्मक सीमाएं: MCP / Plugin / Tools / Skills / Hooks / Subagents

सरल नियम: नई क्रियाओं के लिए Tools/MCP का उपयोग करें, वर्कफ़्लो (workflows) के लिए Skills का, पृथक वातावरण के लिए Subagents का, अनिवार्य बाधाओं/ऑडिट (auditing) के लिए Hooks का, और क्रॉस-प्रोजेक्ट (cross-project) वितरण के लिए Plugins का।

3. कॉन्टेक्स्ट इंजीनियरिंग (Context Engineering): सबसे महत्वपूर्ण सिस्टम बाधा

बहुत से लोग कॉन्टेक्स्ट (Context) को "क्षमता मुद्दा" मानते हैं, लेकिन बाधा आमतौर पर शोर (noise) होती है। उपयोगी जानकारी अप्रासंगिक सामग्री में दब जाती है।

वास्तविक कॉन्टेक्स्ट लागत संरचना

क्लॉड कोड (Claude Code) का 200K कॉन्टेक्स्ट (Context) पूरी तरह से उपलब्ध नहीं है:

1200K Total Context
2├── Fixed Overhead (~15-20K)
3│   ├── System instructions: ~2K
4│   ├── Skill descriptors: ~1-5K
5│   ├── MCP Server tool definitions: ~10-20K  ← सबसे बड़ा छिपा हुआ हत्यारा
6│   └── LSP state: ~2-5K
7│
8├── Semi-fixed (~5-10K)
9│   ├── CLAUDE.md: ~2-5K
10│   └── Memory: ~1-2K
11│
12└── Dynamic Available (~160-180K)
13    ├── Chat history
14    ├── File content
15    └── Tool results

एक विशिष्ट MCP सर्वर (जैसे GitHub) में 20-30 टूल परिभाषाएं होती हैं, प्रत्येक ~200 टोकन (tokens), कुल 4,000-6,000 टोकन। 5 सर्वरों को जोड़ने से 25,000 टोकन (12.5%) की खपत होती है। बड़ी मात्रा में कोड पढ़ते समय यह महत्वपूर्ण है।

अनुशंसित कॉन्टेक्स्ट स्तरीकरण

1Always Resident    → CLAUDE.md: Project contract / build commands / prohibitions
2Path-based         → rules: Language / directory / file-type specific rules
3On-demand          → Skills: Workflows / domain knowledge
4Isolated           → Subagents: Large-scale exploration / parallel research
5Outside Context    → Hooks: Deterministic scripts / auditing / blocking

उन चीजों को लोड न करें जो आप कभी-कभार ही उपयोग करते हैं।

कॉन्टेक्स्ट सर्वोत्तम अभ्यास

• CLAUDE.md को छोटा, कड़ा और निष्पादन योग्य रखें। एन्थ्रोपिक (Anthropic) का स्वयं का ~2.5K टोकन है।
• बड़े संदर्भ दस्तावेज़ों को Skills की सहायक फ़ाइलों में ले जाएं।
• पथ/भाषा नियमों के लिए .claude/rules/ का उपयोग करें।
• खपत की निगरानी के लिए /context का उपयोग करें।

• कार्य स्विचिंग के लिए /clear और नए चरणों के लिए /compact का उपयोग करें।
• CLAUDE.md में कॉम्पैक्ट इंस्ट्रक्शन (Compact Instructions) लिखें ताकि नियंत्रित किया जा सके कि क्या संरक्षित है।

टूल आउटपुट शोर: एक और छिपा हुआ हत्यारा

डायनामिक टूल आउटपुट (जैसे cargo test या git log) आसानी से कॉन्टेक्स्ट (Context) भर सकता है। क्लॉड (Claude) को सब कुछ देखने की जरूरत नहीं है।

RTK (Rust Token Killer) एक अच्छा तरीका है: यह कमांड आउटपुट को क्लॉड (Claude) तक पहुंचने से पहले फ़िल्टर करता है। उदाहरण के लिए, यह हजारों लाइनों के टेस्ट आउटपुट को एक एकल सफलता संदेश में संक्षिप्त कर सकता है।

संपीड़न जाल

डिफ़ॉल्ट संपीड़न आर्किटेक्चर निर्णयों और बाधाओं को हटा सकता है।

समाधान: CLAUDE.md में कॉम्पैक्ट इंस्ट्रक्शन (Compact Instructions) निर्दिष्ट करें ताकि आर्किटेक्चर निर्णयों, संशोधित फ़ाइलों, सत्यापन स्थिति और TODOs को प्राथमिकता दी जा सके।

एक और सक्रिय समाधान: नया सत्र शुरू करने से पहले क्लॉड (Claude) से HANDOFF.md लिखवाएं ताकि प्रगति और मृत सिरों की व्याख्या की जा सके।

प्लान मोड (Plan Mode) का इंजीनियरिंग मूल्य

प्लान मोड (Plan Mode) अन्वेषण को निष्पादन से अलग करता है।

जटिल रीफैक्टरिंग (refactoring) के लिए, यह कोड करने में जल्दबाजी करने से बेहतर है। उन्नत टिप: एक क्लॉड (Claude) का उपयोग योजना लिखने के लिए करें और दूसरे का "वरिष्ठ इंजीनियर" के रूप में इसकी समीक्षा करने के लिए करें।

4. स्किल्स (Skills) डिज़ाइन: मांग पर लोड किए जाने वाले वर्कफ़्लो

स्किल्स (Skills) मांग पर ज्ञान और वर्कफ़्लो (workflows) हैं।

एक अच्छी स्किल (Skill) क्या बनाती है

• विवरण में कहना चाहिए "मुझे कब उपयोग करना चाहिए," "मैं क्या करता हूं" नहीं।
• पूर्ण चरण, इनपुट, आउटपुट और रुकने की स्थितियां हों।
• मुख्य भाग को नेविगेशन और मुख्य बाधाओं के लिए रखें; विवरण सहायक फ़ाइलों में ले जाएं।
• साइड इफेक्ट्स (side effects) वाली स्किल्स (Skills) के लिए disable-model-invocation: true सेट करें।

प्रगतिशील प्रकटीकरण

क्लॉड कोड (Claude Code) "प्रगतिशील प्रकटीकरण" पर जोर देता है: पहले इंडेक्स और नेविगेशन प्रदान करें, फिर आवश्यकतानुसार विवरण खींचें।

तीन विशिष्ट स्किल प्रकार

1. चेकलिस्ट (गुणवत्ता द्वार): जैसे, रिलीज़-चेक (release-check)।
2. वर्कफ़्लो (मानकीकृत संचालन): जैसे, रोलबैक (rollback) के साथ कॉन्फ़िग-माइग्रेशन (config-migration)।
3. डोमेन विशेषज्ञ (निर्णय ढांचा): जैसे, रनटाइमटाइम-डायग्नोसिस (runtime-diagnosis)।

कॉन्टेक्स्ट (Context) स्थान बचाने के लिए वर्णनकर्ताओं को छोटा रखें।

5. टूल (Tool) डिज़ाइन: क्लॉड (Claude) को सही ढंग से चुनने में मदद करना

एजेंट्स (Agents) के लिए टूल्स (Tools) को सुविधा संपूर्णता के बजाय सही उपयोग में आसानी पर ध्यान देना चाहिए।

अच्छे बनाम बुरे टूल्स

डिज़ाइन सिद्धांत: उपसर्गों (जैसे github_pr_*) का उपयोग करें, संक्षिप्त प्रारूपों का समर्थन करें, सहायक त्रुटि संदेश प्रदान करें, और बहुत अधिक खंडित टूल्स (Tools) उजागर करने से बचें।

आंतरिक टूल्स का विकास

"AskUserQuestion" टूल (Tool) का विकास दर्शाता है कि एक समर्पित टूल (Tool) मार्कडाउन (markdown) फ़ॉर्मेटिंग या एग्ज़िट (exit) पैरामीटर्स की तुलना में अधिक स्थिर है।

जैसे-जैसे मॉडल मजबूत हुए, टूडू टूल्स (Todo tools) एक "बेड़ी" बन गए। सर्च टूल्स (Search tools) RAG से Grep तक विकसित हुए, बेहतर लचीलापन और "प्रगतिशील प्रकटीकरण" के लिए।

6. हुक्स (Hooks): संचालन से पहले/बाद में अनिवार्य तर्क

हुक्स (Hooks) फ़ॉर्मेटिंग, फ़ाइल सुरक्षा और अधिसूचनाओं जैसी प्रक्रियाओं पर निर्धारणात्मक नियंत्रण प्राप्त करते हैं।

हुक्स (Hooks) के लिए उपयुक्त

सुरक्षित फ़ाइलों को अवरुद्ध करना, संपादन के बाद ऑटो-फ़ॉर्मेटिंग (auto-formatting), डायनामिक कॉन्टेक्स्ट (Git ब्रांच) इंजेक्ट करना, और अधिसूचनाएं।

प्रारंभिक त्रुटि का पता लगाना

7. सबएजेंट्स (Subagents): स्वतंत्र क्लॉड (Claude) उदाहरण

सबएजेंट्स (Subagents) पृथकता प्रदान करते हैं। रिपॉजिटरी स्कैन करने या टेस्ट चलाने जैसे कार्य भारी आउटपुट उत्पन्न करते हैं जिसे मुख्य थ्रेड (main thread) को अव्यवस्थित नहीं करना चाहिए।

स्पष्ट बाधाएं

टूल्स (Tools) को सीमित करें, सही मॉडल चुनें (अन्वेषण के लिए Haiku, समीक्षा के लिए Opus), और maxTurns सेट करें।

8. प्रॉम्प्ट कैशिंग (Prompt Caching): क्लॉड कोड (Claude Code) आर्किटेक्चर का मूल

क्लॉड कोड (Claude Code) प्रॉम्प्ट कैशिंग (Prompt Caching) के आसपास बनाया गया है। उच्च हिट दर पैसे बचाती है और दर सीमाएं बढ़ाती है।

कैशिंग के लिए प्रॉम्प्ट लेआउट

उपसर्ग मिलान के लिए क्रम मायने रखता है: System Prompt → Tool Definitions → Chat History → User Input।

सत्र के बीच में मॉडल न बदलें

मॉडल बदलने से कैश (cache) टूट जाता है। इसके बजाय हैंडऑफ़ के लिए सबएजेंट्स (Subagents) का उपयोग करें।

संघनन कार्यान्वयन

संघनन कैश हिट्स के कारण एक फ़ोर्क (fork) का उपयोग करके इतिहास को 1/10 लागत पर सारांशित करता है।

9. सत्यापन लूप (Verification Loops): कोई सत्यापनकर्ता नहीं, कोई इंजीनियरिंग एजेंट (Engineering Agent) नहीं

"क्लॉड (Claude) कहता है कि यह हो गया" सत्यापन के बिना बेकार है। सत्यापन को प्रॉम्प्ट (Prompt), स्किल (Skill) और CLAUDE.md में स्पष्ट रूप से परिभाषित करें।

10. उच्च-आवृत्ति कमांड

/context, /clear, /compact, और /memory जैसे कमांड सक्रिय रूप से कॉन्टेक्स्ट (Context) प्रबंधित करने में मदद करते हैं।

शासन और समानांतरता

उपयोगी छिपे हुए कमांड: /simplify (कोड समीक्षा), /rewind (चेकपॉइंटिंग), /btw (पक्ष प्रश्न), /insight (CLAUDE.md अपडेट के लिए सत्र का विश्लेषण)।

11. अच्छा CLAUDE.md कैसे लिखें

यह एक अनुबंध है, ज्ञानकोष नहीं।

इसमें बिल्ड/टेस्ट कमांड, आर्किटेक्चर सीमाएं, कोडिंग परंपराएं, सुरक्षा रेल और कॉम्पैक्ट इंस्ट्रक्शन (Compact Instructions) शामिल करें। अपनी गलतियों को सुधारने के बाद क्लॉड (Claude) से CLAUDE.md को अपडेट करने के लिए कहें।

12. हाल के अनुभव

Kaku (Rust + Lua) बनाने से सबक: पर्यावरण पारदर्शिता महत्वपूर्ण है ('doctor' कमांड का उपयोग करें), और हुक्स (Hooks) बहु-भाषा परियोजनाओं के लिए बहुत अच्छे हैं।

13. एंटी-पैटर्न (Anti-patterns)

<payload)**

14. स्वास्थ्य जांच

अपनी कॉन्फ़िगरेशन जांचने के लिए npx skills add tw93/claude-health का उपयोग करें।

15. निष्कर्ष

ध्यान "सुविधाओं का उपयोग कैसे करें" से हटकर "एजेंट (Agent) को बाधाओं के तहत कैसे चलने दें" पर केंद्रित हो जाता है। यदि आप "हो गया" को परिभाषित नहीं कर सकते, तो कार्य एजेंट (Agent) के लिए तैयार नहीं है।