Claude Code टर्मिनल: पावर यूज़र्स के लिए 7 वर्कफ़्लो अपग्रेड्स

वेनिला Claude Code बॉक्स से बाहर ही उपयोगी है। आप इसे इंस्टॉल करते हैं, प्रॉम्प्ट देते हैं, और यह आपके कहने पर कुछ भी बना देता है। यही ज़्यादातर लोगों की वाइब-कोडिंग सेटअप है—और यह काम करता है।

जिस व्यक्ति के टर्मिनल को कस्टमाइज़ किया गया है, उसके लिए Claude Code एक अलग टूल बन जाता है। उन्होंने भरोसेमंद bash कमांड्स को पहले से अप्रूव कर रखा होता है, इसलिए Claude लगभग कभी परमिशन नहीं माँगता। एक CLAUDE.md उनकी प्रोजेक्ट रूट में रहता है, ताकि सेशन खुलते ही Claude को उनकी परंपराएँ पता हों। और जब किसी सेशन में उलझन महसूस होने लगे, तो वे रिस्टार्ट नहीं दबाते।

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

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

1. बार-बार वही कमांड्स फिर से अप्रूव करना बंद करें

डिफ़ॉल्ट रूप से, हर नए टूल इनवोकेशन में आपकी मंज़ूरी माँगी जाती है। पहली बार pytest चलाते समय ठीक लगता है। तीसरी बार खीजने लगता है। दसवीं बार तक पहुँचते-पहुँचते आप बिना पढ़े ही Enter दबा रहे होते हैं। यह सबसे बुरा संतुलन है: आपने सुरक्षा जाँच को नज़रअंदाज़ करना सीख लिया है, और फिर भी यह आपको धीमा कर रही है।

बेशक, एक "खतरनाक तरीके से परमिशन बायपास" मोड या "ऑटो मोड" भी है। इनके ट्रेड-ऑफ़्स हमने Claude Code Auto Mode और Channels पर मेरे ट्यूटोरियल में विस्तार से कवर किए हैं।

settings.json फ़ाइल में permissions परिभाषित करना

हल है प्रोजेक्ट रूट में एक .claude/settings.json फ़ाइल, जिसमें एक permissions ब्लॉक हो जो भरोसेमंद पैटर्न्स को पहले से अप्रूव करे और संदिग्धों को ब्लॉक करे:

{
  "permissions": {
	"allow": [
  	"Bash(pytest *)",
  	"Bash(uv run *)",
  	"Bash(ruff check *)",
  	"Read(~/.zshrc)"
	],
	"deny": [
  	"Bash(curl *)",
  	"Read(./.env)",
  	"Read(./.env.*)",
  	"Read(./secrets/**)"
	]
  }
}

रूल्स एक तय क्रम में मूल्यांकित होते हैं: पहले deny, फिर ask, फिर allow। पहला मैच जीतता है, इसलिए कोई भी deny रूल बाद के allow पर भारी पड़ता है।

स्कोप और वाइल्डकार्ड्स में महारत

पहली बार लिखते समय तीन बातें अक्सर लोगों को उलझाती हैं।

1. पहली है स्कोप। किसी प्रोजेक्ट का .claude/settings.json आपकी ग्लोबल ~/.claude/settings.json सेटिंग्स को ओवरराइड करता है, तो यदि आपने ग्लोबली Bash(rm *) अलाउ कर रखा है और कोई प्रोजेक्ट इसे डिनाय करता है, तो प्रोजेक्ट जीतेगा। यह सही डिफ़ॉल्ट है, पर अक्सर उन लोगों को चौंका देता है जो ग्लोबल अलाउ को "चिपकू" मानते हैं।

