प्रोजेक्ट इनिशियलाइज़ेशन: /init के साथ एक क्लिक में CLAUDE.md जनरेट करें

📚 सीरीज़ नेविगेशन: पिछला लेख 11 वेब संस्करण और क्लाउड आपको टर्मिनल से बाहर ले गया और ब्राउज़र तथा क्लाउड वातावरण में Claude Code का उपयोग करना सिखाया। यह लेख स्थानीय वातावरण में वापस आता है, एक ऐसी आदत पर जो सबसे ज़्यादा ज़रूरी है — नए प्रोजेक्ट में प्रवेश करने के बाद सबसे पहला काम, /init टाइप करना, ताकि Claude खुद कोडबेस को स्कैन कर सके और प्रोजेक्ट मैनुअल लिख सके। अगला लेख: 13 प्रोजेक्ट संरचना।

दोस्तों, पहले एक आम बेवकूफी भरे काम के बारे में बात करते हैं।

जब मैंने पहली बार Claude Code का उपयोग करना शुरू किया था, तो मैंने एक पूर्व सहकर्मी द्वारा छोड़े गए Node बैकएंड प्रोजेक्ट को संभाला, और बिना /init चलाए सीधे काम शुरू कर दिया। जब मैंने पहली बार पूछा "टेस्ट कैसे रन करें", तो इसने जवाब देने से पहले पूरी package.json छान मारी; बीस मिनट बाद जब मैंने एक नया सेशन शुरू किया, तो इसने उसी सवाल के लिए फिर से शुरू से खोज की; दोपहर में जब टास्क बदला, तो इसने तीसरी बार पूछा "क्या यह प्रोजेक्ट npm का उपयोग करता है या pnpm का"।

इस बिंदु पर आकर मुझे सच में इससे चिढ़ हो गई थी — ऐसा नहीं है कि यह बेवकूफ है, बल्कि बात यह है कि इसे "प्रोजेक्ट मैनुअल" नहीं दिया गया था, इसलिए इसे हर बार शून्य से खोजना पड़ता था। जब आप किसी प्रोजेक्ट में प्रवेश करते ही /init टाइप करना सीख जाते हैं, तो ये सभी दोहराव खत्म हो जाते हैं: यह एक बार में पूरे प्रोजेक्ट को समझ लेता है, इसे एक CLAUDE.md के रूप में लिखकर सेव कर लेता है, और उसके बाद हर सेशन की शुरुआत में इस संदर्भ को अपने साथ लाता है, जिससे आपको बार-बार समझाने की आवश्यकता नहीं पड़ती।

सीधे शब्दों में कहें तो, /init बस एक काम करता है: "Claude हर बार आपके प्रोजेक्ट को फिर से समझे" को "एक बार समझे, और लंबे समय तक याद रखे" में बदल देता है। यह लेख स्पष्ट करेगा कि इसका उपयोग कैसे करें, जनरेट होने के बाद यह कैसा दिखता है, और यह वास्तव में आपका क्या बचाता है।

इस लेख को पढ़ने के बाद, आप सीखेंगे:

• /init द्वारा हल की जाने वाली मुख्य समस्या को समझना: "हर बार फिर से खोजने" से "एक बार जनरेट करना और दीर्घकालिक मेमोरी" तक
• ऑपरेशन्स का एक सेट जिसका आप सीधे पालन कर सकते हैं: प्रोजेक्ट की रूट डायरेक्टरी में claude शुरू करें और /init टाइप करें
• यह जानना कि यह बैकग्राउंड में क्या करता है: संरचना को स्कैन करना, टेक स्टैक की पहचान करना, और CLAUDE.md का ड्राफ्ट जनरेट करना
• यह समझना कि जनरेट किया गया CLAUDE.md मोटे तौर पर कैसा दिखता है और प्रत्येक भाग का क्या काम है
• एक महत्वपूर्ण समझ: /init केवल एक शुरुआत है, ड्राफ्ट को मैन्युअल रूप से पूरक किया जाना चाहिए (इसे कैसे पूरक करें, इसे 18वें लेख के लिए छोड़ दिया गया है)

---

01 /init क्यों होना चाहिए: Claude की "भूलने की बीमारी" की समस्या

पहले निष्कर्ष पर आते हैं: Claude Code जब भी कोई नया सेशन शुरू करता है, तो यह "भूलने की बीमारी" की स्थिति में होता है — इसे याद नहीं रहता कि आपने पिछली बार इससे क्या कहा था।

यह कोई बग नहीं है, यह इसका डिज़ाइन है। आधिकारिक दस्तावेज़ स्पष्ट रूप से बताता है:

