कोडिंग एजेंट्स सॉफ़्टवेयर बनाने के तरीके को बदल रहे हैं।

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

यह मार्गदर्शिका Cursor के एजेंट के साथ काम करने की तकनीकों को कवर करती है। चाहे आप एजेंटिक कोडिंग में नए हों या यह जानना चाहते हों कि हमारी टीम Cursor का उपयोग कैसे करती है, हम एजेंट्स के साथ कोडिंग की सर्वोत्तम प्रथाएँ कवर करेंगे।

#एजेंट हार्नेस को समझना

एक एजेंट हार्नेस तीन घटकों पर आधारित होता है:

1. निर्देश: सिस्टम प्रॉम्प्ट और नियम, जो एजेंट व्यवहार को निर्देशित करते हैं
2. उपकरण: फ़ाइल संपादन, कोडबेस खोज, टर्मिनल में कमांड चलाना, और भी बहुत कुछ
3. मॉडल: कार्य के लिए चुना गया एजेंट मॉडल

Cursor का एजेंट हार्नेस उन सभी मॉडल्स के लिए इन घटकों का समन्वय करता है, जिन्हें हम समर्थन देते हैं। हम आंतरिक evals और बाहरी बेंचमार्क्स के आधार पर हर अत्याधुनिक मॉडल के लिए निर्देशों को ट्यून करते हैं और उपकरणों को ट्यून करते हैं।

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

#योजनाओं से शुरू करें

आप जो सबसे प्रभावशाली परिवर्तन कर सकते हैं, वह है कोडिंग से पहले योजना बनाना।

University of Chicago के एक अध्ययन में पाया गया कि अनुभवी डेवलपर्स के कोड जनरेट करने से पहले योजना बनाने की संभावना अधिक होती है। योजना बनाना आपको यह स्पष्ट रूप से सोचने पर मजबूर करता है कि आप क्या बना रहे हैं और एजेंट को काम करने के लिए ठोस लक्ष्य देता है।

#योजना मोड का इस्तेमाल

Agent इनपुट में योजना मोड टॉगल करने के लिए Shift+Tab दबाएँ। तुरंत कोड लिखने के बजाय, एजेंट यह करेगा:

1. प्रासंगिक फ़ाइलें खोजने के लिए आपके कोडबेस का विश्लेषण करेगा
2. आपकी आवश्यकताओं के बारे में स्पष्टीकरण हेतु प्रश्न पूछेगा
3. फ़ाइल पथ और कोड संदर्भों के साथ एक विस्तृत कार्यान्वयन योजना बनाएगा
4. बिल्ड शुरू करने से पहले आपकी स्वीकृति की प्रतीक्षा करेगा

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

सुझाव: योजनाओं को .cursor/plans/ में सहेजने के लिए "कार्यस्थान में सहेजें" पर क्लिक करें। इससे आपकी टीम के लिए दस्तावेज़ीकरण तैयार होता है, रुका हुआ काम फिर से शुरू करना आसान हो जाता है, और उसी सुविधा पर काम कर रहे भविष्य के एजेंट्स के लिए संदर्भ मिलता है।

हर कार्य के लिए विस्तृत योजना ज़रूरी नहीं होती। छोटे-मोटे परिवर्तनों या उन कार्यों के लिए जो आप पहले कई बार कर चुके हैं, सीधे एजेंट का उपयोग करना बिल्कुल ठीक है।

#किसी योजना से फिर से शुरू करना

कभी-कभी एजेंट ऐसा कुछ बिल्ड कर देता है जो आपकी ज़रूरत के मुताबिक नहीं होता। उसे अनुवर्ती प्रॉम्प्ट्स के ज़रिए ठीक करने की कोशिश करने के बजाय, वापस योजना पर जाएँ।

परिवर्तनों को रिवर्ट करें, योजना को इस बारे में और अधिक विशिष्ट बनाते हुए परिष्कृत करें कि आपको क्या चाहिए, और फिर उसे दोबारा चलाएँ। अक्सर यह किसी चल रहे एजेंट को ठीक करने से तेज़ होता है और ज़्यादा साफ़-सुथरे नतीजे देता है।

