Claude × Codex को जागृत करने के लिए अंतिम एजेंट डिज़ाइन [नवीनतम संस्करण]

भले ही आपको कहा जाए कि "और अधिक स्पष्ट निर्देश दें," मुझे उसी "स्पष्ट हिस्से" से शुरुआत करने में मदद चाहिए।

आपके पास कुछ ऐसा है जिसे आप बनाना चाहते हैं, लेकिन AI से पूछने के लिए ज़रूरी प्रारंभिक रिसर्च करते-करते आपके हाथ रुक जाते हैं। यह एक बुरा सौदा लगता है।

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

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

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

इस आर्टिकल में हम जो डेवलपमेंट टीम बना रहे हैं, उसे Claude Code और Codex का उपयोग करके इस तरह की मांग के करीब पहुंचने के लिए डिज़ाइन किया गया है।

• Claude Code: अनुरोधों के लिए संपर्क बिंदु। ज़रूरी पुष्टियों और काम के बंटवारे को व्यवस्थित करता है।
• Codex: इम्प्लीमेंटेशन और इंस्पेक्शन संभालता है।

एक केस मैनेजमेंट ऐप के लिए, स्क्रीन बनाने के अलावा, आपको वेरिफिकेशन टास्क भी तैयार करने होते हैं। क्या होगा अगर आप खाली फील्ड्स के साथ रजिस्टर करें? क्या रीलोड करने के बाद रिकॉर्ड बने रहेंगे? अगर कोई बग ठीक नहीं होता है, तो किए गए प्रयासों और बचे हुए लक्षणों का सारांश तैयार करके किसी दूसरे एजेंट को सौंप दें।

इंसान जो करता है वह यह है कि रास्ते में ज़रूरी फैसले लेता है और अंत में वास्तविक ऑपरेशन्स को वेरीफाई करता है। इसे आसान बनाने के लिए, एक ऐसा ढांचा बनाएं जहां स्पेसिफिकेशन्स, बदलाव और वेरिफिकेशन के नतीजे ठीक से आपके हाथों में वापस आएं। आइए इसे कनेक्शन के तरीकों से लेकर टास्क हैंडओवर और रोकने की शर्तों तक, कदम दर कदम बनाएं।

Claude को खुला रखते हुए Codex को काम सौंपें

पिछले जवाबों को किसी दूसरे AI में पेस्ट किए बिना Claude Code से Codex तक अनुरोध भेजने का एक तरीका है। यह OpenAI द्वारा जारी किया गया "Claude Code के लिए Codex प्लगइन" है।

आधिकारिक दस्तावेज़ीकरण के अनुसार, यह निम्नलिखित उपयोगों को सपोर्ट करता है:

• मौजूदा बदलावों की जांच करने वाले रिव्यू

• जांच या सुधार का प्रतिनिधिमंडल (delegation)

• बातचीत का हैंडओवर

यह आर्टिकल 16 अक्टूबर 2026 को सत्यापित आधिकारिक दस्तावेज़ों के आधार पर, लोकल एनवायरनमेंट के Claude Code से इसे इस्तेमाल करने की प्रक्रिया को कवर करता है।

पूर्व आवश्यकताएं

• एक ऐसा एनवायरनमेंट जहां Claude Code उपलब्ध हो

• Git

• Node.js (आधिकारिक आवश्यकता: 18.18 या उससे नया)

• Codex से प्रमाणित ChatGPT अकाउंट, या OpenAI API की

प्लगइन आपके लोकल Codex को कॉल करता है। कनेक्ट होने का मतलब यह नहीं है कि Codex, Claude के यूसेज कोटा पर चलेगा; Codex का उपयोग अपना कोटा ही खर्च करता है।

साथ ही, हालांकि यह सेटअप लोकल फाइलों को संभालता है, AI इन्फरेंस ज़रूरी नहीं कि पूरी तरह आपके PC के अंदर ही हो। ऐसे प्रैक्टिस फोल्डर से शुरुआत करें जिसमें कोई गोपनीय जानकारी न हो।

प्लगइन इंस्टॉल करें

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

1/plugin marketplace add openai/codex-plugin-cc
2/plugin install codex@openai-codex
3/reload-plugins
4/codex:setup

आखिरी /codex:setup आपको Codex की इंस्टॉलेशन और ऑथेंटिकेशन स्थिति की जांच करने देता है। अगर Codex नहीं मिलता है और npm उपलब्ध है, तो इंस्टॉलेशन के लिए मार्गदर्शन दिखाई देगा; सामग्री की समीक्षा करें और उसके अनुसार आगे बढ़ें।

अगर ऑथेंटिकेट नहीं है, तो टर्मिनल में codex login चलाएं और निर्देशों का पालन करें।

Windows पर, सुनिश्चित करें कि Claude चलाने वाला एनवायरनमेंट और जहां Codex इंस्टॉल किया गया था वह एनवायरनमेंट अलग-अलग न हों। सिर्फ इसलिए बार-बार रीइंस्टॉल करने से बचें क्योंकि यह "not found" कह रहा है।