प्रत्येक Claude Code सेशन एक बिल्कुल नई कॉन्टेक्स्ट विंडो के साथ शुरू होता है।

तुलना: ऐसा मान लें कि काम पर हर दिन एक नया इंटर्न आता है। इस इंटर्न में बहुत क्षमता है, लेकिन एक समस्या है — आज आपने उसे जो सिखाया, कल कोई और आएगा, और आपको सब कुछ फिर से सिखाना पड़ेगा। आप उसे बताते हैं "हम pnpm का उपयोग करते हैं, npm का नहीं", "टेस्ट tests/ डायरेक्टरी में हैं", "कमिट करने से पहले lint चलाना है", और अगले दिन एक नया व्यक्ति आता है, तो आपको शुरुआत से सब कुछ फिर से समझाना पड़ता है।

यही वह वास्तविक स्थिति है जब कोई CLAUDE.md नहीं होता है। पहले बताए गए Node प्रोजेक्ट में मैंने जो गलती की थी, वह इसी वजह से थी — Claude की याददाश्त कमज़ोर नहीं है, बल्कि उसके पास क्रॉस-सेशन मेमोरी कैरियर ही नहीं है।

तो फिर क्या करें? आधिकारिक तौर पर सेशन्स के बीच ज्ञान को पास करने के लिए दो तंत्र दिए गए हैं, और यह लेख केवल पहले वाले पर चर्चा करेगा:

तंत्र	कौन लिखता है	इसमें क्या होता है
CLAUDE.md फ़ाइल	आप (/init को ड्राफ्ट करने दे सकते हैं)	निर्देश और नियम: प्रोजेक्ट आर्किटेक्चर, बिल्ड कमांड्स, परंपराएँ
ऑटो मेमोरी	खुद Claude	इसके काम के दौरान जमा हुए अनुभव और डीबगिंग इनसाइट्स

ध्यान दें कि ऑटो मेमोरी की एक सख्त सीमा है: प्रत्येक सेशन केवल पहली 200 लाइनें या 25KB ही लोड करता है, और अतिरिक्त हिस्सा कॉन्टेक्स्ट में प्रवेश नहीं करता है — इसलिए बहुत अधिक चीज़ों को रटने के लिए ऑटो मेमोरी पर निर्भर रहना विश्वसनीय नहीं है, CLAUDE.md ही मुख्य टूल है।

CLAUDE.md (प्रोजेक्ट मेमोरी फ़ाइल) वह "हर दिन बदलने वाले इंटर्न" के लिए लिखी गई ऑनबोर्डिंग मैनुअल है — आप इसे पहले से लिखते हैं और इसे प्रोजेक्ट में रखते हैं, Claude हर शुरुआत में इसे पहले पढ़ता है, और तुरंत "याद" कर लेता है कि यह प्रोजेक्ट किस बारे में है।

और /init वह कमांड है जो आपको एक क्लिक से इस मैनुअल का पहला ड्राफ्ट जनरेट करने में मदद करता है।

💡 एक वाक्य में सारांश: Claude हर बार सेशन शुरू करते समय "भूल" जाता है, CLAUDE.md इसका क्रॉस-सेशन मेमोरी कैरियर है — /init आपको एक क्लिक में इस मेमोरी का पहला ड्राफ्ट लिखने में मदद करता है।

---

02 /init क्या है: Claude को अपना खुद का मैनुअल लिखने देना

/init Claude Code में एक अंतर्निहित स्लैश कमांड (इनपुट बॉक्स में / से शुरू होने वाला निर्देश) है।

यह जो करता है, उसे एक वाक्य में संक्षेप में प्रस्तुत किया जा सकता है: Claude को आपके प्रोजेक्ट को खुद स्कैन करने दें और इस प्रोजेक्ट के लिए विशिष्ट एक CLAUDE.md ड्राफ्ट जनरेट करने दें।

आधिकारिक दस्तावेज़ इसके बारे में बहुत सटीक है:

प्रारंभिक CLAUDE.md स्वचालित रूप से जनरेट करने के लिए /init चलाएं। Claude आपके कोडबेस का विश्लेषण करता है और एक फ़ाइल बनाता है जिसमें बिल्ड कमांड, परीक्षण निर्देश, और इसके द्वारा खोजे गए प्रोजेक्ट कन्वेंशन शामिल होते हैं।

