अपने AI कोडिंग एजेंट के कॉन्टेक्स्ट विंडो को भरने से कैसे बचाएँ

हर AI कोडिंग एजेंट एक कॉन्टेक्स्ट विंडो के भीतर काम करता है — पाठ की वह सीमित मात्रा जिसे वह एक बार में "देख" सकता है: आपके संदेश, उसके जवाब, वे फ़ाइलें जो वह पढ़ता है, वह कमांड आउटपुट जो वह चलाता है। जब वह विंडो भर जाती है, तो गुणवत्ता ऐसे तरीक़ों से गिरती है जो रहस्यमय लगते हैं। एजेंट बीस मिनट पहले लिए गए किसी निर्णय को भूल जाता है, ऐसी फ़ाइल को दोबारा पढ़ता है जिसे वह पहले ही संपादित कर चुका है, या चुपचाप ख़ुद का विरोधाभास कर बैठता है। कुछ मिनट से लंबे किसी भी काम में, कॉन्टेक्स्ट को संभालना आउटपुट की गुणवत्ता पर आपके पास मौजूद सबसे बड़ा एकल लीवर है। यहाँ बताया गया है कि इसे सोच-समझकर कैसे करें।

भरी हुई विंडो नुक़सान क्यों पहुँचाती है

जब विंडो में भीड़ हो जाती है तो मॉडल सहजता से क्षमता नहीं खोते। दो चीज़ें होती हैं। पहली, पुराने संदेश किनारों की ओर धकेल दिए जाते हैं, जहाँ मॉडल उन पर कम विश्वसनीय रूप से ध्यान देता है — यह पुरानी "बीच में खो जाना" (lost in the middle) समस्या है। दूसरी, ज़्यादातर एजेंट जगह कम पड़ने पर अपने-आप सारांश बना लेते हैं, और दबाव में बनाया गया स्वचालित सारांश हानिकारक होता है: उसमें वह ठीक-ठीक बाधा (constraint) छूट सकती है जिसकी आपको परवाह थी। इसका समाधान यह है कि एजेंट क्या पकड़े हुए है, इस पर आप नियंत्रण में रहें, बजाय इसके कि उसे भरने दें और वह सुधार-सुधार कर काम चलाता रहे।

नज़र रखें कि विंडो कितनी भरी है

जो आप देख नहीं सकते, उसे आप संभाल नहीं सकते। Claude Code में, वर्तमान उपयोग को प्रतिशत के रूप में प्रिंट करने के लिए /context चलाएँ। अभ्यासकर्ताओं का एक अच्छा दिशानिर्देश यह है कि किसी जटिल काम पर लगभग 60% उपयोग पर कार्रवाई करें — उस ~80% के निशान से काफ़ी पहले, जहाँ स्वचालित कॉम्पैक्शन शुरू हो जाता है। Cursor और Codex अपने UI में एक ऐसा ही संकेतक दिखाते हैं। उस संख्या पर बीच-बीच में एक नज़र डालना कॉन्टेक्स्ट प्रबंधन को एक अस्पष्ट चिंता से एक ठोस संकेत में बदल देता है।

चेकपॉइंट्स पर कॉम्पैक्ट करें — यूँ ही चलते न रहें

जब आप किसी स्वाभाविक चेकपॉइंट पर पहुँचें (कोई फ़ीचर काम करता है, टेस्ट पास होते हैं, कोई बग ठीक हो जाता है), तो इतिहास को बढ़ने देने के बजाय उसे संपीड़ित करें। Claude Code में, /compact पूरे ट्रांसक्रिप्ट को मॉडल-जनित सारांश से बदल देता है — 70,000-टोकन की बातचीत लगभग 4,000 टोकन तक गिर सकती है। महत्वपूर्ण बात यह है कि आप यह तय कर सकते हैं कि क्या बचा रहे:

/compact "Keep the API contract and the DB schema we agreed on. Summarize the debugging session — I only need the root cause, not every step."

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

जब आप काम बदलें, तब क्लियर करें

/compact काम के उसी सिलसिले को जारी रखने के लिए है। /clear उसे छोड़ देने के लिए है। जब आप किसी असंबंधित चीज़ की ओर मुड़ें — आप एक बैकएंड फ़िक्स पूरा करते हैं और किसी फ़्रंटएंड फ़ीचर की ओर बढ़ते हैं — तो नए सिरे से शुरुआत करें। पुराने कॉन्टेक्स्ट को आगे ले जाना मदद नहीं करता; यह बस टोकन बर्बाद करता है और यह जोखिम पैदा करता है कि एजेंट पिछले काम के पैटर्न से मेल बैठाने लगे। जब कॉन्टेक्स्ट "दूषित" हो जाए तब भी क्लियर करना ही इलाज है: मॉडल किसी ग़लत मान्यता को पकड़ लेता है और आप कितना भी सुधारें, वह बार-बार उसी पर लौट आता है।