#संदर्भ प्रबंधन

जैसे-जैसे आप एजेंट्स से कोड लिखवाने में अधिक सहज होते जाते हैं, आपका काम हर एजेंट को वह संदर्भ देना बन जाता है जिसकी उसे अपना कार्य पूरा करने के लिए आवश्यकता होती है।

#एजेंट को संदर्भ खोजने दें

आपको अपने प्रॉम्प्ट में हर फ़ाइल को मैन्युअली टैग करने की ज़रूरत नहीं है।

Cursor का एजेंट शक्तिशाली खोज उपकरण से लैस है और मांग पर संदर्भ जुटा लेता है। जब आप "प्रमाणीकरण फ़्लो" के बारे में पूछते हैं, तो एजेंट grep और सिमैंटिक खोज की मदद से प्रासंगिक फ़ाइलें ढूँढ लेता है, भले ही आपके प्रॉम्प्ट में वे सटीक शब्द मौजूद न हों।

इसे सरल रखें: अगर आपको सटीक फ़ाइल पता है, तो उसे टैग करें। अगर नहीं, तो एजेंट उसे ढूँढ लेगा। अप्रासंगिक फ़ाइलें शामिल करने से एजेंट इस बात को लेकर भ्रमित हो सकता है कि क्या महत्वपूर्ण है।

Cursor के एजेंट के पास @Branch जैसे उपयोगी टूल भी हैं, जो आपको एजेंट को इस बारे में संदर्भ देने देते हैं कि आप किस पर काम कर रहे हैं। "इस ब्रांच पर हुए परिवर्तनों की समीक्षा करें" या "मैं किस पर काम कर रहा हूँ?" जैसे वाक्य एजेंट को आपके वर्तमान कार्य के बारे में दिशा देने के स्वाभाविक तरीके हैं।

#नई बातचीत कब शुरू करें

सबसे आम सवालों में से एक: क्या मुझे यह बातचीत जारी रखनी चाहिए या नई शुरू करनी चाहिए?

इन स्थितियों में नई बातचीत शुरू करें:

• आप किसी अलग कार्य या फ़ीचर पर जा रहे हों
• एजेंट भ्रमित लग रहा हो या बार-बार वही गलतियाँ कर रहा हो
• आप काम की एक तार्किक इकाई पूरी कर चुके हों

इन स्थितियों में बातचीत जारी रखें:

• आप उसी फ़ीचर पर आगे काम कर रहे हों
• एजेंट को चर्चा के पहले के संदर्भ की आवश्यकता हो
• आप किसी ऐसी चीज़ को डीबग कर रहे हों, जिसे उसने अभी बनाया है

लंबी बातचीतों से एजेंट का फ़ोकस भटक सकता है। कई टर्न और सारांशण के बाद, संदर्भ में अनावश्यक शोर जमा हो जाता है और एजेंट भटक सकता है या असंबंधित कार्यों पर स्विच कर सकता है। अगर आपको लगे कि एजेंट की प्रभावशीलता घट रही है, तो नई बातचीत शुरू करने का समय आ गया है।

#पिछले काम का संदर्भ लें

जब आप नई बातचीत शुरू करें, तो पूरी बातचीत को कॉपी-पेस्ट करने के बजाय पहले के काम का संदर्भ लेने के लिए @Past Chats का उपयोग करें। एजेंट चैट इतिहास में से चुनकर सिर्फ वही संदर्भ पढ़ सकता है, जिसकी उसे ज़रूरत हो।

यह पूरी बातचीतों की नकल करने की तुलना में अधिक कुशल है।

#एजेंट का विस्तार

Cursor एजेंट व्यवहार को अनुकूलित करने के दो मुख्य तरीके प्रदान करता है: हर बातचीत पर लागू होने वाले स्थिर संदर्भ के लिए नियम, और प्रासंगिक होने पर एजेंट द्वारा उपयोग की जा सकने वाली गतिशील क्षमताओं के for कौशल।