तुलना: नए कर्मचारी को अपनी खुद की ऑनबोर्डिंग मैनुअल लिखने देना। आमतौर पर, ऑनबोर्डिंग मैनुअल पुराने कर्मचारियों द्वारा नए लोगों के पढ़ने के लिए लिखे जाते हैं। लेकिन /init इसका उल्टा करता है — यह इस "नए व्यक्ति" को पहले पूरे प्रोजेक्ट को खुद पढ़ने देता है, और फिर जो कुछ उसने पढ़ा है (कौन सी तकनीक उपयोग की गई है, डायरेक्टरीज़ कैसे विभाजित हैं, कमांड्स कैसे चलाएं) उसे एक मैनुअल में संकलित करता है। आप बाद में इसे देखकर बता सकते हैं कि इसने सही पढ़ा है या नहीं।

इस डिज़ाइन का लाभ बहुत वास्तविक है: प्रोजेक्ट में वस्तुनिष्ठ तथ्य (टेक स्टैक, डायरेक्टरी स्ट्रक्चर, कौन से स्क्रिप्ट कमांड्स हैं), Claude इन्हें खुद स्कैन करके निकाल सकता है, आपको इन्हें एक-एक शब्द टाइप करने की आवश्यकता नहीं है। आप जो ऊर्जा बचाते हैं, उसका उपयोग उन चीज़ों को पूरक करने के लिए किया जा सकता है जिन्हें यह स्कैन नहीं कर सकता (जैसे कि टीम के ब्रांच नेमिंग कन्वेंशन), और बस इतना ही काफी है।

आपको इसका उपयोग कब करना चाहिए? आमतौर पर ये कुछ ट्रिगरिंग स्थितियां होती हैं:

• किसी और द्वारा छोड़े गए प्रोजेक्ट को संभालना — आपने खुद भी इसे पूरी तरह से नहीं समझा है, इसलिए इसे आधार तैयार करने के लिए पहले इसे स्कैन करने दें
• आपके अपने प्रोजेक्ट में अभी तक CLAUDE.md नहीं है — आप इसे इसके बिना ही उपयोग कर रहे हैं, अब इसे जोड़ने का समय आ गया है
• बदलाव करने के लिए किसी ओपन-सोर्स प्रोजेक्ट को क्लोन करना — काम शुरू करने से पहले प्रोजेक्ट मैप प्राप्त करने के लिए /init का उपयोग करें

💡 एक वाक्य में सारांश: /init Claude को प्रोजेक्ट को खुद पढ़ने देता है और वस्तुनिष्ठ तथ्यों को एक CLAUDE.md ड्राफ्ट में संकलित करता है — आप तथ्यों को खोदने की अपनी ऊर्जा बचाते हैं, और उन चीज़ों को पूरक करने पर ध्यान केंद्रित करते हैं जिन्हें यह स्कैन नहीं कर सकता।

---

03 इसे कैसे चलाएं: डायरेक्टरी दर्ज करें, शुरू करें, कमांड टाइप करें

ऑपरेशन इतना सरल है कि यह लगभग एंटी-क्लाइमैटिक लगता है — claude शुरू करने के बाद, बस इनपुट बॉक्स में /init टाइप करें और बात खत्म।

पहला कदम: प्रोजेक्ट की रूट डायरेक्टरी में Claude Code शुरू करें।

यह कदम महत्वपूर्ण है, आपको claude शुरू करने से पहले प्रोजेक्ट की रूट डायरेक्टरी में cd करना होगा, आप इसे सीधे डेस्कटॉप या होम डायरेक्टरी से शुरू नहीं कर सकते। लेख 07 में इस बात पर ज़ोर दिया गया था: आप इसे जहाँ से शुरू करते हैं, Claude उसे अपना वर्कस्पेस मान लेता है और वहीं की फ़ाइलें पढ़ता है। होम डायरेक्टरी में /init चलाने पर, यह आपके ढेर सारे अव्यवस्थित व्यक्तिगत फ़ाइलों को स्कैन करेगा, और कुछ भी उपयोगी स्कैन नहीं कर पाएगा।

cd /path/to/your-project
claude

दूसरा कदम: इनपुट बॉक्स में /init टाइप करें, और एंटर दबाएं।

/init

बस इतना ही। इसके बाद आपको कुछ नहीं करना है, बाकी सब Claude खुद चलाएगा — पूरी प्रक्रिया के लिए किसी मैन्युअल ऑपरेशन की आवश्यकता नहीं है, यह अपने आप विश्लेषण करेगा और आउटपुट देगा।

तो बैकग्राउंड में यह वास्तव में क्या करता है? इसे कई बार चलते हुए देखने के बाद, यह मोटे तौर पर फ्लो है:

पूरी चीज़ को एक लाइन में जोड़ा जाए तो यह है: प्रोजेक्ट डायरेक्टरी में claude शुरू करें → /init टाइप करें → Claude प्रोजेक्ट संरचना को स्कैन करता है, टेक स्टैक की पहचान करता है → डिस्क पर एक CLAUDE.md ड्राफ्ट सेव करता है → फिर आप इसे मैन्युअल रूप से फाइन-ट्यून और पूरा करते हैं। पहले चार चरण मूल रूप से स्वचालित हैं, और अंतिम चरण "मैन्युअल फाइन-ट्यूनिंग" ही ड्राफ्ट को एक अच्छे मैनुअल में बदलने की कुंजी है। इस लेख में केवल इसका उल्लेख किया गया है, लेख 18 इस पर विस्तार से चर्चा करेगा।

आधिकारिक तौर पर, इस चरण को "आपके कोडबेस का विश्लेषण करना" कहा जाता है। विशेष रूप से यह किन फ़ाइलों को स्कैन करता है, व्यवहारिक रूप से ये मुख्य श्रेणियां हैं (इसे चलाने के बाद, यह मूल रूप से इन्हें जांचेगा):

• डिपेंडेंसी मैनिफेस्ट: package.json (Node), requirements.txt (Python), pom.xml (Java) जैसे दस्तावेज़ — जिनका उपयोग टेक स्टैक और चलाए जा सकने वाले कमांड्स को निर्धारित करने के लिए किया जाता है
• मौजूदा दस्तावेज़: README और अन्य — यह समझने के लिए कि प्रोजेक्ट क्या करता है
• कॉन्फ़िगरेशन फ़ाइलें + कोड संरचना: यह समझने के लिए कि डायरेक्टरीज़ कैसे विभाजित हैं और एंट्री पॉइंट कहाँ है

⚠️ एक आसानी से नज़रअंदाज़ किया जाने वाला विवरण: यदि प्रोजेक्ट में पहले से ही एक CLAUDE.md है, तो /init उसे क्रूरता से ओवरराइट नहीं करेगा। आधिकारिक दस्तावेज़ स्पष्ट रूप से कहता है — इस मामले में यह ओवरराइट करने के बजाय सुधारों का सुझाव देगा। जब मैंने एक ऐसे प्रोजेक्ट में फिर से /init टाइप किया जिसमें पहले से ही एक CLAUDE.md लिखा हुआ था, तो मुझे चिंता थी कि यह मेरी मेहनत पर पानी फेर देगा, लेकिन इसने ईमानदारी से कुछ सुझाव सूचीबद्ध किए कि "यहाँ क्या जोड़ा जा सकता है", और मूल पाठ की एक भी लाइन नहीं बदली। यह डिज़ाइन काफी विचारशील है।

💡 एक वाक्य में सारांश: प्रोजेक्ट की रूट डायरेक्टरी में cd करें, claude शुरू करें, /init टाइप करें, और बाकी इसे स्वचालित रूप से स्कैन करने दें — यदि पहले से कोई CLAUDE.md है, तो यह केवल सुधार का सुझाव देगा, उसे ओवरराइट नहीं करेगा।

---

04 जनरेट होने के बाद यह कैसा दिखता है: CLAUDE.md ड्राफ्ट का ब्रेकडाउन

/init चलाने के बाद, प्रोजेक्ट की रूट डायरेक्टरी में एक नई CLAUDE.md फ़ाइल होगी। इसे खोलें, और आपको एक स्पष्ट रूप से संरचित Markdown दिखाई देगा।

तुलना: एक मानक प्रोजेक्ट मैनुअल। यह घटनाओं का क्रमिक विवरण नहीं है, बल्कि खंडों में विभाजित है — प्रोजेक्ट क्या करता है, कौन सी तकनीकों का उपयोग किया गया है, डायरेक्टरीज़ कैसे विभाजित हैं, कमांड्स कैसे टाइप करें, और क्या परंपराएँ हैं। एक नया व्यक्ति (जिसमें अगले सेशन में "भूलने की बीमारी" वाला Claude भी शामिल है) केवल इन खंडों को देखकर जान जाएगा कि प्रोजेक्ट किस बारे में है।

जनरेट की गई सामग्री आमतौर पर इन क्षेत्रों को कवर करती है (विशिष्ट फ़ील्ड इस बात पर निर्भर करेंगे कि Claude आपके प्रोजेक्ट की वास्तविक स्थिति के आधार पर क्या तय करता है, नीचे एक विशिष्ट उदाहरण दिया गया है):

# प्रोजेक्ट का नाम