पहले रिव्यू आज़माएं

ऐसे रिव्यू से शुरुआत करें जो कोड को फिर से नहीं लिखता। Git-मैनेज्ड प्रैक्टिस प्रोजेक्ट में एक छोटा बदलाव तैयार करें और चलाएं:

1/codex:review --background

• प्रगति जांचें: /codex:status

• पूरे हुए नतीजे जांचें: /codex:result

जब कई अनुरोध सक्रिय हों, तो नतीजों के मिक्स होने से बचने के लिए दिखाई गई Job ID निर्दिष्ट करें।

टास्क के बंटवारे के लिए Amazon के पब्लिक सैंपल उपयोगी हैं

रोल डिवीजन के संदर्भ के लिए, AWS (Amazon की क्लाउड बिज़नेस यूनिट) द्वारा प्रकाशित डेवलपमेंट सैंपल देखें। GitHub के aws-samples पर दो प्रासंगिक रिपॉजिटरी हैं:

• sample-codex-agent-team (Codex के लिए)

• sample-claude-code-agent-team (Claude Code के लिए)

Codex वर्ज़न में छह रोल हैं:

यह तय करना कि रजिस्ट्रेशन स्क्रीन कैसे बनाई जाए, बनाम स्केलेबिलिटी, मेंटेनेंस लागत आदि पर विचार करना, अलग-अलग काम हैं। फीचर इम्प्लीमेंटेशन को ऑपरेशनल सलाह से अलग करने से विशिष्ट एजेंटों से पूछे जाने वाले सवाल अधिक ठोस हो जाते हैं।

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

दोनों सैंपल के बीच टास्क हैंडओवर के तरीके अलग हैं:

• Claude Code वर्ज़न: एजेंट एक साझा टास्क लिस्ट से टास्क उठाते हैं (प्रयोगात्मक एजेंट टीमों का उपयोग करता है, अतिरिक्त कॉन्फ़िगरेशन की आवश्यकता है)

• Codex वर्ज़न: विभाजित जिम्मेदारी वाली फाइलों के साथ एक कार्य योजना के अनुसार आगे बढ़ता है

ये अलग-अलग सैंपल हैं। अगर दोनों इंस्टॉल किए जाएं तो ये अपने आप मिलकर एक टीम नहीं बन जाते।

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

यह आर्टिकल एक छोटे ढांचे से शुरू होता है जहां Claude Code इंटरफ़ेस के रूप में काम करता है, और सीमित इम्प्लीमेंटेशन व इंस्पेक्शन टास्क Codex को सौंपता है।

नोट: यह पब्लिक सैंपल का संदर्भ लेते हुए एक अनूठा ऑपरेशनल उदाहरण है। यह Claude और Codex के AWS इंटीग्रेशन की गारंटी देने वाला प्रोडक्ट नहीं है, और न ही मापे गए व्यवहार की कोई रिपोर्ट है।

बनाने से पहले "सेव करने योग्य" का अर्थ स्पष्ट करें

जब आप विस्तार से वर्णन नहीं कर पाते कि आप क्या बनाना चाहते हैं, तो तुरंत इम्प्लीमेंटेशन शुरू न करें। पहले Claude से पुष्टि की जाने वाली चीज़ों को व्यवस्थित करवाएं। आपको सभी तकनीकी शब्द जानने की ज़रूरत नहीं है; बस उन्हें उन सवालों में बदल दें जिनका आप जवाब दे सकें।

मैं एक पर्सनल केस मैनेजमेंट ऐप बनाना चाहता हूं। कृपया पहले ज़रूरी स्पेसिफिकेशन्स को व्यवस्थित करें और जिन फैसलों की ज़रूरत है उनके बारे में एक-एक करके सवाल पूछें। तकनीकी विकल्पों के लिए, यूज़र्स पर पड़ने वाले प्रभाव और सिफारिश के कारणों को संक्षेप में समझाएं। जब तक मैं मंजूरी न दूं, इम्प्लीमेंटेशन शुरू न करें।

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

इस अभ्यास के लिए, दायरा सीमित करें:

• In Scope: उसी PC/ब्राउज़र पर उपयोग, रीलोड के बाद रिकॉर्ड बने रहें

• Out of Scope: मल्टी-डिवाइस सिंक, लॉगिन, बाहरी प्रकाशन, ग्राहक का असली डेटा

पूरा होने के मानदंड "उपयोग में आसान" से नहीं, बल्कि ऑपरेशन के नतीजों से तय करें:

• केस रजिस्टर कर सकता है

• डेडलाइन के हिसाब से सॉर्ट किया गया

• स्टेटस बदल सकता है

• खाली रजिस्ट्रेशन कारण दिखाता है

• रीलोड के बाद कंटेंट बना रहता है

स्पेक्स और टास्क अनुरोधों को फाइलों में सेव करें

तय की गई बातों को docs/spec.md में एक स्पेसिफिकेशन के रूप में सेव करें जिसे सभी संदर्भित करेंगे। यहां दिए गए फाइल नाम उदाहरण हैं; ये अपने आप सभी AI में नहीं बंटतीं, इसलिए हर अनुरोध के साथ "इसे पढ़ें" निर्दिष्ट करें।