स्थिर जानकारी को चैट में नहीं, किसी फ़ाइल में रखें

अगर आप ख़ुद को एक ही चीज़ें बार-बार समझाते हुए पाएँ — आपका टेस्ट कमांड, आपके नामकरण के नियम, API किस डायरेक्टरी में रहता है — तो वह जानकारी बातचीत में होनी ही नहीं चाहिए। इसे किसी ऐसी प्रोजेक्ट फ़ाइल में रखें जिसे एजेंट अपने-आप पढ़ता है: Claude Code के लिए CLAUDE.md, Codex और अन्य के लिए AGENTS.md, Cursor के लिए .cursorrules। यह हर सत्र की शुरुआत में लोड होती है, इसलिए एजेंट के पास यह पहले संदेश से ही होती है, और यह हर /clear और /compact के बाद भी बची रहती है। हालाँकि इसे दुबला रखें — यह हर एक अनुरोध पर टोकन ख़र्च करती है, इसलिए एक फूली हुई CLAUDE.md अपने-आप में कॉन्टेक्स्ट की बर्बादी का एक रूप है।

एजेंट को ज़्यादा नहीं, कम दें

दस फ़ाइलें ठूँस देने की प्रवृत्ति — "ताकि इसके पास सब कुछ हो" — उल्टी पड़ती है। हर फ़ाइल जिसे आप पेस्ट या @-मेंशन करते हैं, बजट खा जाती है और मॉडल के ध्यान को पतला कर देती है। एक सही ढंग से चुनी गई फ़ाइल अक्सर दस से बेहतर होती है। न्यूनतम से शुरू करें और कॉन्टेक्स्ट तभी जोड़ें जब एजेंट को वास्तव में उसकी ज़रूरत हो। अगर आप निश्चित न हों कि कौन-सी फ़ाइल मायने रखती है, तो पूरी डायरेक्टरी को पहले से लोड करने के बजाय एजेंट से उसे पहले ढूँढने को कहें।

बिखरी हुई खोजबीन को किसी सबएजेंट को सौंपें

कुछ काम स्वाभाविक रूप से वाचाल होते हैं — "कोडबेस में हर उस जगह को खोजो जहाँ हम पेमेंट्स API को कॉल करते हैं।" अगर आप इसे अपने मुख्य सत्र में चलाते हैं, तो खोज का कच्चा आउटपुट आपकी विंडो में बाढ़ ले आता है। इसके बजाय, इसे किसी सबएजेंट को सौंप दें (Claude Code का Task टूल, या एक अलग Cursor एजेंट)। सबएजेंट यह शोरगुल वाली खोजबीन अपनी ख़ुद की अलग विंडो में करता है और वापस सिर्फ़ निष्कर्ष सौंपता है — वे तीन फ़ाइलें जो मायने रखती हैं — जिससे आपका मुख्य कॉन्टेक्स्ट साफ़ बना रहता है।

एक कारगर लय

सब मिलाकर, एक स्वस्थ लंबा सत्र ऐसा दिखता है:

1. एक संक्षिप्त CLAUDE.md से शुरुआत करें ताकि एजेंट को आपके प्रोजेक्ट की जानकारी हो।
2. हर काम का दायरा संकीर्ण रखें; केवल उन्हीं फ़ाइलों का संदर्भ दें जिन्हें वह छूता है।
3. हर 30–45 मिनट पर या हर मील के पत्थर के बाद /context पर एक नज़र डालें।
4. हर चेकपॉइंट पर एक कस्टम निर्देश के साथ /compact करें।
5. जिस क्षण आप असंबंधित काम पर स्विच करें, उसी क्षण /clear करें।

इसमें से कुछ भी असाधारण नहीं है। यही एक ऐसे एजेंट के बीच का फ़र्क़ है जो दो घंटे के सत्र में तेज़ बना रहता है और एक ऐसे के बीच जो शुरुआत में मज़बूत रहता है और धीरे-धीरे कहानी का सिरा खो देता है — और इसमें आपका कुछ सेकंड का ध्यान लगता है, न कि इसकी उलझन को डिबग करने में बीती एक रहस्यमय दोपहर।