## प्रोजेक्ट का अवलोकन
संक्षेप में बताएं कि यह प्रोजेक्ट क्या करता है और इसके मुख्य कार्य क्या हैं।

## टेक स्टैक
- Frontend: React + TypeScript
- Backend: Node.js + Express
- Database: PostgreSQL

## डायरेक्टरी संरचना
- `src/components/` - React कंपोनेंट्स
- `src/api/`        - API लेयर
- `tests/`          - टेस्ट फ़ाइलें

## सामान्य कमांड्स
- डेवलपमेंट सर्वर शुरू करें: `pnpm dev`
- टेस्ट रन करें: `pnpm test`
- कोड लिंट करें: `pnpm lint`

## डेवलपमेंट कन्वेंशन्स
- TypeScript strict मोड का उपयोग करें
- कमिट करने से पहले `pnpm test` चलाएं

आइए प्रत्येक ब्लॉक के मूल्य को एक-एक करके बताएं — ये वही चीज़ें हैं जो Claude आपसे पहले बार-बार पूछता था:

यह ब्लॉक	इसमें क्या होता है	यह आपके लिए कौन सा दोहराव बचाता है
प्रोजेक्ट का अवलोकन	प्रोजेक्ट का उद्देश्य, मुख्य कार्य	हर बार "यह प्रोजेक्ट क्या करता है" समझाने की आवश्यकता नहीं
टेक स्टैक	कौन सा फ्रेमवर्क, भाषा, डेटाबेस इस्तेमाल किया गया है	हर बार पूछने की आवश्यकता नहीं "क्या यह React है या Vue"
डायरेक्टरी संरचना	मुख्य डायरेक्टरीज़ में क्या है, एंट्री पॉइंट कहाँ है	हर बार यह खोजने की आवश्यकता नहीं "API कोड किस फ़ोल्डर में है"
सामान्य कमांड्स	स्टार्ट, टेस्ट, लिंट कैसे टाइप करें	हर बार कमांड खोजने के लिए package.json पलटने की आवश्यकता नहीं
डेवलपमेंट कन्वेंशन्स	प्रोजेक्ट कन्वेंशन्स (जैसे strict मोड)	हर बार याद दिलाने की आवश्यकता नहीं "strict मोड चालू करना याद रखें"

क्या आप समझे? पहले वाले Node प्रोजेक्ट में जो घिसे-पिटे सवाल पूछे गए थे "टेस्ट कैसे रन करें" और "npm या pnpm का उपयोग करें", वे पूरी तरह से "सामान्य कमांड्स" और "टेक स्टैक" द्वारा एक ही बार में कवर कर लिए गए। एक बार मैनुअल लिखकर वहां रख दिया जाए, तो Claude शुरुआत में इसे खुद पढ़ लेगा, और ये दोहराव वाले संवाद सीधे शून्य हो जाएंगे।

जहाँ तक इस बात का सवाल है कि इस फ़ाइल को कहाँ रखा जाए — आधिकारिक रूप से सुझाया गया स्थान प्रोजेक्ट की रूट डायरेक्टरी में ./CLAUDE.md (या ./.claude/CLAUDE.md) है। /init डिफ़ॉल्ट रूप से इसे आपके लिए सही स्थान पर रख देता है, इसलिए आपको पाथ के बारे में चिंता करने की आवश्यकता नहीं है। अधिक विस्तृत पदानुक्रमित संबंध (उपयोगकर्ता स्तर और प्रोजेक्ट स्तर को कैसे सुपरइम्पोज़ करें), लेख 18 के लिए छोड़े गए हैं।

💡 एक वाक्य में सारांश: जनरेट किया गया CLAUDE.md "अवलोकन / टेक स्टैक / डायरेक्टरी / कमांड्स / कन्वेंशन्स" में विभाजित है, और प्रत्येक ब्लॉक ठीक से एक प्रकार के बार-बार पूछे जाने वाले प्रश्न को संबोधित करता है — फ़ाइल कहाँ रखनी है, यह /init आपके लिए संभाल लेगा।

---

05 महत्वपूर्ण समझ: /init एक शुरुआत है, अंत नहीं

इस लेख में मैं आपको यही एक बात सबसे ज़्यादा याद रखना चाहता हूँ: /init एक ड्राफ्ट जनरेट करता है, अंतिम ड्राफ्ट नहीं।

मैन्युअल रूप से कुछ चीज़ें जोड़ना क्यों ज़रूरी है? क्योंकि कुछ चीज़ें ऐसी हैं जिन्हें Claude पूरे कोडबेस को स्कैन करके भी नहीं ढूंढ सकता — वे कोड में होती ही नहीं हैं, वे केवल आपके और आपकी टीम के दिमाग में होती हैं।