तय किए गए स्पेक्स, पूरा होने के मानदंड, और out-of-scope फीचर्स को docs/spec.md में सेव करें। अनिर्णीत मामलों को पुष्टि किए गए के रूप में न लिखें। इम्प्लीमेंटेशन रोकने की ज़रूरत वाली चीज़ों को अस्थायी सेटिंग्स के साथ आगे बढ़ने वाली चीज़ों से अलग करें।

इसके बाद, docs/tasks.md में इम्प्लीमेंट करने वालों के लिए टास्क अनुरोधों का सारांश तैयार करें। सिर्फ टास्क का नाम बताना काफी नहीं है। पढ़ने की सामग्री, एडिट करने योग्य फाइलें, न बदलने वाले हिस्से, वेरिफिकेशन के तरीके और अपेक्षित आउटपुट शामिल करें।

स्पेक्स को इम्प्लीमेंट करने योग्य इकाइयों में तोड़ें। docs/tasks.md में सौंपी गई फाइलें, पूर्व-आवश्यकता वाले टास्क और वेरिफिकेशन के तरीके लिखें। UI और स्टोरेज लॉजिक के बीच साझा की जाने वाली चीज़ों को पहले से तय करें। दो एजेंटों द्वारा एक ही फाइल को एक साथ एडिट करने की योजना न बनाएं।

दोनों AI को एक ही स्पेक दिखाएं

लगातार दिए जाने वाले निर्देश Claude के लिए CLAUDE.md और Codex के लिए AGENTS.md में लिखे जा सकते हैं। ये दस्तावेज़ीकृत तंत्र हैं। हालांकि, यह न मानें कि एक फाइल दूसरे के लिए भी उसी तरह काम करेगी। दोनों से एक ही स्पेक फाइल को संदर्भित करें।

निर्देश छोटे रखें:

• स्पेक फाइल का स्थान

• अनुरोधों के बाहर कोई बदलाव न करें

स्पेक्स को डुप्लीकेट करने से खतरा होता है कि एक तरफ का डेटा पुराना हो जाए। यह उससे बचाता है।

समानांतर कार्यों से पहले वर्कस्पेस अलग करें

कई AI का काम करना तेज़ लगता है, लेकिन अलग-अलग नीतियों के साथ एक ही फाइल को फिर से लिखना सिर्फ इंसानों के लिए सफाई का काम पैदा करता है।

शुरुआती समानांतर काम के लिए, "UI builder" को "test planner" के साथ जोड़ें। फॉर्मेट तय होने से पहले UI और स्टोरेज को अलग-अलग इम्प्लीमेंट करने से बेमेल होने की समस्याएं बढ़ती हैं।

फोल्डर अलग करने के लिए Git Worktree का उपयोग करें

Git worktree यहां उपयोगी है। यह एक आधिकारिक Git फीचर है जो एक ही प्रोजेक्ट के लिए अलग-अलग बदलावों वाले अलग वर्किंग फोल्डर की अनुमति देता है।

बनाने से पहले, सुनिश्चित करें कि स्पेक्स और बेस Git में कमिट हो गए हैं। बिना कमिट की गई ड्राफ्ट फाइलें नई जगहों पर नहीं जा सकतीं। सत्यापित करें कि ब्रांच नाम और टारगेट फोल्डर पहले से उपयोग में नहीं हैं।

1git worktree add -b feature/ui ../case-app-ui
2git worktree add -b feature/storage ../case-app-storage
3git worktree list

तीन सावधानियां:

1. फोल्डर बनाने से AI वर्कस्पेस नहीं बदलता। हर डायरेक्टरी में अलग सेशन खोलें और शुरू करने से पहले लोकेशन/ब्रांच की जांच करें।

1. प्लगइन कॉलर के एनवायरनमेंट का उपयोग करते हैं। Claude/Codex को कनेक्ट करने से यह अपने आप अलग नहीं होता। शुरुआत में, "एक लोकेशन पर एक एडिटर" पर टिके रहें।

1. Worktrees मुख्य रूप से फाइलों को अलग करते हैं। साझा डेटाबेस या पोर्ट से टकराव होता है। टेस्ट स्टोरेज/पोर्ट अलग करें या शुरुआत को क्रमबद्ध करें।

Codex में एक साथ चलने वाले टास्क सीमित करें

Codex में सब-एजेंट बढ़ाने के लिए, एक साथ चलने वाले थ्रेड्स को सीमित करें। सब-एजेंट को पैरेंट AI से सीमित टास्क मिलते हैं। .codex/config.toml में मौजूदा कॉन्फ़िगरेशन:

1[agents]
2enabled = true
3max_concurrent_threads_per_session = 2

• एंट्री डुप्लीकेट न करें

• केवल भरोसेमंद प्रोजेक्ट्स में उपयोग करें (प्रोजेक्ट सेटिंग्स केवल भरोसेमंद संदर्भों में लोड होती हैं)

