मैंने Claude Code का सोर्स कोड पढ़ा ताकि आपको न पढ़ना पड़े

ज़्यादातर लोग Claude Code खोलते हैं, एक प्रॉम्प्ट टाइप करते हैं, जवाब का इंतज़ार करते हैं, फिर दूसरा प्रॉम्प्ट टाइप करते हैं।

यह वैसा ही है जैसे फेरारी खरीदना और उसे सिर्फ़ पहले गियर में चलाना।

मैं समझना चाहता था कि क्यों कुछ लोग Claude Code से दूसरों की तुलना में 10 गुना ज़्यादा हासिल कर पाते हैं। इसलिए मैंने वही किया जो कोई भी समझदार इंसान करेगा: मैंने पूरा सोर्स कोड पढ़ा (जब मैं कहता हूँ "मैंने", तो मेरा मतलब है, बिल्कुल, Claude Code ने)।

आर्किटेक्चर की 11 परतें। हज़ारों लाइनें। एक एजेंट ऑर्केस्ट्रेशन प्लेटफ़ॉर्म जो टर्मिनल चैट के रूप में छिपा हुआ है।

यहाँ बताया गया है कि सोर्स कोड इस चीज़ का वास्तव में उपयोग करने के तरीके के बारे में क्या बताता है।

1. CLAUDE.md हर बार लोड होता है। हर। एक। बार।

यह सबसे ज़्यादा लाभदायक काम है जो आप कर सकते हैं और लगभग कोई भी इसे ठीक से नहीं करता।

ज़्यादातर लोगों के पास या तो अपनी CLAUDE.md फ़ाइल में कुछ नहीं होता या उन्होंने इसमें पूरी बाइबल लिख दी होती है।

सोर्स कोड से पता चलता है कि Claude Code आपकी CLAUDE.md फ़ाइलों को हर क्वेरी इटरेशन पर पढ़ता है। सत्र की शुरुआत में नहीं। हर बार। इसका मतलब है कि हर बार जब आप कोई संदेश भेजते हैं, तो यह आपके निर्देशों को फिर से पढ़ता है।

यहाँ एक पूरा पदानुक्रम है:

• ~/.claude/CLAUDE.md — वैश्विक (आपकी कोडिंग शैली, प्राथमिकताएँ)

• ./CLAUDE.md — प्रोजेक्ट स्तर (आर्किटेक्चर निर्णय, परंपराएँ)