#नियम: आपके प्रोजेक्ट के लिए स्थिर संदर्भ

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

.cursor/rules/ में Markdown फ़ाइलों के रूप में नियम बनाएँ:

# कमांड

- `npm run build`: Build the project
- `npm run typecheck`: Run the typechecker
- `npm run test`: Run tests (prefer single test files for speed)

# कोड स्टाइल

- Use ES modules (import/export), not CommonJS (require)
- Destructure imports when possible: `import { foo } from 'bar'`
- See `components/Button.tsx` for canonical component structure

# वर्कफ़्लो

- Always typecheck after making a series of code changes
- API routes go in `app/api/` following existing patterns

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

नियमों में किन चीज़ों से बचें:

• पूरी style guides की नकल करना (इसके बजाय linter का उपयोग करें)
• हर संभव कमांड को दस्तावेज़ित करना (एजेंट सामान्य टूल जानता है)
• उन विशेष परिस्थितियों के लिए निर्देश जोड़ना जो शायद ही कभी लागू होती हैं

सुझाव: सरल तरीके से शुरू करें। नियम केवल तब जोड़ें, जब आप देखें कि एजेंट बार-बार वही गलती कर रहा है। अपने पैटर्न समझने से पहले ज़रूरत से ज़्यादा अनुकूलन न करें।

अपने नियमों को git में commit करें, ताकि आपकी पूरी टीम को उसका लाभ मिले। जब आप एजेंट को गलती करते देखें, तो नियम अपडेट करें। आप GitHub issue या PR में @cursor को tag भी कर सकते हैं, ताकि एजेंट आपके लिए नियम अपडेट कर दे।

#कौशल: डायनेमिक क्षमताएँ और वर्कफ़्लो

एजेंट कौशल एजेंट्स की क्षमताओं का विस्तार करते हैं। कौशल डोमेन-विशिष्ट ज्ञान, वर्कफ़्लो, और स्क्रिप्ट्स को एक साथ पैकेज करते हैं, जिन्हें एजेंट ज़रूरत पड़ने पर इस्तेमाल कर सकते हैं।

कौशल SKILL.md फ़ाइलों में परिभाषित किए जाते हैं और इनमें ये शामिल हो सकते हैं:

• कस्टम कमांड: पुन: प्रयोज्य वर्कफ़्लो, जिन्हें एजेंट इनपुट में / के साथ ट्रिगर किया जाता है
• हुक्स: स्क्रिप्ट्स, जो एजेंट की कार्रवाइयों से पहले या बाद में चलती हैं
• डोमेन ज्ञान: विशिष्ट कार्यों के लिए निर्देश, जिन्हें एजेंट मांग पर शामिल कर सकता है

नियमों के विपरीत, जो हमेशा शामिल रहते हैं, कौशल तभी डायनेमिक रूप से लोड होते हैं जब एजेंट तय करता है कि वे प्रासंगिक हैं। इससे आपकी कॉन्टेक्स्ट विंडो साफ़-सुथरी रहती है, जबकि एजेंट को विशेषीकृत क्षमताओं तक पहुँच मिलती है।

#उदाहरण: लंबे समय तक चलने वाला एजेंट लूप

एक शक्तिशाली पैटर्न यह है कि कौशल का इस्तेमाल करके ऐसे एजेंट बनाए जाएँ जो लंबे समय तक चलते रहें और लक्ष्य हासिल होने तक पुनरावृत्ति करते रहें। यहाँ बताया गया है कि आप ऐसा हुक कैसे बिल्ड कर सकते हैं, जो किसी एजेंट को तब तक काम में लगाए रखे जब तक सभी टेस्ट पास न हों।

सबसे पहले, .cursor/hooks.json में हुक को कॉन्फ़िगर करें:

{
  "version": 1,
  "hooks": {
    "stop": [{ "command": "bun run .cursor/hooks/grind.ts" }]
  }
}

हुक स्क्रिप्ट (.cursor/hooks/grind.ts) stdin से संदर्भ लेती है और लूप जारी रखने के लिए followup_message लौटाती है:

import { readFileSync, existsSync } from "fs";

interface StopHookInput {
  conversation_id: string;
  status: "completed" | "aborted" | "error";
  loop_count: number;
}

const input: StopHookInput = await Bun.stdin.json();
const MAX_ITERATIONS = 5;

if (input.status !== "completed" || input.loop_count >= MAX_ITERATIONS) {
  console.log(JSON.stringify({}));
  process.exit(0);
}

const scratchpad = existsSync(".cursor/scratchpad.md")
  ? readFileSync(".cursor/scratchpad.md", "utf-8")
  : "";

if (scratchpad.includes("DONE")) {
  console.log(JSON.stringify({}));
} else {
  console.log(JSON.stringify({
    followup_message: `[Iteration ${input.loop_count + 1}/${MAX_ITERATIONS}] Continue working. Update .cursor/scratchpad.md with DONE when complete.`
  }));
}

यह पैटर्न इन कामों के लिए उपयोगी है:

• सभी टेस्ट पास होने तक चलाना (और ठीक करना)
• UI पर तब तक काम करते रहना, जब तक वह डिज़ाइन मॉकअप से मेल न खा जाए
• कोई भी लक्ष्य-उन्मुख कार्य, जिसमें सफलता को सत्यापित किया जा सके

सुझाव: हुक्स वाले कौशल सुरक्षा टूल, सीक्रेट्स मैनेजर और ऑब्ज़र्वेबिलिटी प्लेटफ़ॉर्म के साथ इंटीग्रेट हो सकते हैं। पार्टनर एकीकरण के लिए हुक्स दस्तावेज़ीकरण देखें।

एजेंट कौशल वर्तमान में केवल नाइटली रिलीज़ चैनल में उपलब्ध हैं। Cursor सेटिंग्स खोलें, Beta चुनें, फिर अपना अपडेट चैनल Nightly पर सेट करें और पुनः आरंभ करें।

कोडिंग के अलावा, आप एजेंट को उन अन्य टूल्स से कनेक्ट कर सकते हैं जिनका आप रोज़ाना उपयोग करते हैं। MCP (मॉडल कॉन्टेक्स्ट प्रोटोकॉल) एजेंट को Slack संदेश पढ़ने, Datadog लॉग्स की जाँच करने, Sentry की त्रुटियों को डीबग करने, डेटाबेस क्वेरी करने और भी बहुत कुछ करने देता है।

#छवियाँ शामिल करना

एजेंट आपके प्रॉम्प्ट्स में दी गई छवियों को सीधे प्रोसेस कर सकता है। स्क्रीनशॉट पेस्ट करें, डिज़ाइन फ़ाइलें ड्रैग-एंड-ड्रॉप करें, या इमेज पाथ का संदर्भ दें।

#डिज़ाइन से कोड

एक डिज़ाइन मॉकअप पेस्ट करें और एजेंट से उसे कोड में बदलने के लिए कहें। एजेंट इमेज देख सकता है और लेआउट, रंगों और स्पेसिंग से मेल बिठा सकता है। आप Figma MCP सर्वर का उपयोग भी कर सकते हैं।

#विज़ुअल डीबगिंग

किसी त्रुटि स्थिति या अप्रत्याशित UI का स्क्रीनशॉट लें और एजेंट से उसकी जांच करने को कहें। अक्सर यह समस्या को शब्दों में समझाने से तेज़ होता है।

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

#सामान्य वर्कफ़्लो

यहाँ ऐसे एजेंट पैटर्न दिए गए हैं, जो अलग-अलग प्रकार के कार्यों में अच्छी तरह काम आते हैं।

#परीक्षण-आधारित विकास

एजेंट कोड लिख सकता है, परीक्षण चला सकता है, और स्वचालित रूप से दोहराव कर सकता है:

1. अपेक्षित इनपुट/आउटपुट जोड़ों के आधार पर परीक्षण लिखने के लिए एजेंट से कहें। साफ़ तौर पर बताएँ कि आप TDD कर रहे हैं, ताकि वह ऐसी कार्यक्षमता के लिए mock implementation न बनाए जो अभी मौजूद नहीं है।
2. एजेंट से कहें कि परीक्षण चलाए और पुष्टि करे कि वे विफल हो रहे हैं। साफ़ तौर पर कहें कि इस चरण में implementation code न लिखे।
3. जब आप परीक्षणों से संतुष्ट हों, तो उन्हें कमिट करें।
4. एजेंट से ऐसा कोड लिखने के लिए कहें जो परीक्षण पास कर दे, और उसे निर्देश दें कि वह परीक्षणों को संशोधित न करे। उससे कहें कि जब तक सभी टेस्ट पास न हों, तब तक वह दोहराव करता रहे।
5. जब आप परिवर्तनों से संतुष्ट हों, तो implementation को कमिट करें।

एजेंट्स तब सबसे अच्छा काम करते हैं, जब उनके पास दोहराव के लिए एक स्पष्ट लक्ष्य हो। परीक्षण एजेंट को परिवर्तन करने, नतीजों का आकलन करने, और सफल होने तक धीरे-धीरे सुधार करने में मदद करते हैं।

#कोडबेस को समझना

किसी नए कोडबेस पर ऑनबोर्डिंग के दौरान, सीखने और पड़ताल के लिए एजेंट का उपयोग करें। वही सवाल पूछें जो आप अपनी टीम के किसी साथी से पूछते:

• "इस प्रोजेक्ट में लॉगिंग कैसे काम करती है?"
• "मैं नया API एंडपॉइंट कैसे जोड़ूँ?"
• "CustomerOnboardingFlow किन-किन एज केस को संभालता है?"
• "लाइन 1738 पर हम createUser() की जगह setUser() क्यों कॉल कर रहे हैं?"

एजेंट, कोडबेस में खोजकर जवाब ढूँढने के लिए grep और सिमैंटिक खोज, दोनों का उपयोग करता है। अपरिचित कोड को जल्दी समझने के सबसे तेज़ तरीकों में से यह एक है।

#Git वर्कफ़्लो

एजेंट Git हिस्ट्री में खोज कर सकते हैं, मर्ज कॉन्फ्लिक्ट्स को सुलझा सकते हैं, और आपके Git वर्कफ़्लो को स्वचालित कर सकते हैं।

उदाहरण के लिए, एक /pr कमांड जो कमिट करता है, पुश करता है, और एक पुल रिक्वेस्ट खोलता है:

वर्तमान परिवर्तनों के लिए पुल रिक्वेस्ट बनाएँ।

1. `git diff` से staged और unstaged परिवर्तन देखें
2. जो बदला है उसके आधार पर एक स्पष्ट कमिट संदेश लिखें
3. वर्तमान ब्रांच पर कमिट और पुश करें
4. शीर्षक/विवरण के साथ पुल रिक्वेस्ट खोलने के लिए `gh pr create` का उपयोग करें
5. पूरा होने पर PR URL लौटाएँ

कमांड उन वर्कफ़्लो के लिए आदर्श हैं जिन्हें आप दिन में कई बार चलाते हैं। उन्हें .cursor/commands/ में Markdown फ़ाइलों के रूप में सहेजें और git में check in करें, ताकि आपकी पूरी टीम उनका उपयोग कर सके।

हमारे द्वारा उपयोग किए जाने वाले कमांड के कुछ अन्य उदाहरण:

• /fix-issue [number]: gh issue view से समस्या का विवरण प्राप्त करें, प्रासंगिक कोड खोजें, सुधार लागू करें, और एक PR खोलें
• /review: linters चलाएँ, सामान्य समस्याओं की जाँच करें, और किन चीज़ों पर ध्यान देने की ज़रूरत हो सकती है उसका सारांश दें
• /update-deps: पुरानी हो चुकी निर्भरताओं की जाँच करें और उन्हें एक-एक करके अपडेट करें, हर अपडेट के बाद परीक्षण चलाएँ