• यह सीमा "उस सेशन में मेन एजेंट को छोड़कर समानांतर थ्रेड्स" पर लागू होती है, न कि Claude/सेशन के कुल आंकड़े पर।

AWS सैंपल के 14 थ्रेड सिर्फ उनकी पसंद हैं। यह कोई अनिवार्य नियम नहीं है। उनका max_threads एक पुराना नाम है; मौजूदा नामों का उपयोग करें।

इम्प्लीमेंट करने वालों को हर बार शुरू से न समझाएं

Codex में, .codex/agents में TOML फाइलों के ज़रिए कस्टम एजेंट परिभाषित करें। ज़रूरी शर्तों के साथ task-builder.toml बनाएं:

1name = "task-builder"
2description = "पुष्टि किए गए स्पेक्स से केवल सौंपा गया दायरा इम्प्लीमेंट करें"
3developer_instructions = """
4पहले docs/spec.md और docs/tasks.md पढ़ें।
5केवल सौंपा गया दायरा इम्प्लीमेंट करें; अगर स्पेक में बदलाव की ज़रूरत हो तो रुकें और रिपोर्ट करें।
6दूसरे एजेंटों के बदलाव वापस न करें, सीक्रेट न पढ़ें, या बाहर पब्लिश न करें।
7बदली गई फाइलें, चलाए गए टेस्ट, नतीजे और अपुष्ट चीज़ें लौटाएं।
8"""

यहां मॉडल के नाम फिक्स करने से बचें। डिफ़ॉल्ट रूप से यह पैरेंट सेटिंग्स को इनहेरिट करता है। पब्लिक सैंपल मॉडल आपके कॉन्ट्रैक्ट पर उपलब्ध नहीं हो सकते; अनुपलब्ध नामों को हार्डकोड करने से रोल के विवरण से पहले ही शुरुआत रुक जाती है।

फाइल रखने के बाद, नए Codex सेशन में पहचान की जांच करें और एक छोटा टास्क सौंपें। अगर Claude से अनुरोध कर रहे हैं, तो Codex में task-builder का उपयोग करना निर्दिष्ट करें।

Codex से अनुरोध करें कि docs/tasks.md से केवल स्टोरेज लॉजिक task-builder को सौंपे। शुरू करने से पहले एजेंट की पहचान और वास्तविक फोल्डर की जांच करें। अगर उपलब्ध न हो, तो चुपचाप तरीके बदलने के बजाय रिपोर्ट करें।

नोट: "बदलाव न करें" लिखना राइट परमिशन हटाने से अलग है। आधिकारिक दस्तावेज़ बताते हैं कि Codex चाइल्ड एजेंट पैरेंट परमिशन (सैंडबॉक्स सेटिंग्स) को इनहेरिट करते हैं। "reviewer" रोल नाम सुरक्षित रीड-ओनली एनवायरनमेंट नहीं बनाता।

अगर सुधार बार-बार दोहराएं जाएं तो एजेंट बदलें

अगर AI कहता है "कारण मिल गया" लेकिन वही ऑपरेशन फिर से फेल हो जाता है, तो अगले सुधार में जल्दबाजी करने के बजाय दर्ज करें कि क्या बदला/क्या नहीं बदला। इसे सौंपना आसान होता है।

आधिकारिक प्लगइन में Codex को जांच/सुधार सौंपने के लिए rescue एंट्री है। नाम के बावजूद, यह सिर्फ बग के लिए नहीं, बल्कि सीमित दायरे वाले कार्यों के लिए है।

जांच को स्पष्ट रूप से रीड-ओनली के रूप में चिह्नित करें

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

1/codex:rescue --fresh जांचें कि रीलोड पर रजिस्ट्रेशन क्यों गायब हो जाता है, रीड-ओनली। docs/spec.md और कोड की तुलना करें। रिप्रोडक्शन स्टेप्स, सबूत-आधारित कारण, ज़रूरी जांच लौटाएं। फाइलें न बदलें।

--fresh नया अनुरोध शुरू करता है; --resume पिछले को जारी रखता है (छोड़ने पर पूछता है)। फिर से शुरू करते समय परमिशन निर्दिष्ट करें। अगर सुधार की ओर बढ़ रहे हैं, तो दायरा परिभाषित करें।

1/codex:rescue --resume पुष्टि किए गए कारण के आधार पर न्यूनतम बदलावों के साथ केवल स्टोरेज लॉजिक ठीक करें। UI/स्पेक्स न बदलें। पहले फेल होने वाला टेस्ट और बाद का नतीजा दिखाएं।

Transfer के साथ पूरी बातचीत ट्रांसफर करें

• केवल टास्क पास करें → rescue

• बातचीत Codex में ले जाएं → transfer

1/codex:transfer

आधिकारिक दस्तावेज़: यह एक Codex थ्रेड बनाता है जो मौजूदा Claude Code बातचीत को जारी रखता है, और resume कमांड दिखाता है। अगर सपोर्ट न हो तो Codex अपडेट करें।