यहाँ कुछ उदाहरण दिए गए हैं जिनका अनुमान Claude खुद कभी नहीं लगा सकता:

• ब्रांच नेमिंग कन्वेंशन: आपकी टीम feature/xxx, fix/xxx का उपयोग करने के लिए सहमत है, यह किस फ़ाइल में लिखा है? कहीं नहीं। Claude इसे स्कैन नहीं कर सकता।
• डिप्लॉयमेंट प्रक्रिया: क्या main में मर्ज करने से स्वचालित रूप से डिप्लॉयमेंट ट्रिगर होता है, या आपको इसे मैन्युअल रूप से क्लिक करना होगा? यह प्रोजेक्ट कोड से नहीं देखा जा सकता।
• Code Review आवश्यकताएं: "PR को दो लोगों द्वारा approve किया जाना चाहिए", "कोर मॉड्यूल में बदलाव के लिए पहले Plan Mode में प्रपोज़ल देना होगा" — ये टीम के छिपे हुए नियम हैं।
• बिज़नेस बैकग्राउंड: इस हिस्से को इस तरह क्यों डिज़ाइन किया गया, कौन सा मॉड्यूल छूने पर आसानी से समस्या पैदा कर सकता है — ये "क्यों" आपके दिमाग में छिपे हैं।

सही तरीका है लगातार सुधार करना, न कि इसे एक बार में पक्का कर देना।

पहले बताया गया Node प्रोजेक्ट इस बात का नकारात्मक उदाहरण है: मुझे लगा कि /init चलाने के बाद सब कुछ ठीक हो गया और मैंने कुछ भी नहीं जोड़ा। परिणामस्वरूप, इसके द्वारा जनरेट किए गए "सामान्य कमांड्स" में मेरे द्वारा लिखी गई डिप्लॉयमेंट स्क्रिप्ट छूट गई (क्योंकि वह स्क्रिप्ट scripts/ में छिपी थी और package.json में एक्सपोज़ नहीं की गई थी), इसलिए Claude ने स्वाभाविक रूप से इसे स्कैन नहीं किया। मुझे मैन्युअल रूप से CLAUDE.md में एक पंक्ति जोड़नी पड़ी "डिप्लॉयमेंट के लिए ./scripts/deploy.sh का उपयोग करें", तब जाकर यह पूरा हुआ। इसलिए सही आदत निश्चित है: /init चलाने के बाद, इसे तुरंत एक बार पूरा पढ़ें, और उन कड़े प्रतिबंधों को मैन्युअल रूप से जोड़ें जिन्हें यह स्कैन नहीं कर सकता।

तो सही दृष्टिकोण की तुलना इस प्रकार है:

❌ गलत उपयोग	✅ सही उपयोग
/init चलाने के बाद इसे छोड़ दें, इसे अंतिम ड्राफ्ट के रूप में उपयोग करें	/init चलाने के बाद इसे पूरा पढ़ें, और इसे समीक्षा के लिए एक ड्राफ्ट के रूप में मानें
इससे उम्मीद करें कि यह टीम के सभी नियमों को स्कैन कर लेगा	उन कड़े प्रतिबंधों को मैन्युअल रूप से जोड़ें (ब्रांच, डिप्लॉयमेंट, Review) जिन्हें यह स्कैन नहीं कर सकता
इसे एक बार जनरेट करें और इसे कभी न बदलें	प्रोजेक्ट के विकसित होने के साथ इसे लगातार अपडेट करें, पुरानी चीज़ों को हटा दें

बस कार्य के इस विभाजन को याद रखें: /init वस्तुनिष्ठ तथ्यों को तेज़ी से निकालने और आधार तैयार करने के लिए ज़िम्मेदार है (जिसमें यह बहुत अच्छा है), और आप सब्जेक्टिव कन्वेंशन्स और बिज़नेस बैकग्राउंड जोड़ने के लिए ज़िम्मेदार हैं (जिसे केवल आप जानते हैं)। दोनों पक्ष मिलकर ही वास्तव में एक उपयोगी CLAUDE.md बना सकते हैं।

जहां तक बात है "इस ड्राफ्ट को एक संक्षिप्त और उपयोगी मैनुअल में कैसे बदला जाए" — जैसे पदानुक्रम कैसे डिज़ाइन करें, इसे तोड़ने के लिए उद्धरणों का उपयोग कैसे करें, इसे लंबे समय तक कैसे बनाए रखें — यह लेख 18 "CLAUDE.md उपयोगकर्ता मार्गदर्शिका" का काम है। इस लेख के लिए, आपको बस यह सुनिश्चित करना है कि "आपके पास यह है", और इसे "अच्छी तरह से लिखना" अगला कदम है।