2. दूसरी है नेटवर्क कमांड्स पर वाइल्डकार्ड। Bash(curl http://github.com/ *) सीमित दिखता है, लेकिन यह https://, URL से पहले के विकल्प, रिडायरेक्ट्स, या शेल वैरिएबल एक्सपैंशन को नहीं पकड़ता। डॉक्यूमेंटेशन जिस पैटर्न की सलाह देता है, वह है सीधे Bash(curl *) को डिनाय कर देना। फिर जिन डोमेन्स को आप सच में अलाउ करना चाहते हैं, उनके लिए WebFetch(domain:github.com) के साथ WebFetch टूल का प्रयोग करें।

3. तीसरी है व्हाइटस्पेस। Bash(ls *) ls -la से मैच करता है, पर lsof से नहीं। Bash(ls*) दोनों से मैच करता है। एस्टरिस्क से पहले की स्पेस असल काम कर रही होती है—इसलिए आपने कौन-सा लिखा है, इस पर जानबूझकर ध्यान दें।

कुछ कीबाइंडिंग्स भी permissions के साथ उसी "टर्मिनल से लड़ना बंद करें" श्रेणी में आती हैं, और पहले दिन सीखने लायक हैं:

• Shift+Tab से परमिशन मोड्स (डिफ़ॉल्ट, ऑटो-एक्सेप्ट, प्लान) बदलें

• Esc+Esc रीवाइंड पिकर खोलता है (इस पर #3 में और)

• Ctrl+R आपके प्रॉम्प्ट इतिहास में रिवर्स-सर्च करता है, ठीक bash और zsh की तरह

• Ctrl+U कर्सर से लाइन की शुरुआत तक डिलीट करता है

• Shift+Enter प्रॉम्प्ट के अंदर नई लाइन जोड़ता है

इनमें से ज़्यादातर कीबाइंडिंग्स टर्मिनल में बॉक्स से बाहर काम करती हैं। अगर नहीं करतीं, तो /terminal-setup स्लैश कमांड एक बार चलाएँ ताकि सब इंस्टॉल हो जाए।

2. Claude Code को आपका प्रोजेक्ट याद रखने दें

हर सेशन एक नए कॉन्टेक्स्ट विंडो से शुरू होता है।

डिफ़ॉल्ट रूप से, Claude को याद नहीं रहता कि आप uv की जगह pip इस्तेमाल करते हैं। उसे यह भी याद नहीं कि आपके टेस्ट tests/ में रहते हैं, test/ में नहीं। और कल जिन API परंपराओं को आपने दस टर्न तक समझाया था, वे भी गायब हो जाती हैं। इसका समाधान है प्रोजेक्ट रूट पर एक CLAUDE.md फ़ाइल। उसी डायरेक्टरी (या किसी सबडायरेक्टरी) से Claude Code लॉन्च करें, और यह आपकी पहली प्रॉम्प्ट से पहले ही फ़ाइल को कॉन्टेक्स्ट में लोड कर लेता है।

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

Claude तीन जगहों पर कॉन्टेक्स्ट ढूँढता है, एक-दूसरे के ऊपर स्टैक्ड:

Project CLAUDE.md at ./CLAUDE.md रेपो के साथ शिप होता है। यह हर योगदानकर्ता के लिए समान होता है, इसलिए यहाँ प्रोजेक्ट-विशिष्ट तथ्य रखें:

• पैकेज मैनेजर और भाषा का संस्करण
• टेस्ट कमांड और टेस्ट कहाँ रहते हैं
• डायरेक्टरी लेआउट और कोई भी गैर-स्पष्ट परंपराएँ
• वह सब कुछ जिसकी ज़रूरत नए टीममेट को पहले दिन पड़ेगी

User CLAUDE.md at ~/.claude/CLAUDE.md आपकी मशीन के हर प्रोजेक्ट में साथ चलता है। यहाँ व्यक्तिगत पसंदें डालें: आपका कोडिंग स्टाइल, आप डॉकस्ट्रिंग्स कैसे पसंद करते हैं, आप किन भाषाओं को पहले चुनते हैं। यहाँ प्रोजेक्ट के तथ्य न रखें, वरना वे हर रेपो में फैल जाएँगे।

ऑटो-मेमोरी तीसरी परत है, और इसे Claude खुद लिखता है। जब आप सेशन के दौरान इसे सुधारते हैं ("हम यहाँ snake_case इस्तेमाल करते हैं, camelCase नहीं"), तो यह सुधार को ~/.claude/projects/<project>/memory/MEMORY.md में लॉग कर देता है। उस फ़ाइल की पहली 200 पंक्तियाँ या 25KB हर बातचीत की शुरुआत में उसी प्रोजेक्ट में लोड होती हैं। आप /memory से देख सकते हैं कि क्या लोड हुआ, और यहीं से ऑटो-मेमोरी ऑन/ऑफ़ भी कर सकते हैं।

एक आकार निर्धारण नियम: हर CLAUDE.md को 200 पंक्तियों के अंदर रखें। इसके आगे, फ़ाइल हर टर्न पर ध्यान देने लायक कॉन्टेक्स्ट खा जाती है, और Claude लंबी फ़ाइलों को छोटी की तुलना में कम विश्वसनीयता से फॉलो करता है। अगर आपकी फ़ाइल बढ़ रही है, तो उसे पाथ स्कोप्स के साथ .claude/rules/ में बाँट दें। CLAUDE.md में वास्तव में क्या होना चाहिए, इस पर गहराई से चर्चा के लिए मेरा writing the best CLAUDE.md ट्यूटोरियल देखें।

3. सेशन बिगड़ें तो बार-बार रिस्टार्ट करना छोड़ें

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

पहली चीज़ संकेत पहचानना है। इस तरह के कॉन्टेक्स्ट रॉट के कुछ साफ़ संकेत हैं:

• Claude किसी फ़ाइल पाथ को फिर से पूछे जिसे वह पाँच टर्न पहले एडिट कर चुका है
• वह वही सुझाव दोहराए जिसे आपने पहले ही ठुकरा दिया
• वह किस ब्रांच पर हैं, इसका ट्रैक खो दे
• एक ही बिंदु पर आपने एक सेशन में उसे दो बार से ज़्यादा सुधारा हो

इनमें से कुछ दिखते ही आपके पास चार विकल्प हैं—और वे एक-दूसरे के बदले नहीं चलते:

अपने सेशन को कॉम्पैक्ट करना

 /compact उतना बुरा नहीं है जितना कुछ यूज़र्स कहते हैं।

आपका प्रोजेक्ट CLAUDE.md इसकी मार से बचा रहता है। कॉम्पैक्शन के बाद Claude फ़ाइल को डिस्क से फिर पढ़ता है और फिर से इंजेक्ट करता है, इसलिए आपकी परंपराएँ नहीं खोतीं। आप समरी को निर्देश दे सकते हैं, जैसे /compact keep the auth refactor decisions, drop the failed test runs। यही एक उपयोगी समरी और एक जनरल समरी में फ़र्क कर देता है।

Claude Code के “undo” विकल्प का उपयोग

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

"Restore code and conversation" अधिकतर लोगों की ज़रूरत होती है। आधे घंटे के गलत टर्न बिना git खोले गायब हो सकते हैं। पूरे सेशन के लिए यह Claude Code का सबसे नज़दीकी undo है।

एक बार जब आप रिस्टार्ट करना छोड़ देते हैं, अगली समस्या फिर से सेशन्स ढूँढने की होती है।

सेशन्स का नामकरण और फिर से खोलना

claude -n <name> (या --name) एक नामित सेशन शुरू करता है, और नाम /resume और टर्मिनल टाइटल में दिखता है। जब एक ही रेपो में आपके तीन काम चल रहे हैं (एक एक्सपेरिमेंट ब्रांच, एक रिफ़ैक्टर, एक डिबग पास), तो नाम ही उन्हें अलग-अलग बताते हैं। /rename से आप बीच सेशन में भी नाम बदल सकते हैं, अगर स्कोप बदल जाए।

प्रो टिप: एक ही टर्मिनल विंडो में कई सेशन चलाते समय उन्हें और अलग दिखाने के लिए /color का उपयोग करें।

किसी सेशन को फिर खोलना दो फ़्लैग्स से होता है। claude --continue (या -c) मौजूदा डायरेक्टरी में सबसे हाल की बातचीत लोड करता है। तब उपयोग करें जब आप यहीं थे और यहीं से आगे बढ़ना है।

claude --resume एक इंटरऐक्टिव पिकर खोलता है, और claude --resume <name-or-id> किसी खास सेशन पर सीधे ले जाता है। सेशन्स को git ब्रांच की तरह ट्रीट करें: अलग काम-धाराओं को अपना-अपना सेशन मिलना चाहिए।

4. कठिन काम की योजना बनाएँ, आसान पर किफ़ायत बरतें

कस्टमाइज़्ड सेटअप की सबसे बड़ी लागत एडिटर या कीबाइंडिंग्स नहीं हैं। असली बात है सामने के टास्क की कठिनाई के अनुरूप कम्प्यूट खर्च को मैच करना। इस पर तीन टूल साथ मिलकर काम करते हैं: plan mode, /effort, और /model।

Claude Code plan mode का उपयोग

प्लान मोड Claude को फ़ाइलों को छूने से पहले अप्रोच पर सोचने के लिए कहता है। यह प्लान लिखता है, आप पढ़ते हैं, आप इसे अप्रूव करते हैं या आपत्ति उठाते हैं, और तभी यह निष्पादन करता है।

मेरे प्लान ठोस बनाने की एक तरकीब है यह साधारण प्रॉम्प्ट जिसे मैं अक्सर इस्तेमाल करता हूँ:

Red-team this plan from multiple angles using as many Opus 4.7 agents as you need.

यह कई सबएजेंट्स लॉन्च करेगा जो अलग-अलग पहलुओं से प्लान की समीक्षा करेंगे और सुधार सुझाएँगे। 500 से अधिक लाइनों वाले प्लान फ़ाइल के साथ काम करते समय यह एक अच्छा अभ्यास है।

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

प्लान मोड में जाने के पाँच तरीके हैं:

इनलाइन रूप (/plan refactor the auth module to use JWT) को ज़्यादातर लोग मिस कर देते हैं। यह एक ही कीस्ट्रोक में मोड और टास्क सेट कर देता है, दो की जगह। रिव्यू-फर्स्ट प्लान वर्कफ़्लोज़ की स्टेप-बाय-स्टेप वॉकथ्रू के लिए मेरा Claude Code plan mode ट्यूटोरियल विस्तार से समझाता है।

उचित effort स्तर सेट करना

अगली चीज़ है Effort। यह तय करता है कि हर टर्न पर Claude कितना विस्तृत सोचता है। ज़्यादा effort का मतलब गहरी तर्क-प्रक्रिया, ज़्यादा टोकन, और धीमी प्रतिक्रिया।

/effort <level> और --effort <level> CLI फ़्लैग दोनों पाँचों मान स्वीकार करते हैं। Low, medium, high, और xhigh सेशन्स के पार भी बने रहते हैं। Max सिर्फ सेशन-ओनली है क्योंकि यह टोकन-खर्च सीमा हटा देता है, इसलिए इसे हर बार जानबूझकर सेट करें। रोज़मर्रा के काम के लिए सही डिफ़ॉल्ट low या medium है। high या xhigh को सचमुच कठिन समस्याओं के लिए रखें, और max तब जब आप गलत होने से बेहतर टोकन जलाना चाहें।

एक प्रतिवाद ध्यान में रखें: बढ़िया कॉन्टेक्स्ट के साथ low पर चल रहा मॉडल, अक्सर खराब कॉन्टेक्स्ट पर max से बेहतर होता है। अपना प्रॉम्प्ट साफ़ करना, effort बढ़ाने से ज़्यादा बड़ा फ़ायदा देता है।

सही मॉडल चुनना

मॉडल चयन वहीं है जहाँ सच में क़ीमत बचती है। /model से आप बीच सेशन में स्विच कर सकते हैं, और Option+P (macOS) / Alt+P (Win/Linux) आपके टाइप किए हुए टेक्स्ट को क्लीयर किए बिना मॉडल बदल देता है। याद रखने लायक एलियास:

• sonnet रोज़मर्रा का डिफ़ॉल्ट ड्राइवर है

• opus सबसे कठिन समस्याओं के लिए है (एलियास best भी opus पर ही रिज़ॉल्व होता है)

• haiku तब जब आपको स्पीड चाहिए

• sonnet[1m] और opus[1m] 1M-कॉन्टेक्स्ट वेरिएंट्स हैं

• opusplan प्लान मोड में Opus और निष्पादन में Sonnet चलाता है

• default किसी भी ओवरराइड को साफ़ कर रिकमेंडेड मॉडल पर लौटा देता है

अगर आप हर चीज़ के लिए Opus डिफ़ॉल्ट कर रहे हैं, तो अपने दिन के अधिकांश हिस्से के लिए Sonnet पर स्विच करना आपके लिए उपलब्ध सबसे बड़ा खर्च कट है। 

Opus तब सही है जब आप किसी कठिन समस्या में अटक गए हों और उस पर सबसे स्मार्ट मॉडल चाहिए। बाकी लगभग सब कुछ Sonnet संभाल लेता है। दोनों के बीच लागत का फ़ासला इतना बड़ा है कि "सेफ़ रहने के लिए मैं Opus ही ले लूँ"—यह ऑटोपायलट पर छोड़ी जा सकने वाली सबसे महंगी आदत है।

5. जो काम आप हाथ से करते हैं, उन्हें ऑटोमेट करें

जब घर्षण के स्रोत हट जाते हैं, अगली परत है वह काम जो आप अब भी हाथ से करते हैं।

अनुसूचित टास्क

इसे समझना कि कैसे न करें, उससे आसान है। दो फ़ीचर्स ज़्यादातर काम कवर करते हैं: /loop उन रिक्ररिंग जाँचों के लिए जिन्हें वरना आप चौकसी से देखते, और hooks उन गारंटियों के लिए जो CLAUDE.md निर्देश से नहीं मिलतीं।

/loop किसी प्रॉम्प्ट या स्लैश कमांड को दोहराते शेड्यूल पर फिर से चलाता है। सिन्टैक्स दो रूपों में है:

• /loop 5m <prompt> हर 5 मिनट पर प्रॉम्प्ट चलाता है

• /loop <prompt> अकेले चलाने पर कैडेंस मॉडल के हवाले हो जाती है, जो तय करता है फिर कब चलना है

इंटरवल इकाइयाँ हैं s, m, h, और d, न्यूनतम एक मिनट। आपको Claude Code v2.1.72 या बाद का चाहिए।

उदाहरण के लिए, आप एक टेस्ट वॉचर सेट कर सकते हैं: /loop 2m run the test suite and report failures। हर बदलाव के बाद टेस्ट चलाना याद रखने (और आधा समय भूल जाने) के बजाय, Claude अगली 2-मिनट टिक पर टूटे हुए टेस्ट पकड़ लेता है।

इसी पैटर्न से स्टेजिंग डिप्लॉय पोल (/loop 10m check if the staging deploy is green) या किसी फ़्लेकी इंसीडेंट के दौरान लॉग टेल (/loop 1m tail the last 50 lines of app.log and flag errors) भी हो सकता है।

लूप्स 7 दिनों तक जीवित रहते हैं।

सातवें दिन टास्क आख़िरी बार चलता है और खुद को डिलीट कर देता है। वे सेशन-स्कोप्ड हैं, इसलिए --continue या --resume से बंद करके फिर खोलने पर वे वापस आ जाते हैं। किसी लूप को जल्दी रोकने के लिए Esc दबाएँ। अगर आपको ऐसा शेड्यूल चाहिए जो सेशन बंद होने पर भी बचा रहे (रात का चेक, साप्ताहिक डाइजेस्ट), तो /schedule के ज़रिये Routines का उपयोग करें।

Hooks

Hooks दूसरी आधी तस्वीर हैं। ये Claude के वर्कफ़्लो के खास बिंदुओं पर शेल कमांड चलाते हैं, जिन्हें .claude/settings.json में कॉन्फ़िगर किया जाता है। 

CLAUDE.md निर्देश की बजाय hook चुनने का कारण एक है: CLAUDE.md सलाह देता है, जबकि hooks गारंटी के साथ चलते हैं। क्लासिक केस है "एडिट के बाद हमेशा लिंटर चलाओ" नियम, जिसे Claude आधा समय छोड़ देता है। एक hook उस गैप को बंद कर देता है।

छह इवेंट्स ज़्यादातर केसेस कवर कर लेते हैं:

एक न्यूनतम PostToolUse hook जो हर फ़ाइल एडिट के बाद लिंट करता है:

{
  "hooks": {
	"PostToolUse": [
  	{
    	"matcher": "Edit|Write",
    	"hooks": [
      	{ "type": "command", "command": "/path/to/lint-check.sh" }
    	]
  	}
	]
  }
}

एक ज़रूरी बात याद रखें: केवल एग्ज़िट कोड 2 ही वास्तव में Claude को ब्लॉक करता है। एग्ज़िट 1 को नॉन-ब्लॉकिंग त्रुटि माना जाता है, और Claude फिर भी आगे बढ़ता है—हालाँकि 1 सामान्य Unix फ़ेल्योर कोड है। अगर आपका hook किसी नियम को लागू करवाने के लिए है, तो 2 लौटाएँ।

आपको hooks हाथ से लिखने की भी ज़रूरत नहीं।

Claude को प्रॉम्प्ट दें "हर फ़ाइल एडिट के बाद ruff चलाने वाला hook लिखो" और यह आपके लिए JSON ड्राफ़्ट कर देगा। /hooks हर ऐक्टिव hook कॉन्फ़िगरेशन की सूची दिखाता है, ताकि किसी अप्रत्याशित फायर होने पर आपको सेटिंग फ़ाइलों में grep न करना पड़े। पूरे इवेंट कैटलॉग और stdin/stdout JSON स्कीमाज़ के लिए मेरा Claude Code hooks ट्यूटोरियल देखें।

6. इन सबकी क़ीमत पर नज़र रखें

लूप्स, लंबे सेशन्स, और डिफ़ॉल्ट रूप से Opus—ये सब टोकन जलाते हैं। तीन कमांड्स खर्च को इतना दृश्य बना देते हैं कि आप इसे मैनेज कर सकें, और आदत होनी चाहिए इन्हें सरसरी नज़र से देख लेने की, न कि इन्हें जटिलता से कॉन्फ़िगर करने की।

/usage आपका प्लान टियर, सेशन टोटल्स, प्रति-मॉडल कॉस्ट ब्रेकडाउन, और 5-घंटे व साप्ताहिक रेट-लिमिट विंडो के प्रोग्रेस बार दिखाता है।

/context मौजूदा कॉन्टेक्स्ट विंडो को रंगीन ग्रिड के रूप में दिखाता है, क्षमता चेतावनियों और किन टूल्स या फ़ाइलों से जगह भर रही है इस पर सुझावों के साथ। इसका उपयोग तब करें जब सेशन भारी सा लगे और आप /compact और /clear के बीच निर्णय ले रहे हों।

/statusline आपके टर्मिनल के नीचे एक स्थायी बार कॉन्फ़िगर करता है। इसमें मॉडल, कॉन्टेक्स्ट प्रतिशत, रेट-लिमिट विंडो, और वो सब कुछ दिख सकता है जो आप सेशन JSON से पढ़ सकते हैं। यह सबसे ज़्यादा व्यवहार बदलता है, क्योंकि यह काम करते समय क़ीमत से जुड़े नंबरों को आपकी परिधीय नज़र में रखता है।

आप /statusline चलाकर सादा भाषा में बता सकते हैं कि क्या दिखाना है, और Claude आपके लिए स्क्रिप्ट जनरेट करके सेटिंग्स अपडेट कर देगा। दूसरा विकल्प है कि आप खुद एक शेल स्क्रिप्ट लिखें और उसे ~/.claude/settings.json से पॉइंट करें:

{
  "statusLine": {
	"type": "command",
	"command": "~/.claude/statusline.sh"
  }
}

लंबी अवधि के क्रॉस-सेशन ट्रैकिंग के लिए, npx ccusage एक समुदाय टूल है जो समय के साथ टोकन बर्न को इकट्ठा करता है। यह थर्ड-पार्टी है, Anthropic-निर्मित नहीं, लेकिन सेशन-स्कोप्ड /usage और आपकी मंथली बिलिंग के बीच का गैप भर देता है।

7. तीन और चीज़ें जिनके बारे में जानना ज़रूरी है

ऊपर के छह अपग्रेड्स वे हैं जिनपर मैं रोज़ हाथ डालता हूँ। नीचे के तीन ऐसे असली फ़ीचर्स हैं जिनका मैं कम उपयोग करता हूँ, लेकिन जिनके बारे में आपको पता होना चाहिए—ताकि ज़रूरत पड़ते ही उन्हें निकाल सकें।

/voice के साथ पुश-टू-टॉक का उपयोग

/voice पुश-टू-टॉक डिक्टेशन चालू करता है। Space दबाए रखें, बोलें, छोड़ें—और ट्रांसक्राइब किया गया टेक्स्ट आपके प्रॉम्प्ट इनपुट में आ जाता है। आपको v2.1.69 या आगे का चाहिए, और बीस भाषाएँ समर्थित हैं।

आवाज़ तब टाइपिंग को मात देती है जब आप चलते-चलते सोच रहे हों या किसी टास्क की शुरुआत में इरादा डिक्टेट कर रहे हों, जहाँ शब्द अभी तय नहीं हुए हैं। लाइन-लेवल एडिट्स के लिए यह कमतर है, जहाँ "लाइन 47 को बदलकर..." टाइप करना आसान होता है।

/teleport से क्लाउड सेशन खींचना

/teleport (एलियास /tp) किसी क्लाउड सेशन को आपके लोकल टर्मिनल में खींच लाता है। मान लीजिए आपने वेब ऐप या iOS ऐप पर कोई लंबा काम शुरू किया था और अब आप लैपटॉप पर लौट आए हैं। claude --teleport चलाएँ, पिकर खुलेगा, और वह सेशन आपके टर्मिनल में सही ब्रांच चेकआउट के साथ आ जाएगा।

कुछ आवश्यकताएँ लाइन में होनी चाहिए:

• क्लीन git स्टेट
• सही रेपो
• वही claude.ai अकाउंट जिससे क्लाउड सेशन चला था
• ब्रांच रिमोट पर पुश की गई हो

--teleport को --resume से भ्रमित न करें। बाद वाला केवल इस मशीन के इतिहास से लोकल सेशन्स फिर खोलता है। विस्तार से वॉकथ्रू के लिए, हमारा Claude Code रिमोट कंट्रोल ट्यूटोरियल बाकी बातेँ कवर करता है।

/btw से साइड सवाल पूछना

/btw उस त्वरित सवाल के लिए है जिसे आप फ्लो तोड़े बिना पूछना चाहते हैं।

कल्पना करें Claude किसी टास्क के बीच में है। आपने कोई लंबा एडिट या टूल कॉल शुरू करा दिया है और अचानक आपको IPs मैच करने के लिए regex चाहिए या कौन-सा फ़्लैग X करता है यह जानना है। 

आप बस /btw <question>, टाइप करें और जवाब एक dismissible ओवरले में उभर आता है। चल रहा टास्क चलता रहता है, जवाब बातचीत इतिहास में दर्ज नहीं होता, इसलिए एकबारगी लुकअप के लिए नया सेशन स्पॉन करने की ज़रूरत नहीं और मौजूदा वाले को भी प्रदूषित नहीं करता।

निष्कर्ष

इस लेख की हर बात पर फिसलने का सबसे तेज़ तरीका है सब कुछ एक ही दिन में आज़माना। दो-तीन चीज़ें चुनें, उन पर मसल मेमोरी बनाएँ, और जब वे ऑटोमैटिक हो जाएँ तो बाकी जोड़ें।

शुरू करने के लिए तीन, दिन के अलग-अलग हिस्सों के लिए—ताकि वे एक-दूसरे को न दबाएँ:

• एक सटीक Project CLAUDE.md, साथ में

  हर सेशन में बार-बार अप्रूव किए जाने वाले bash कमांड्स के लिए

  .claude/settings.json में दो-तीन वाइल्डकार्ड परमिशन रूल्स। यह सुबह की सेटअप आदत है—और इसका असर तभी महसूस होता है जब बाधाएँ बंद हो जाती हैं।

• /compact बनाम /clear का फैसला, और Esc+Esc रीवाइंड पिकर। यह मिड-सेशन आदत है—और संकेत है वह पल जब Claude किसी फ़ाइल पाथ को फिर से पूछता है जो उसे एक घंटे पहले पता था।

• एक

  /loop किसी रिक्ररिंग चेक के लिए जो पहले ही आपका समय खाता है। यह बैकग्राउंड आदत है—और एक बार चलने पर, खुद-ब-खुद फ़ायदा देती रहती है।

यदि Sonnet, Opus, और Haiku के बीच का फ़र्क अभी भी धुंधला है, हमारा Introduction to Claude Models कोर्स बताता है कि कब कौन-सा मॉडल फ़िट बैठता है। इससे /effort और /model कॉल्स बहुत आसान हो जाती हैं।