बातचीत ट्रांसफर करना ≠ PC की स्थिति ट्रांसफर करना। बिना सेव किए गए बदलाव, ऑथ, चल रहे ऐप्स नहीं जाते। गंतव्य पर फाइलों/स्थिति की जांच करें।

"Done" होने के बाद दूसरे AI से वेरीफाई करें

इम्प्लीमेंट करने वाले का टेस्टिंग मददगार है, लेकिन अगर उन्होंने स्पेक्स को गलत समझा है, तो पास होने वाले टेस्ट आपकी इच्छित व्यवहार से मेल नहीं खाएंगे।

इंस्पेक्टरों को इम्प्लीमेंट करने वाले की व्याख्या नहीं, बल्कि इंसान द्वारा वेरीफाई किए गए स्पेक्स और वास्तविक बदलाव दें। "पूरी तरह ठीक हो गया" जैसी मूल्यांकन साझा न करें; उन्हें स्वतंत्र रूप से अनुपालन की जांच करने दें।

docs/spec.md और वास्तविक बदलावों की स्वतंत्र रूप से तुलना करें। सबूत के साथ उन पूरा होने के मानदंडों की पहचान करें जो पूरे नहीं हुए। इम्प्लीमेंट करने वाले के आत्म-मूल्यांकन को न मानें। रिप्रोड्यूस होने वाले मुद्दों, संभावित चिंताओं और अपुष्ट चीज़ों को अलग करें। अभी ठीक न करें।

विपरीत चीज़ों को जोड़ें:

• Claude ने इम्प्लीमेंट किया → अलग जांच के रूप में Codex का सामान्य रिव्यू जोड़ें

• Codex ने इम्प्लीमेंट किया → Claude से इंस्पेक्ट करने को कहें, वैकल्पिक रूप से नया Codex रिव्यू जोड़ें

सामान्य बनाम Adversarial रिव्यू

सामान्य रिव्यू को /codex:review से कॉल करें। ब्रांच की main से तुलना करें:

1/codex:review --base main

अगर main नहीं है तो वास्तविक बेस ब्रांच का उपयोग करें। रिव्यू के दौरान बदलावों को न छुएं।

नोट: सामान्य रिव्यू "केवल स्टोरेज जांचें" जैसे फ्री-टेक्स्ट फोकस निर्देशों को स्वीकार नहीं करता। आधिकारिक स्पेक प्राथमिकता निर्देशों को प्रतिबंधित करता है। डिज़ाइन धारणाओं या विशिष्ट जोखिमों को चुनौती देने के लिए, adversarial-review का उपयोग करें।

1/codex:adversarial-review --background जांचें कि क्या सेव फेलियर सफलता के रूप में दिखते हैं, क्या दो टैब से एडिट करने पर रिकॉर्ड खो जाते हैं, मौजूदा डिज़ाइन धारणाओं को सत्यापित करें।

यह कठोर लहजा नहीं है; यह चुने गए दृष्टिकोणों/धारणाओं को चुनौती देता है। दोनों रिव्यू मुद्दों की पहचान करते हैं, कोड ठीक नहीं करते। नतीजों की पुष्टि करें, फिर सुधार अलग से सौंपें।

निष्कर्षों को लागू होने वाले पूरा होने के मानदंडों, यूज़र प्रभाव, वेरिफिकेशन तरीकों के साथ व्यवस्थित करें। स्पेक में बदलाव की ज़रूरत वाले मुद्दों को अपने आप न ठीक करें; इंसान के सामने विकल्प/अंतर प्रस्तुत करें।

शुरुआत में रिव्यू गेट को छोड़ दें

ऑटोमेशन विकल्प: "Review gate" जब भी Claude अपना जवाब पूरा करता है, Codex रिव्यू डालता है। /codex:setup --enable-review-gate से इसे चालू करें।

चेतावनी: आधिकारिक दस्तावेज़ Claude/Codex के बीच लंबे सुधार लूप से कोटा तेज़ी से खत्म होने के जोखिम का उल्लेख करते हैं।

निष्कर्षों को समझने के लिए मैनुअल रिव्यू से शुरुआत करें। दूर जाते समय इसे बंद कर दें। /codex:setup --disable-review-gate से रोकें और लंबित अनुरोधों की जांच करें।

अगले कार्यों के लिए सफल अनुरोधों को संरक्षित करें

लंबे निर्देशों को बार-बार पेस्ट करने के बजाय, सफल वर्कफ़्लो को सेव करें। Skills आपको टास्क प्रक्रियाओं को फाइलों में स्टोर करके दोबारा उपयोग करने की सुविधा देते हैं।

Anthropic दस्तावेज़: प्रक्रियाओं को .claude/skills में रखें। team-brief फोल्डर बनाएं जिसमें SKILL.md हो जिसमें हैंडओवर से पहले की जांच हो।