💡 एक वाक्य में सारांश: /init केवल आधार तैयार करने के लिए वस्तुनिष्ठ तथ्यों को निकालता है; टीम के नियम और डिप्लॉयमेंट प्रक्रियाएं जैसी ज़रूरी चीज़ें जिन्हें यह स्कैन नहीं कर सकता, आपको मैन्युअल रूप से जोड़नी होंगी — ड्राफ्ट केवल तभी मान्य होता है যখন इसकी समीक्षा कर ली जाए।

---

06 हैंड्स-ऑन: एक न्यूनतम प्रोजेक्ट के लिए /init को सफलतापूर्वक चलाना

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

पहला कदम: एक न्यूनतम प्रोजेक्ट बनाएं (Mac / Linux)

mkdir init-demo
cd init-demo
echo '{"name": "init-demo", "scripts": {"test": "echo test ok"}}' > package.json
echo 'console.log("hello from init-demo");' > index.js

Windows PowerShell उपयोगकर्ता: mkdir init-demo और cd init-demo टाइप करें, फिर नोटपैड का उपयोग करके package.json और index.js फ़ाइलें बनाएं, और ऊपर दिए गए सिंगल कोट्स के अंदर की सामग्री को पेस्ट करके सेव करें।

अपेक्षा: init-demo फ़ोल्डर में दो फ़ाइलें package.json और index.js होनी चाहिए। ls (Windows पर dir) टाइप करने से आपको दोनों दिखनी चाहिए।

दूसरा कदम: प्रोजेक्ट डायरेक्टरी में Claude Code शुरू करें

claude

अपेक्षा: स्वागत स्क्रीन दिखाई देती है, और नीचे एक इनपुट बॉक्स होता है। पुष्टि करें कि टर्मिनल वर्तमान में init-demo डायरेक्टरी में है।

तीसरा कदम: /init चलाएं

इनपुट बॉक्स में टाइप करें:

/init

अपेक्षा: Claude स्क्रॉल करना शुरू कर देगा — आप देखेंगे कि यह package.json और index.js पढ़ रहा है, प्रोजेक्ट का विश्लेषण कर रहा है, और फिर फ़ाइलें लिख रहा है। पूरा होने के बाद, यह आपको बताएगा कि CLAUDE.md जनरेट हो गया है। चूंकि इस प्रोजेक्ट में केवल दो फ़ाइलें हैं, इसलिए पूरी प्रक्रिया बहुत तेज़ होगी, कुछ सेकंड से लेकर दस सेकंड से थोड़ा अधिक समय तक।

चौथा कदम: पुष्टि करें कि CLAUDE.md जनरेट हो गया है

Claude से बाहर निकलें (exit टाइप करें या Ctrl+D दबाएं), और वापस टर्मिनल पर जाएं:

cat CLAUDE.md

(Windows PowerShell के लिए type CLAUDE.md का उपयोग करें)

अपेक्षा: टर्मिनल पर एक Markdown प्रिंट होगा, जिसमें आप कम से कम प्रोजेक्ट का नाम init-demo, टेक स्टैक Node.js / JavaScript के रूप में देख सकते हैं, और वह test कमांड (echo test ok) "रनिंग टेस्ट" के रूप में पहचाना गया है। यह देखना = /init सफलतापूर्वक चल गया है, इसने वास्तव में आपके इस छोटे से प्रोजेक्ट को समझ लिया है और याद कर लिया है।

पांचवां कदम (वैकल्पिक): सत्यापित करें कि इसे "याद" है

claude में फिर से प्रवेश करें, और पूछें:

इस प्रोजेक्ट का टेस्ट कमांड क्या है?

अपेक्षा: यह package.json को फिर से देखे बिना आपको सीधे टेस्ट कमांड बता देगा — क्योंकि उत्तर उस CLAUDE.md में पहले से ही लिखा है जिसे उसने शुरुआत में पढ़ा था। इस एक कदम से, आप अपनी आँखों से देखेंगे कि "भूलने की बीमारी" ठीक हो गई है।