• .claude/rules/*.md — मॉड्यूलर नियम

• CLAUDE.local.md — निजी नोट्स (gitignored)

आपको 40,000 कैरेक्टर मिलते हैं। यह बहुत है। ज़्यादातर लोग शायद 200 का उपयोग करते हैं।

अपने आर्किटेक्चर निर्णय वहाँ डालें। अपनी फ़ाइल परंपराएँ। अपने टेस्टिंग पैटर्न। अपने "यह कभी मत करो" नियम। मॉडल उन्हें हर बार पढ़ता है। यही अंतर है Claude Code के एक सामान्य सहायक होने और Claude Code के आपका सहायक होने के बीच जो आपके कोडबेस को जानता है।

अगर आप इसे पढ़ने के बाद एक काम करते हैं, तो यही है।

2. सबएजेंट प्रॉम्प्ट कैश साझा करते हैं (समानांतरता लगभग मुफ़्त है)

यह वह चीज़ है जिसने मेरा दिमाग़ घुमा दिया।

जब Claude Code एक सबएजेंट को फ़ोर्क करता है, तो यह पैरेंट कॉन्टेक्स्ट की एक बाइट-समान कॉपी बनाता है। API इसे कैश करता है। इसलिए आपके कोडबेस के विभिन्न हिस्सों पर काम करने के लिए 5 एजेंट तैयार करने की लागत एक एजेंट के क्रमिक रूप से काम करने से मुश्किल से ज़्यादा होती है।

इसे फिर से पढ़ें।

5 एजेंट। 1 के बराबर लागत। क्योंकि वे सभी प्रॉम्प्ट कैश को हिट करते हैं।

ज़्यादातर लोग Claude Code का उपयोग एक एकल कार्यकर्ता की तरह करते हैं। एक बार में एक कार्य। इसके खत्म होने का इंतज़ार करें। इसे अगला काम दें।

सोर्स कोड में सबएजेंट के लिए सचमुच तीन निष्पादन मॉडल हैं:

• fork — पैरेंट कॉन्टेक्स्ट प्राप्त करता है, कैश-ऑप्टिमाइज़्ड

• teammate — tmux या iTerm में अलग पैन, फ़ाइल-आधारित मेलबॉक्स के माध्यम से संचार करता है

• worktree — अपना खुद का git worktree प्राप्त करता है, प्रति एजेंट अलग ब्रांच

आप Claude Code को 5 एजेंट तैयार करने के लिए कह सकते हैं: एक सुरक्षा ऑडिट कर रहा है, एक auth मॉड्यूल को रिफ़ैक्टर कर रहा है, एक टेस्ट लिख रहा है, एक डॉक्स अपडेट कर रहा है, एक बग फिक्स कर रहा है। सभी एक ही समय पर। सभी कैश साझा कर रहे हैं।

आर्किटेक्चर इसी के लिए बनाया गया है। इसका सिंगल-थ्रेडेड उपयोग करना आपराधिक है।

3. अनुमति प्रणाली कॉन्फ़िगर करने के लिए डिज़ाइन की गई है, क्लिक करने के लिए नहीं

हर बार जब Claude Code पूछता है "इस कार्रवाई की अनुमति दें?" और आप हाँ क्लिक करते हैं, तो यह कॉन्फ़िगरेशन की विफलता है, कोई सुविधा नहीं।

सोर्स कोड 5-स्तरीय सेटिंग्स कैस्केड दिखाता है:

1policy > flag > local > project > user

~/.claude/settings.json में आप ग्लोब पैटर्न सेट कर सकते हैं कि हमेशा क्या अनुमति है:

1{
2  "permissions": {
3    "allow": [
4      "Bash(npm *)",
5      "Bash(git *)",
6      "Edit(src/**)",
7      "Write(src/**)"
8    ]
9  }
10}

तीन अनुमति मोड हैं:

• bypass — कोई अनुमति जाँच नहीं (खतरनाक लेकिन तेज़)

• allowEdits — आपकी वर्किंग डायरेक्ट्री में फ़ाइल संपादन को स्वचालित रूप से अनुमति देता है

• auto (यह नया है) — प्रत्येक कार्रवाई पर एक LLM क्लासिफ़ायर चलाता है। यह सबसे अच्छा बिंदु है।

ऑटो मोड की अपनी अनुमति/अस्वीकार सूचियाँ हैं जिन्हें आप कॉन्फ़िगर कर सकते हैं। सोर्स कोड दिखाता है कि यह समानांतर में कई रिज़ॉल्वर चलाता है: उपयोगकर्ता क्लिक, हुक क्लासिफ़ायर, ब्रिज, और जो पहले जवाब देता है वह जीतता है।

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

4. 5 कॉम्पैक्शन रणनीतियाँ हैं। कॉन्टेक्स्ट प्रेशर एक वास्तविक समस्या है

सोर्स कोड में आपकी बातचीत को संपीड़ित करने के पाँच अलग-अलग तरीके हैं जब यह बहुत लंबी हो जाती है:

1. microcompact — पुराने टूल परिणामों का समय-आधारित सफ़ाई

1. context collapse — बातचीत के अंशों का सारांश

1. session memory — मुख्य संदर्भ को एक फ़ाइल में निकालता है

1. full compact — पूरे इतिहास का सारांश

1. PTL truncation — सबसे पुराने संदेश समूहों को हटा देता है

यह आपको कुछ महत्वपूर्ण बताता है: कॉन्टेक्स्ट ओवरफ़्लो एक केंद्रीय समस्या है जिस पर इंजीनियरों ने बहुत समय बिताया।

आपके लिए इसका क्या मतलब है:

• सक्रिय रूप से /compact का उपयोग करें। सिस्टम के ऑटो-कॉम्पैक्ट होने और आपके लिए महत्वपूर्ण कॉन्टेक्स्ट खोने का इंतज़ार न करें।

• डिफ़ॉल्ट विंडो 200K टोकन है। लेकिन आप [1m] मॉडल सफ़िक्स का उपयोग करके 1M टोकन का विकल्प चुन सकते हैं। कई फ़ाइलों में बड़े रिफ़ैक्टर के लिए, यह मायने रखता है।

• लंबे सत्र "session memory" जमा करते हैं — कार्य विनिर्देशों, फ़ाइल सूचियों, वर्कफ़्लो स्थिति, त्रुटियों और सीखों के संरचित सारांश। यही कारण है कि एक सत्र को फिर से शुरू करना नए सिरे से शुरू करने से बेहतर है।

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

जो लोग Claude Code से सबसे अधिक लाभ उठाते हैं, वे /compact का उपयोग वीडियो गेम में मैन्युअल सेव पॉइंट की तरह करते हैं। जो मायने रखता है उसे संरक्षित करें, जो नहीं करता उसे साफ़ करें, और आगे बढ़ते रहें।

5. हुक सिस्टम असली एक्सटेंशन API है (25+ लाइफ़साइकल इवेंट)

यह पावर-यूज़र फ़ीचर है जिसके बारे में लगभग कोई नहीं जानता।

सोर्स कोड 25+ लाइफ़साइकल इवेंट दिखाता है जिनमें आप हुक कर सकते हैं:

• PreToolUse — किसी भी टूल के निष्पादित होने से पहले चलता है

• PostToolUse — किसी भी टूल के निष्पादित होने के बाद चलता है

• UserPromptSubmit — जब आप कोई संदेश भेजते हैं तब चलता है

• SessionStart / SessionEnd — सत्र लाइफ़साइकल

• और 20+ और

5 प्रकार के हुक के साथ:

• command — एक शेल कमांड चलाएँ

• prompt — LLM के माध्यम से कॉन्टेक्स्ट इंजेक्ट करें

• agent — एक पूर्ण एजेंट सत्यापन लूप चलाएँ

• HTTP — एक वेबहुक कॉल करें

• function — JS चलाएँ

आप जो कर सकते हैं उसके वास्तविक उदाहरण:

• हर फ़ाइल लिखने से पहले ऑटो-लिंटिंग चलाएँ

• हर संपादन के बाद टेस्ट चलाएँ

• हर प्रॉम्प्ट में स्वचालित रूप से प्रासंगिक डॉक्स इंजेक्ट करें

• जब कोई कार्य पूरा हो जाए तो एक Slack सूचना भेजें

• सत्यापित करें कि कोड शिप होने से पहले सुरक्षा पैटर्न का पालन किया गया है

UserPromptSubmit हुक विशेष रूप से पागलपन भरा है। आप हर एक संदेश में additionalContext इंजेक्ट कर सकते हैं जो आप भेजते हैं। कल्पना करें कि बिना टाइप किए स्वचालित रूप से टेस्ट आउटपुट, हाल के git डिफ़, या प्रोजेक्ट स्थिति को हर प्रॉम्प्ट से जोड़ना।

इस तरह आप Claude Code के ऊपर एक कस्टम डेवलपमेंट एनवायरनमेंट बनाते हैं। बेहतर प्रॉम्प्टिंग करके नहीं। बल्कि सिस्टम में ही हुक करके।

6. सत्र स्थायी और फिर से शुरू करने योग्य हैं (नए सिरे से शुरू करना बंद करें)

हर बातचीत को JSONL के रूप में सहेजा जाता है

1~/.claude/projects/{hash}/{sessionId}.jsonl

सोर्स कोड समर्थन करता है:

• --continue — अपना अंतिम सत्र फिर से शुरू करें

• --resume — कोई विशिष्ट पिछला सत्र चुनें

• --fork-session — पिछली बातचीत से शाखा बनाएँ (मुझे व्यक्तिगत रूप से यह पसंद है)

सत्र मेमोरी निष्कर्षण कॉम्पैक्शन में मुख्य संदर्भ को संरक्षित करता है: कार्य विनिर्देश, फ़ाइल सूचियाँ, वर्कफ़्लो स्थिति, त्रुटियाँ और सीख।

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

--continue का उपयोग करें। हमेशा। कॉन्टेक्स्ट को जमा होने दें। सत्र मेमोरी को समय के साथ सीखने दें। सोर्स कोड में सचमुच इसके लिए बुनियादी ढाँचा है। इसका उपयोग करें।

7. टूल सिस्टम स्मार्ट बैचिंग के साथ 60+ टूल चलाता है

Claude Code में 60+ बिल्ट-इन टूल हैं। लेकिन दिलचस्प हिस्सा यह है कि यह उन्हें कैसे चलाता है।

सोर्स कोड टूल कॉल को दो श्रेणियों में विभाजित करता है:

• concurrent — केवल-पढ़ने के ऑपरेशन (फ़ाइलें पढ़ना, खोजना, ग्लोबिंग) समानांतर में चलते हैं

• serial — म्यूटेटिंग ऑपरेशन (एडिट, राइट, bash कमांड) एक बार में एक चलते हैं

इसका मतलब है कि जब Claude Code को आपके कोडबेस को समझने के लिए 10 फ़ाइलें पढ़ने की ज़रूरत होती है, तो यह सभी 10 को एक साथ पढ़ता है। लेकिन जब इसे 3 फ़ाइलों को संपादित करने की ज़रूरत होती है, तो यह उन्हें एक-एक करके करता है ताकि विरोध से बचा जा सके।

बिल्ट-इन टूल के अलावा, आप MCP सर्वर कनेक्ट कर सकते हैं जो और टूल जोड़ते हैं। सोर्स कोड डिफ़र्ड लोडिंग का उपयोग करता है। MCP टूल केवल ज़रूरत पड़ने पर लोड होते हैं, इसलिए 5 MCP सर्वर कनेक्ट करने से हर अनुरोध धीमा नहीं होता।

और उन टूल्स की डिफ़र्ड डिस्कवरी के लिए ToolSearch है जिनके बारे में एजेंट अभी तक नहीं जानता।

व्यावहारिक निष्कर्ष: यदि आपके वर्कफ़्लो में बाहरी सिस्टम (डेटाबेस, क्लाउड प्रदाता, CI/CD) शामिल हैं, तो उनके लिए MCP सर्वर कनेक्ट करें। आर्किटेक्चर जटिलता को संभालता है। आपको बस और क्षमताएँ मिलती हैं।

8. स्ट्रीमिंग आर्किटेक्चर का मतलब है कि रुकावट सस्ती है

पूरी पाइपलाइन अलग-अलग इवेंट देने वाले async जनरेटर का उपयोग करती है। Escape दबाने से पिछले कॉन्टेक्स्ट को खोए बिना वर्तमान स्ट्रीम को साफ़ रूप से रद्द कर दिया जाता है।

यह छोटा लगता है लेकिन यह बदल देता है कि आपको Claude Code का उपयोग कैसे करना चाहिए।

किसी ऐसे जवाब का इंतज़ार न करें जिसके बारे में आप जानते हैं कि गलत हो रहा है। तुरंत रुकावट डालें और पुनर्निर्देशित करें। सोर्स कोड इसके लिए डिज़ाइन किया गया है। आपका पिछला कॉन्टेक्स्ट संरक्षित है। बाधित प्रतिक्रिया को साफ़ रूप से हटा दिया जाता है। शून्य दंड।

इसे पेयर प्रोग्रामिंग की तरह समझें। अगर आपका साथी गलत रास्ते पर जाने लगता है, तो आप उसके खत्म होने का इंतज़ार नहीं करते। आप कहते हैं "असल में, इस तरह जाओ।" वही ऊर्जा।

9. रीट्राई सिस्टम आपके विचार से कहीं अधिक परिष्कृत है

सोर्स कोड दिखाता है:

• एक्सपोनेंशियल बैकऑफ़ और जिटर के साथ 10 रीट्राई (500ms बेस)

• 401/403 पर स्वचालित OAuth टोकन रिफ़्रेश

• मॉडल फ़ॉलबैक: यदि Opus 529 त्रुटियों के साथ 3 बार विफल होता है, तो यह स्वचालित रूप से Sonnet पर वापस आ जाता है

• स्ट्रीम पर 90-सेकंड का आइडल वॉचडॉग — यदि स्ट्रीमिंग रुक जाती है, तो यह नॉन-स्ट्रीमिंग पर वापस आ जाता है

• लगातार मोड में 5 मिनट के अधिकतम बैकऑफ़ के साथ अनंत रीट्राई है

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

संक्षेप में: सोर्स कोड से सबसे अधिक लाभदायक कार्य:

• एक वास्तविक CLAUDE.md लिखें → हर बार लोड होता है। 40K कैरेक्टर। सबसे अधिक लाभदायक कॉन्फ़िगरेशन।

• सबएजेंट के साथ समानांतर करें → fork मॉडल प्रॉम्प्ट कैश साझा करता है। 5 एजेंट ≈ 1 की लागत।

• settings.json में अनुमतियाँ कॉन्फ़िगर करें → क्लिक थकान को हमेशा के लिए खत्म करें।

• सक्रिय रूप से /compact का उपयोग करें → 5 कॉम्पैक्शन रणनीतियाँ मौजूद हैं क्योंकि कॉन्टेक्स्ट प्रेशर वास्तविक है।

• हुक सेट करें → 25+ इवेंट, 5 प्रकार। यह असली एक्सटेंशन API है।

• हमेशा --continue सत्र → JSONL पर्सिस्टेंस + सत्र मेमोरी = संचित कॉन्टेक्स्ट।

• MCP सर्वर कनेक्ट करें → डिफ़र्ड लोडिंग का मतलब है उपयोग होने तक शून्य लागत।

• स्वतंत्र रूप से रुकावट डालें → async जनरेटर का मतलब है पुनर्निर्देशन के लिए शून्य दंड।

मुख्य बात: Claude Code एक एजेंट ऑर्केस्ट्रेशन प्लेटफ़ॉर्म है जो टर्मिनल UI पहने हुए है।

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

सोर्स कोड इसे स्पष्ट करता है। अब आप जानते हैं कि यह वास्तव में हुड के नीचे क्या करता है।

अगर आपको यह मददगार लगा तो रीट्वीट करें 🫶