1---
2name: team-brief
3description: स्पेक्स से दायरा और वेरिफिकेशन व्यवस्थित करें
4disable-model-invocation: true
5---
6docs/spec.md और docs/tasks.md पढ़ें, केवल मौजूदा बदलावों को लक्षित करें।
7दायरा, निषिद्ध बदलाव, पूर्व-आवश्यकताएं, पूरा होने के मानदंड, वेरिफिकेशन व्यवस्थित करें।
8एजेंटों के लिए अनुरोध टेक्स्ट बनाएं, अनिर्णीत चीज़ों को इंसानी पुष्टि के लिए छोड़ दें।
9इस प्रक्रिया में कोड न बदलें, बाहर पब्लिश न करें, या Codex लॉन्च न करें।

Claude Code में कॉल करें:

1/team-brief डेडलाइन के हिसाब से सॉर्टिंग जोड़ना चाहता हूं

यह कस्टम कमांड है, मानक नहीं। disable-model-invocation: true सुनिश्चित करता है कि इंसान ही समय तय करे। Claude अपने आप शुरू नहीं करेगा। प्रक्रियाएं AI लॉन्च/इंस्पेक्शन को मजबूर नहीं करतीं; पहले "केवल तैयारी का पुन: उपयोग" आज़माएं।

बड़े कार्यों के लिए Dynamic Workflows

बड़े दायरे के लिए, Claude Code Dynamic workflows (मई 2026 में घोषित) प्रदान करता है, जो कई एजेंटों को स्क्रिप्ट करता है। पेड प्लान/API में उपलब्ध।

• सामान्य चैट: Claude हर बार अगला टास्क चुनता है

• Dynamic workflows: स्क्रिप्ट ब्रांच/नतीजे संग्रह, फिर से चलाने योग्य

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

Dynamic workflow बनाएं जो स्क्रीन को विभाजित करके जांच करे, अलग एजेंटों से निष्कर्षों को सत्यापित करे। पहले लक्ष्य, एजेंट संख्या, एग्जिट शर्तें प्रस्तुत करें। कोई कोड बदलाव नहीं; मंजूरी के बाद छोटे दायरे में चलाएं।

सुझाव:

• Pro प्लान में /config के ज़रिए चालू करें

• /workflows से प्रगति/उपयोग की निगरानी करें, कभी भी रोकें

• /config में स्केल (small आदि) चुनें; आधिकारिक दस्तावेज़ इन्हें अनुमान कहते हैं, सख्त सीमा नहीं। गारंटीशुदा एजेंट संख्या न मानें।

यह Claude-साइड एजेंट चलाता है। Codex अपने आप शामिल नहीं होता। पहले Claude की आंतरिक जांच/सत्यापन के लिए उपयोग करें; Codex प्रतिनिधिमंडल को अलग चरण मानें।

केस मैनेजमेंट ऐप को End-to-End चलाएं

कंपोनेंट्स को एक ऐप बिल्ड में जोड़ें। नीचे एक व्याख्यात्मक dev उदाहरण है, पूरा हुआ अनुभव रिपोर्ट नहीं; अपने एनवायरनमेंट में सत्यापित करें।

बिल्ड टारगेट

• फील्ड्स: केस का नाम, डेडलाइन, स्टेटस, नोट्स

• स्टेटस: शुरू नहीं हुआ / प्रगति में / पूरा हुआ

• केस नाम से खोजें

• डेडलाइन के हिसाब से सॉर्ट किए गए अधूरे केस देखें

प्रारंभिक अनुरोध

Claude को पास करें। मौजूदा महत्वपूर्ण प्रोजेक्ट्स को नहीं, नए प्रैक्टिस फोल्डर को लक्षित करें।

प्रैक्टिस फोल्डर में पर्सनल केस मैनेजमेंट ऐप बनाएं। पहले एनवायरनमेंट और स्पेक्स की पुष्टि करें। नाम, डेडलाइन, स्टेटस, नोट्स के लिए रजिस्ट्रेशन/एडिटिंग/सर्च/सॉर्टिंग/पर्सिस्टेंस शामिल करें। लॉगिन, सिंक, बाहरी प्रकाशन को बाहर रखें।

संभावित स्टोरेज: localStorage। कोई मल्टी-डिवाइस सिंक/बैकअप नहीं; ब्राउज़र डेटा साफ करने से रिकॉर्ड मिट जाते हैं। इसमें कीमती प्रोडक्शन जानकारी न रखें।

बेस बनाएं, साझा हिस्से परिभाषित करें

एक एजेंट बेस बनाता है। सत्यापित करें कि ऐप लॉन्च होता है, खाली स्क्रीन दिखती है। ज़रूरत पड़ने पर वर्कस्पेस अलग करने से पहले स्पेक्स/बेस को Git में कमिट करें।

• UI एजेंट को दें: डिस्प्ले फील्ड्स, एक्शन मैपिंग

• Storage एजेंट को दें: रिकॉर्ड फॉर्मेट, रीड/ऐड/अपडेट के तरीके, फेलियर हैंडलिंग

किसी को भी फील्ड नाम खुद से न बनाने दें। अगर स्टेटस फील्ड status है, तो दोनों उसी का उपयोग करें। आसानी के लिए एक तरफ इसे state में न बदलें; साझा बदलावों को एडजस्टमेंट के लिए वापस Claude के पास भेजें।