एजेंट इन कमांड का स्वायत्त रूप से उपयोग कर सकता है, इसलिए आप एक ही / invocation से बहु-चरणीय वर्कफ़्लो उसे सौंप सकते हैं।

#कोड की समीक्षा

AI-जनित कोड की समीक्षा ज़रूरी है, और Cursor इसके लिए कई विकल्प देता है।

#जेनरेशन के दौरान

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

#एजेंट समीक्षा

एजेंट के काम पूरा करने के बाद, एक समर्पित समीक्षा चलाने के लिए समीक्षा → समस्याएँ खोजें पर क्लिक करें। एजेंट प्रस्तावित संपादनों का पंक्ति-दर-पंक्ति विश्लेषण करता है और संभावित समस्याओं को चिह्नित करता है।

सभी लोकल परिवर्तनों के लिए, Source Control टैब खोलें और अपनी main ब्रांच से तुलना करने के लिए Agent Review चलाएँ।

#पुल रिक्वेस्ट्स के लिए Bugbot

पुल रिक्वेस्ट्स पर स्वचालित समीक्षाएँ पाने के लिए सोर्स कंट्रोल में पुश करें। Bugbot समस्याओं को शुरुआती चरण में पकड़ने और हर PR पर सुधार के सुझाव देने के लिए उन्नत विश्लेषण का उपयोग करता है।

#आर्किटेक्चर डायग्राम

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

#समानांतर में एजेंट चलाना

Cursor में कई एजेंट्स को समानांतर में चलाना आसान है, बिना इस जोखिम के कि वे एक-दूसरे के काम में हस्तक्षेप करें। हमने पाया है कि एक ही समस्या पर कई मॉडल्स को आज़माकर और उनमें से सर्वश्रेष्ठ परिणाम चुनकर, खासकर अधिक कठिन कार्यों में, अंतिम आउटपुट काफ़ी बेहतर हो जाता है।

#नेटिव वर्कट्री समर्थन

Cursor समानांतर एजेंट्स के लिए git वर्कट्रीज़ स्वचालित रूप से बनाता और प्रबंधित करता है। हर एजेंट अपनी अलग वर्कट्री में, पृथक फ़ाइलों और परिवर्तनों के साथ चलता है, ताकि एजेंट एक-दूसरे के काम में दखल दिए बिना कोड को संपादित, बिल्ड और परीक्षण कर सकें।

वर्कट्री में किसी एजेंट को चलाने के लिए, एजेंट ड्रॉपडाउन से वर्कट्री विकल्प चुनें। जब एजेंट अपना काम पूरा कर ले, तो उसके परिवर्तन वापस आपकी वर्किंग ब्रांच में मर्ज करने के लिए लागू करें पर क्लिक करें।

#एक साथ कई मॉडल चलाएँ

एक ही प्रॉम्प्ट को कई मॉडलों पर एक साथ चलाना एक बेहद प्रभावी तरीका है। ड्रॉपडाउन से कई मॉडल चुनें, अपना प्रॉम्प्ट सबमिट करें, और नतीजों की साथ-साथ तुलना करें। Cursor यह भी सुझाव देगा कि उसके हिसाब से कौन-सा समाधान सर्वश्रेष्ठ है।

यह खास तौर पर इन मामलों में उपयोगी है:

• कठिन समस्याएँ, जहाँ अलग-अलग मॉडल अलग-अलग तरीके अपना सकते हैं
• अलग-अलग मॉडल परिवारों में कोड गुणवत्ता की तुलना करना
• उन विशेष परिस्थितियों को खोजना जिन्हें कोई मॉडल छोड़ सकता है

जब आप कई एजेंट समानांतर में चलाएँ, तो सूचनाएँ और ध्वनियाँ कॉन्फ़िगर करें, ताकि उनके पूरा होने पर आपको पता चल सके।

#क्लाउड एजेंटों को सौंपना

क्लाउड एजेंट उन कार्यों के लिए बेहद उपयोगी हैं जिन्हें आप वरना अपनी टू-डू सूची में जोड़ते:

• किसी और चीज़ पर काम करते समय सामने आए बग सुधार
• हाल के कोड परिवर्तनों का रिफैक्टरिंग
• मौजूदा कोड के लिए परीक्षण जनरेट करना
• दस्तावेज़ीकरण में अपडेट

आप कार्य के अनुसार लोकल और क्लाउड एजेंटों के बीच स्विच कर सकते हैं। cursor.com/agents, Cursor एडिटर, या अपने फ़ोन से क्लाउड एजेंट शुरू करें। डेस्क से दूर होने पर, वेब या मोबाइल से सत्रों की जाँच करें। क्लाउड एजेंट रिमोट सैंडबॉक्स में चलते हैं, इसलिए आप अपना लैपटॉप बंद कर सकते हैं और बाद में नतीजे देख सकते हैं।

यहाँ बताया गया है कि क्लाउड एजेंट आंतरिक रूप से कैसे काम करते हैं:

1. कार्य और किसी भी प्रासंगिक संदर्भ का वर्णन करें
2. एजेंट आपके रेपो को क्लोन करता है और एक ब्रांच बनाता है
3. यह स्वायत्त रूप से काम करता है, जब समाप्त हो जाता है तो एक पुल रिक्वेस्ट खोलता है
4. जब यह पूरा हो जाता है तो आपको सूचित किया जाता है (Slack, ईमेल, या वेब इंटरफ़ेस के माध्यम से)
5. बदलावों की समीक्षा करें और तैयार होने पर मर्ज करें

टिप: आप Slack से "@Cursor" के साथ एजेंट्स ट्रिगर कर सकते हैं। और जानें.

#मुश्किल बग्स के लिए डीबग मोड

जब सामान्य एजेंट इंटरैक्शन किसी बग को हल करने में अटक जाते हैं, तो डीबग मोड एक अलग तरीका देता है।

सुधारों का अनुमान लगाने के बजाय, डीबग मोड:

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

यह इन स्थितियों में सबसे अच्छा काम करता है:

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

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

#अपने वर्कफ़्लो को विकसित करना

जो डेवलपर्स एजेंट्स से सबसे ज़्यादा लाभ उठाते हैं, उनमें कुछ समान गुण होते हैं:

वे स्पष्ट और विशिष्ट प्रॉम्प्ट लिखते हैं। स्पष्ट निर्देशों के साथ एजेंट की सफलता दर काफ़ी बढ़ जाती है। "add tests for auth.ts" की तुलना "Write a test case for auth.ts covering the logout edge case, using the patterns in __tests__/ and avoiding mocks." से करें।

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

वे सावधानी से समीक्षा करते हैं। AI-जनित कोड ऊपर से सही लग सकता है, लेकिन उसमें बारीक गलतियाँ हो सकती हैं। डिफ्स पढ़ें और ध्यान से समीक्षा करें। एजेंट जितनी तेज़ी से काम करता है, आपकी समीक्षा प्रक्रिया उतनी ही ज़्यादा महत्वपूर्ण हो जाती है।

वे ऐसे लक्ष्य देते हैं जिन्हें सत्यापित किया जा सके। एजेंट उन चीज़ों को ठीक नहीं कर सकते जिनके बारे में उन्हें पता ही नहीं है। typed languages का इस्तेमाल करें, linters कॉन्फ़िगर करें, और परीक्षण लिखें। एजेंट को स्पष्ट संकेत दें कि परिवर्तन सही हैं या नहीं।

वे एजेंट्स को सक्षम सहयोगियों की तरह देखते हैं। योजनाएँ माँगें। स्पष्टीकरण माँगें। जिन तरीकों से आप सहमत नहीं हैं, उन्हें चुनौती दें।

एजेंट्स तेज़ी से बेहतर हो रहे हैं। हालाँकि नए मॉडल्स के साथ ये पैटर्न बदलते रहेंगे, हमें उम्मीद है कि कोडिंग एजेंट्स के साथ काम करते समय यह आपको आज अधिक उत्पादक बनने में सहायता करेगा।

इन तकनीकों को आज़माने के लिए Cursor का एजेंट के साथ शुरू करें।