अपने AI कोडिंग एजेंट को पटरी पर कैसे रखें: एक्सप्लोर करें, योजना बनाएँ, फिर बनाएँ

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

इसका इलाज कोई होशियार मॉडल नहीं है। यह एक वर्कफ़्लो है: पहले एक्सप्लोर करें, फिर योजना बनाएँ, फिर बनाएँ। यही वह पैटर्न है जिसकी Anthropic अपनी आधिकारिक Claude Code best-practices गाइड में सिफ़ारिश करता है, और यही विचार किसी भी ऐसे एजेंट पर लागू होता है जो एडिट करने से पहले आपकी repo पढ़ सके।

सीधे कोड पर कूदना क्यों विफल होता है

एक AI एजेंट एक सीमित कॉन्टेक्स्ट विंडो के भीतर काम करता है — आपकी बातचीत का चलता रिकॉर्ड और हर वह फ़ाइल जो वह पढ़ता है और हर वह कमांड जो वह चलाता है। जब आप योजना छोड़ते हैं तो दो चीज़ें गलत होती हैं:

1. एजेंट इरादे का अनुमान लगाता है। यह आपका मन नहीं पढ़ सकता, इसलिए एक अस्पष्ट प्रॉम्प्ट को एक प्रशंसनीय-लेकिन-गलत कार्यान्वयन मिलता है।
2. गलतियाँ चुपचाप जमा होती हैं। एक बार एजेंट एडिट करना शुरू कर देता है, तो चरण एक में की गई एक गलत धारणा आपके नोटिस करने से पहले दस और बदलावों के नीचे दब जाती है।

सोचने को करने से अलग करना गलत धारणा को तब पकड़ लेता है जब इसे ठीक करना अभी भी सस्ता है — एक 12-फ़ाइल revert के बजाय सुधार का एक वाक्य।

चरण 1: एक रीड-ओनली मोड में एक्सप्लोर करें

अधिकांश गंभीर एजेंटों के पास अब एक मोड है जहाँ वे पढ़ और विश्लेषण कर सकते हैं लेकिन कुछ भी बदल नहीं सकते। Claude Code में इसे plan mode कहते हैं: एक रीड-ओनली अवस्था जहाँ एजेंट फ़ाइलें पढ़ता है और सवालों के जवाब देता है, बिना एडिट किए, state बदलने वाली कमांड चलाए, या commit किए।

एजेंट से कोड समझने को कहकर शुरू करें, बदलने को नहीं:

Read /src/auth and explain how we handle sessions and login.
Also look at how we manage environment variables for secrets.

आप साझा कॉन्टेक्स्ट बना रहे हैं और पुष्टि कर रहे हैं कि एजेंट सचमुच आपके कोडबेस को समझता है, इससे पहले कि आप उसे संशोधित करने का भरोसा दें।

चरण 2: एक योजना माँगें, फिर उस पर दबाव डालें

एक बार एजेंट एक्सप्लोर कर ले, तो किसी भी कोड से पहले एक ठोस योजना माँगें:

I want to add Google OAuth login. What files need to change?
What's the session flow? Write a step-by-step plan — don't write code yet.

एजेंट एक क्रमांकित योजना लौटाता है: कौन-सी फ़ाइलें वह छुएगा, नया session flow, टोकन कहाँ स्टोर करेगा। अब पहले मसौदे को स्वीकार न करें। यह कोर्स-करेक्ट करने का सबसे सस्ता पल है। खामियों पर दबाव डालें:

• "अगर OAuth callback बीच में ही फेल हो जाए तो क्या होता है?"
• "हमारे पास पहले से src/auth/tokens.ts में एक refreshToken helper है — एक नया लिखने के बजाय उसका पुनः उपयोग करो।"
• "इसे सिर्फ़ login flow तक सीमित रखो। मौजूदा password reset कोड को मत छुओ।"

यहाँ योजना को परिष्कृत करने के कुछ मिनट बाद में किसी गलत कार्यान्वयन को सुलझाने के एक घंटे को बचाते हैं।

चरण 3: सत्यापन के एक तरीके के साथ बनाएँ

अभी ही आप एजेंट को कोड लिखने देते हैं — और आप उसे अपने काम की जाँच का एक तरीका देते हैं। किसी भी प्रॉम्प्ट में सबसे शक्तिशाली एकल जोड़ है एक सत्यापन चरण जो एजेंट खुद चला सके:

Implement the OAuth flow from your plan. Write a test for the callback
handler covering the failure case, run the test suite, and fix any failures.

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

चरण 4: जानें कि योजना कब छोड़नी है

योजना बनाने में ओवरहेड है, और यह हमेशा सार्थक नहीं होती। अगर बदलाव छोटा है और दायरा स्पष्ट है — कोई typo ठीक करना, एक log लाइन जोड़ना, एक variable rename करना — तो बस एजेंट से इसे सीधे करने को कहें। Anthropic गाइड से एक अच्छा नियम: अगर आप diff को एक वाक्य में बता सकते हैं, तो योजना छोड़ दें। explore-plan-build चक्र को उस काम के लिए सुरक्षित रखें जो कई फ़ाइलों में फैलता है, ऐसा दृष्टिकोण इस्तेमाल करता है जिसके बारे में आप अनिश्चित हैं, या ऐसा कोड छूता है जिसे आप अच्छे से नहीं जानते।

एक सुरक्षा-जाल: जल्दी कोर्स-करेक्ट करें और चेकपॉइंट्स का उपयोग करें

एक अच्छी योजना के साथ भी, एजेंट भटकते हैं। दो आदतें आपको नियंत्रण में रखती हैं:

• जिस पल यह पटरी से उतरे, बीच में रोकें। एजेंट के किसी गलत दृष्टिकोण को पूरा करने का इंतज़ार न करें। Claude Code में, Esc इसे बीच में रोक देता है, कॉन्टेक्स्ट संरक्षित रखते हुए ताकि आप पुनर्निर्देशित कर सकें।
• स्वतंत्र रूप से प्रयोग करने के लिए चेकपॉइंट्स का उपयोग करें। Claude Code हर बदलाव से पहले आपकी फ़ाइलों का स्नैपशॉट लेता है, इसलिए आप एजेंट से कुछ जोखिम भरा आज़माने को कह सकते हैं, और अगर यह काम न करे, तो वापस लौटें (Esc Esc या /rewind) और कोई अलग दृष्टिकोण आज़माएँ। (चेकपॉइंट्स एजेंट के अपने edits को ट्रैक करते हैं, बाहरी प्रक्रियाओं को नहीं — वे एक सुविधा हैं, git का विकल्प नहीं।)

और अगर आप खुद को एक ही गलती को दो बार से अधिक सुधारते पाते हैं, तो कॉन्टेक्स्ट संभवतः विफल प्रयासों से प्रदूषित है। इसे साफ़ करें और एक तीक्ष्ण प्रॉम्प्ट के साथ फिर से शुरू करें जो अभी सीखी हुई बात को समेट ले — एक बेहतर प्रॉम्प्ट के साथ एक साफ़ सेशन लगभग हमेशा मृत-अंतों से भरे एक लंबे सेशन को हरा देता है।

निचोड़

एक्सप्लोर करें, योजना बनाएँ, बनाएँ, सत्यापित करें। पहले काम के लिए यह धीमा लगता है और दूसरे तक खुद की कीमत वसूल लेता है। आपको आत्मविश्वासी-लेकिन-गलत कोड मिलना बंद हो जाता है, और आपको एक ऐसा एजेंट मिलने लगता है जो वही चीज़ बनाता है जो आपका वास्तव में मतलब था।