Codex को इम्प्लीमेंटेशन अनुरोध

राइट करने योग्य स्थान और ज़रूरी सबूत आउटपुट दोनों निर्दिष्ट करें।

1/codex:rescue --fresh docs/spec.md और docs/tasks.md पढ़ें। केवल सौंपा गया स्टोरेज लॉजिक और टेस्ट इम्प्लीमेंट करें। बदली गई फाइलें, कमांड, टेस्ट नतीजे, अपुष्ट चीज़ें लौटाएं। अगर स्पेक में बदलाव या दूसरे एजेंट के एडिट की ज़रूरत हो तो रुकें और रिपोर्ट करें।

इस बीच, Claude उन्हीं फाइलों को दूसरी तरफ से न बदले। पूरा होने की जांच/टेस्ट डेटा तैयारी पर ध्यान दें; नतीजे आने के बाद अगले कदम तय करें।

वेरिफिकेशन डेटा तैयार करें

• कल की डेडलाइन, "शुरू नहीं हुआ"

• आज की डेडलाइन, "प्रगति में"

• अगले हफ्ते की डेडलाइन, "पूरा हुआ"

• एक ही डेडलाइन वाले कई केस

• लंबे केस नाम

यह ठोस सॉर्टिंग/डिस्प्ले जांच को संभव बनाता है।

स्पेक्स में विस्तृत नियम दस्तावेज़ित करें:

• सॉर्टिंग: एक ही डेडलाइन के लिए रजिस्ट्रेशन क्रम

• खाली फील्ड्स: नाम/डेडलाइन ज़रूरी; नोट्स वैकल्पिक। गायब फील्ड्स दिखाएं।

• तारीखें: तारीख बदलने की धारणा परिभाषित करें। टाइमज़ोन/समय हैंडलिंग से दिन बदलने पर ऐप सुंदर दिखने के बावजूद बेकार हो जाता है।

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

इंटीग्रेट और टेस्ट करें

जब इम्प्लीमेंटेशन तैयार हो जाएं, Claude से बदलाव सूची/टेस्ट नतीजे पढ़वाएं, इंटीग्रेशन की पुष्टि करें। अगर worktrees का उपयोग कर रहे हैं, तो बदलावों को एक वेरिफिकेशन ब्रांच में इकट्ठा करें। इंटीग्रेशन के बाद व्यक्तिगत रूप से पास हुए टेस्ट फिर से चलाएं।

UI ऑटोमेशन के लिए Playwright का उपयोग करें। मौजूदा गाइड AI एजेंटों के लिए CLI/Skills प्रदान करते हैं; MCP एकमात्र तरीका नहीं है।

"AI ब्राउज़र कंट्रोल तंत्र" को "दोहराने योग्य टेस्ट" से अलग करें। री-रनेबल रजिस्ट्रेशन-टू-रीलोड फ्लो के लिए Playwright Test का उपयोग करें।

Playwright Tests बनाएं जो रजिस्ट्रेशन, खाली होने पर अस्वीकृति, सर्च, स्टेटस बदलाव, डेडलाइन सॉर्टिंग, पर्सिस्टेंस को वेरीफाई करें। लॉन्च कॉन्फ़िगरेशन/टेस्ट डेटा को अलग करें। टेस्ट पास करने के लिए ऐप व्यवहार/पूरा होने के मानदंड न बदलें।

नए प्रैक्टिस प्रोजेक्ट के लिए सेटअप:

1npm init playwright@latest

अगर पहले से इंस्टॉल है, तो जोड़ने से पहले मौजूदा लॉन्च/टेस्ट कॉन्फ़िगरेशन की जांच करें।

सुनिश्चित करें कि ब्राउज़र इंस्टॉल हैं, ऐप लॉन्च कॉन्फ़िगर करें, फिर चलाएं:

1npx playwright test
2npx playwright show-report

महत्वपूर्ण: शून्य-पाए गए या सभी-छोड़े गए टेस्ट को "पास" न मानें।

फेल होने पर, कारण अलग करें: स्टोरेज बग या टेस्ट किसी ऐसे बटन को ढूंढ रहा है जो मौजूद ही नहीं? हरा करने के लिए टेस्ट न हटाएं; मूल स्पेक्स के खिलाफ सुधार लक्ष्य तय करें।

अंतिम इंसानी सत्यापन

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

लंबे लॉग के बजाय Claude से चार चीज़ें प्राप्त करें:

• लॉन्च करने का तरीका

• वेरीफाई किए गए व्यवहार

• बची हुई सीमाएं

• अगले सुधार के उम्मीदवार

एक आइटम खुद रजिस्टर करें, रीलोड करें, पर्सिस्टेंस वेरीफाई करें। फिर पूरा हुआ चिह्नित करें।

लगातार सुधार कहां रोकें

जैसे-जैसे टीम का दायरा बढ़ता है, अंत परिभाषित करें। क्या हम एक ही बग को घुमा रहे हैं या लगातार मुद्दे हल कर रहे हैं? अस्पष्ट स्थिति आगे के निर्देशों में बाधा डालती है।