⚠️ एक छोटा सा रिमाइंडर: वास्तविक प्रोजेक्ट्स में, /init अधिक फ़ाइलों को स्कैन करता है और बहुत अधिक सामग्री जनरेट करता है, इसलिए यह इस डेमो की तुलना में थोड़ा धीमा चलेगा, बस इसके स्कैन पूरा होने की धैर्यपूर्वक प्रतीक्षा करें; इसके स्कैन पूरा होने के बाद, अनुभाग 05 में उल्लिखित बात को न भूलें — इसे एक बार पूरा पढ़ें, और उन कड़े प्रतिबंधों को जोड़ें जिन्हें यह स्कैन नहीं कर सकता।

💡 एक वाक्य में सारांश: दो-फ़ाइलों वाला एक न्यूनतम प्रोजेक्ट बनाएं, claude में /init टाइप करें, बाहर निकलने के बाद cat CLAUDE.md का उपयोग करें, और अपनी आँखों से देखें कि यह प्रोजेक्ट को समझता है — फिर सत्यापित करने के लिए टेस्ट कमांड के बारे में पूछें कि "भूलने की बीमारी" ठीक हो गई है।

---

07 सारांश

इस लेख में केवल एक क्रिया को विस्तार से समझाया गया है: किसी नए प्रोजेक्ट में प्रवेश करने के बाद सबसे पहला काम, /init टाइप करें, और Claude को खुद प्रोजेक्ट मैनुअल का पहला ड्राफ्ट लिखने दें।

आइए मुख्य बिंदुओं को एक साथ जोड़ें:

आयाम	निष्कर्ष
यह क्या हल करता है	Claude हर सेशन में "भूल" जाता है, CLAUDE.md क्रॉस-सेशन मेमोरी कैरियर है
/init क्या है	वह कमांड जो Claude को प्रोजेक्ट को स्कैन करने और स्वचालित रूप से CLAUDE.md ड्राफ्ट जनरेट करने देता है
इसे कैसे चलाएं	प्रोजेक्ट की रूट डायरेक्टरी में cd करें → claude शुरू करें → /init टाइप करें
यह क्या करता है	संरचना को स्कैन करता है, टेक स्टैक की पहचान करता है, कमांड निकालता है, और उन्हें एक ड्राफ्ट के रूप में डिस्क पर सेव करता है
यह कैसा दिखता है	अवलोकन / टेक स्टैक / डायरेक्टरी / कमांड्स / कन्वेंशन्स जैसे खंडों में विभाजित है
महत्वपूर्ण समझ	ड्राफ्ट अंतिम ड्राफ्ट नहीं है — टीम कन्वेंशन्स को मैन्युअल रूप से जोड़ा जाना चाहिए

अब आपको यह करने में सक्षम होना चाहिए: किसी भी प्रोजेक्ट में प्रवेश करें, रूट डायरेक्टरी में claude शुरू करने के बाद /init टाइप करें, इसे स्वचालित रूप से एक CLAUDE.md जनरेट करने दें, जनरेट की गई सामग्री में प्रत्येक ब्लॉक को समझें, और यह समझें कि यह केवल एक शुरुआत है — यह वस्तुनिष्ठ तथ्यों को आपके लिए आधार के रूप में सेट करता है, लेकिन सब्जेक्टिव कन्वेंशन्स आपको खुद जोड़ने होंगे। अब से, Claude "हर दिन एक भूलने वाला नया व्यक्ति" नहीं होगा, बल्कि एक अनुभवी व्यक्ति होगा जिसने शुरुआत से ही आपका प्रोजेक्ट मैनुअल पढ़ लिया है।

---

अगला लेख 13 "प्रोजेक्ट संरचना" — /init चलाने के बाद, CLAUDE.md में वह "डायरेक्टरी संरचना" Claude द्वारा स्कैन की गई थी। लेकिन एक प्रोजेक्ट में CLAUDE.md के अलावा, .claude/ डायरेक्टरी, settings.json, कस्टम कमांड्स, MCP कॉन्फ़िगरेशन आदि जैसी "Claude Code एक्सक्लूसिव फ़ाइलों" का एक समूह भी होता है, और प्रत्येक की अपनी भूमिका होती है। वे कहाँ रखे जाते हैं और वे कैसे दिखते हैं? अगला लेख इस प्रोजेक्ट संरचना को एक बार में समझने में आपकी मदद करेगा।

---

अनुशंसित पठन

• Agent teams एजेंट टीम: मल्टी-सेशन कोलैबोरेशन
• बेस्ट प्रैक्टिसेज़: बिखरी हुई अच्छी आदतों को एक ऐसे सेट में बदलना जिसका पालन किया जा सके
• डेवलपमेंट कॉन्फ़िगरेशन: Claude के काम करने वाले "कार्य वातावरण" को सुचारू बनाना