रोकने के मानदंड तय करें

"प्रति मुद्दा अधिकतम दो सुधार" को दिशानिर्देश के रूप में उपयोग करें। यह आधिकारिक सिफारिश नहीं है, बल्कि फंसने पर फैसला इंसानों को वापस देने का एक ऑपरेशनल नियम है।

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

सिर्फ निर्देश रोकने की गारंटी नहीं देते। उपयोग की निगरानी करें, /codex:cancel से अनावश्यक बैकग्राउंड अनुरोध रद्द करें। सत्यापित करें कि एजेंट वास्तव में रुक गए हैं।

लागत अलग से ट्रैक करें

ChatGPT-प्रमाणित Codex कोटा API-की प्राइसिंग से अलग होता है। समानांतर एजेंट इन्फरेंस/टूल संसाधन खर्च करते हैं।

छोटे टेक्स्ट एडिट को दोनों AI/बड़े रिव्यू से न गुज़ारें।

श्रेणीबद्ध करें:

• अकेले पूरे होने वाले टास्क

• दूसरे नज़रिए की ज़रूरत वाले टास्क

• स्वतंत्र रूप से समानांतर चलने वाले टास्क

यह प्रयास/कोटा आवंटन तय करने में मदद करता है।

पुराने मॉडल स्पेक्स से सावधान रहें

पुराने मॉडल स्पेक्स फेलियर का कारण बनते हैं। OpenAI अपडेट: ChatGPT-प्रमाणित Codex के लिए GPT-5.5 15 अक्टूबर 2026 (JST) को समाप्त हो गया। API-की ऑथ प्रभावित नहीं हुआ।

पुराने स्पेक्स/रोल फाइलों को वर्तमान में उपलब्ध मॉडल में अपडेट करें। केवल नाम न बदलें, चुनने योग्य मॉडल और स्वीकृत रीज़निंग सेटिंग्स की जांच करें।

परमिशन और Hooks जांचें

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

इस्तेमाल करने से पहले पब्लिक सैंपल्स में hooks की जाँच करें। Hooks तय समय पर अपने आप चलते हैं; सिर्फ सुविधाजनक जोड़ नहीं, बल्कि यह देखें कि वास्तव में क्या रन हो रहा है।

"जल्दी बनाया गया" को मापना

सिर्फ जनरेशन टाइम की तुलना न करें।

• आपके द्वारा दोबारा समझाने की संख्या

• इंटीग्रेशन/फिक्स करने का समय

• पूरा होने के मानदंडों (completion criteria) के मुकाबले बचे हुए डिफेक्ट्स

अगली बार भी यही बाँट काम करेगी या नहीं, यह तय करने के लिए इन बातों को शामिल करें।

छोटे साप्ताहिक टूल्स से शुरुआत करें

नॉन-इंजीनियर्स को सबसे आसान जीत वहीं मिलती है जहाँ वे खुद सही-गलत का फैसला कर सकते हैं।

• पूछताछ ट्रैकिंग (Inquiry tracking)

• ऑर्डर डेडलाइन की जाँच

• एक जैसे क्रम (sorts) के साथ CSV फॉर्मेटिंग

ऐसे उपयोगों से शुरू करें जिन्हें आसानी से बताया जा सके।

क्या पहले डेडलाइन के करीब वाले चाहिए? पूरे हो चुके हटाने हैं? इनपुट छूटने पर अलर्ट चाहिए? रोज़मर्रा की ज़रूरतें ही AI के पूरा होने के मानदंड बन जाती हैं।

पहले कोडिंग में महारत हासिल करने की ज़रूरत नहीं; शर्तों के आधार पर प्रोटोटाइप बनाएँ, इस्तेमाल करें और ठीक करें। ध्यान दें: ग्राहक डेटा सिस्टम या पब्लिक सर्विसेज़ को प्रोटोटाइप की सफलता से आगे प्रोफेशनल वैलिडेशन की ज़रूरत होती है।

शुरुआती टीम काफी है:

1. Claude स्पेक्स को व्यवस्थित करता है

1. Codex एक काम पूरा करता है

1. अलग नज़रिए से लौटे हुए रिज़ल्ट्स की जाँच करें

अगले ऐप में पूरी तरह दोबारा समझाने से बचने के लिए काम के अनुरोधों/जाँच के तरीकों को सेव कर लें।

पढ़ने के लिए शुक्रिया।

LINE Open Chat "Niku's AI Speed Strategy" मुफ्त 8-पॉइंट सेट बाँट रहा है।

• Codex/Claude Code परिचय गाइड

• कॉपी-पेस्ट निर्देश

• क्विक रेफरेंस टेबल्स

• 50 मिनी ऐप्स

• 50 इमेज प्रॉम्प्ट्स

• yomiyasu इंस्टॉलेशन

• टाइटल जनरेटर

• X मोनेटाइज़ेशन फ्लो/राशि

यहाँ पाएँ 👇 https://x.gd/VtPmw