Claude Code में Dynamic Workflows में महारत कैसे हासिल करें: 6 पैटर्न और 14 चरण जिनका उपयोग Anthropic इंजीनियर वास्तव में करते हैं

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

10 में से 9 बिल्डरों ने Dynamic Workflows को एक बार भी आज़माया नहीं है, भले ही उन्हें दो सप्ताह पहले लॉन्च किया गया हो।

वे 50 प्रॉम्प्ट लिखते हैं जब एक वर्कफ़्लो काम कर सकता है। यह 14-चरणीय रोडमैप और 6 पैटर्न है जो Anthropic के अपने इंजीनियर वास्तव में उपयोग करते हैं - माइग्रेशन, रिसर्च, सॉर्टिंग, रूट-कॉज़, ट्राइएज और इवैल के लिए।

ताज़ा AI अल्फा पाने के लिए मेरे Substack को फ़ॉलो करें:

movez.substack.com

Dynamic Workflows को Claude Code में 28 मई, 2026 को लॉन्च किया गया था। डिफ़ॉल्ट Claude Code हार्नेस कोडिंग के लिए बनाया गया है - और यह अधिकांश कोडिंग कार्यों के लिए अच्छा काम करता है। लेकिन काम के कुछ ऐसे प्रकार हैं जहाँ एक कॉन्टेक्स्ट विंडो टूटने लगती है: लंबे समय तक चलने वाले, बड़े पैमाने पर समानांतर, अत्यधिक संरचित, या प्रतिकूल।

उनके लिए, Anthropic स्वयं कस्टम हार्नेस बनाता था (रिसर्च, कोड रिव्यू, एजेंट टीम)। Dynamic Workflows के साथ, Claude उस हार्नेस को आपके लिए मौके पर ही लिखता है, जो आपके कार्य के लिए JavaScript में कस्टम-बिल्ट होता है।

14 कदम। 6 पैटर्न। पचास प्रॉम्प्ट के बजाय एक वर्कफ़्लो।

भाग 1 · मानसिक मॉडल

01. एक वर्कफ़्लो एक हार्नेस है जो Claude लिखता है।

डिफ़ॉल्ट Claude Code हार्नेस में Claude एक ही कॉन्टेक्स्ट विंडो में योजना बनाता है और निष्पादित करता है। अधिकांश कोडिंग कार्यों के लिए, यह बढ़िया है। लंबे समय तक चलने वाले, समानांतर, या प्रतिकूल कार्यों के लिए, यह टूट जाता है।

एक Dynamic Workflow, Claude द्वारा कार्य के लिए अपना स्वयं का कस्टम हार्नेस लिखना है - एक JavaScript फ़ाइल जिसमें कुछ विशेष फ़ंक्शन होते हैं जो सबएजेंट बनाते और समन्वयित करते हैं, साथ ही उनके बीच बहने वाले डेटा को संसाधित करने के लिए मानक JavaScript (Math, JSON, Array) होता है।

ये तीन चीज़ें हैं जो यह आपको देता है जो डिफ़ॉल्ट हार्नेस नहीं दे सकता:

• प्रति-एजेंट अलगाव। प्रत्येक सबएजेंट को एक केंद्रित लक्ष्य के साथ अपनी स्वयं की कॉन्टेक्स्ट विंडो मिलती है। कोई क्रॉस-संदूषण नहीं।
• प्रति-एजेंट मॉडल चयन। वर्कफ़्लो चुनता है कि प्रत्येक सबएजेंट किस मॉडल का उपयोग करता है - कठिन तर्क के लिए Opus, सस्ती खोज के लिए Haiku, बीच के लिए Sonnet।
• प्रति-एजेंट अलगाव स्तर। Worktree (पृथक git चेकआउट) या रिमोट (कोई चेकआउट नहीं)। वर्कफ़्लो तय करता है कि प्रत्येक एजेंट को क्या चाहिए।

इसे या तो Claude से सीधे पूछकर ("एक वर्कफ़्लो बनाएं जो...") या ट्रिगर शब्द ultracode के साथ शुरू करें। यदि कोई वर्कफ़्लो बाधित होता है - उपयोगकर्ता कार्रवाई, टर्मिनल बंद - तो सत्र फिर से शुरू करने पर यह वहीं से जारी रहता है जहाँ छोड़ा था।

02. वे 3 विफलता मोड जिन्हें वर्कफ़्लो हल करते हैं।

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

• एजेंटिक आलस्य - Claude एक जटिल, बहु-भागीय कार्य को पूरा करने से पहले रुक जाता है और आंशिक प्रगति के बाद इसे पूरा घोषित कर देता है। सुरक्षा समीक्षा में 50 में से 20 आइटम को संबोधित करता है और बाकी को "निपटा हुआ" कहता है।
• स्व-पक्षपात पूर्वाग्रह - जब किसी रूब्रिक के विरुद्ध सत्यापित या न्याय करने के लिए कहा जाता है तो Claude अपने स्वयं के परिणामों को प्राथमिकता देता है। दांव वाला एक सत्यापनकर्ता निष्पक्ष सत्यापनकर्ता नहीं हो सकता।
• लक्ष्य बहाव - कई चरणों में, विशेष रूप से संघनन के बाद, मूल उद्देश्य के प्रति निष्ठा का क्रमिक नुकसान। प्रत्येक सारांशीकरण चरण हानिपूर्ण है। "X मत करो" की बाधाएँ चरण 47 पर चुपचाप गायब हो जाती हैं।

एक वर्कफ़्लो तीनों को संरचनात्मक रूप से हल करता है: अलग-अलग Claude अपने स्वयं के संदर्भों, केंद्रित लक्ष्यों और पृथक स्थिति के साथ। यदि आपका कार्य इनमें से किसी भी पैटर्न से ग्रस्त है - तो यह वर्कफ़्लो तक पहुँचने का संकेत है।

03. स्थिर बनाम गतिशील वर्कफ़्लो।

हो सकता है कि आपने पहले से ही Claude Agent SDK या claude -p का उपयोग करके स्थिर वर्कफ़्लो बनाए हों - कई Claude Code इंस्टेंस को एक साथ समन्वयित करना।

• स्थिर वर्कफ़्लो सामान्य होते हैं: हर एज केस को संभालने के लिए एक बार लिखे जाते हैं। वे काम करते हैं, लेकिन उन्हें रूढ़िवादी होना पड़ता है।
• Dynamic Workflows अलग हैं: Claude इस कार्य के लिए यह वर्कफ़्लो लिखता है। हार्नेस टेलर-मेड होता है। नीचे एक ही प्रश्न को दोनों तरीकों से संभाला गया है:

डायनामिक संस्करण के जीतने का कारण खोज चरण नहीं है - दोनों खोज सकते हैं।

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

एक स्थिर हार्नेस ऐसा नहीं कर सकता क्योंकि उसे पता नहीं है कि आपका कोड मौजूद है।

04. मुख्य API। agent(), parallel(), pipeline()।

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

parallel() एक बैरियर है: यह फैलता है, फिर सब कुछ वापस आने तक प्रतीक्षा करता है। pipeline() स्ट्रीमिंग है: प्रत्येक आइटम स्वतंत्र रूप से हर चरण से होकर बहता है।

प्रश्न के आधार पर चुनें: क्या मुझे आगे कुछ भी करने से पहले सभी परिणाम चाहिए? हाँ → parallel। नहीं → pipeline (सस्ता, कुल मिलाकर तेज़)।

05. वर्गीकृत करें और कार्य करें। काम करने से पहले उसे रूट करें।

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

जब यह पैटर्न अपना मूल्य कमाता है:

• कार्य विषम है - विभिन्न उप-प्रकारों को अलग-अलग उपचार की आवश्यकता होती है।
• आप महंगे मॉडल को केवल वहीं खर्च करना चाहते हैं जहाँ जटिलता की माँग हो (सस्ते पर वर्गीकरण, फिर केवल आवश्यकता होने पर Opus पर रूट करें)।
• कार्य का अपघटन स्वयं गैर-तुच्छ है और आकार तय करने के लिए एक मॉडल से लाभान्वित होता है।

उदाहरण: "समझाएँ कि auth मॉड्यूल कैसे काम करता है।" एक वर्गीकरण सबएजेंट पहले कोडबेस पढ़ता है, जटिलता का अनुमान लगाता है, फिर वास्तविक स्पष्टीकरण कार्य को 10-फ़ाइल मॉड्यूल के लिए Sonnet या 100-फ़ाइल वाले के लिए Opus पर रूट करता है। काम को समझने के बाद, कार्य के लिए सही मॉडल तय किया गया।

06. फैन-आउट-और-संश्लेषित करें। कई छोटे कदम, एक विलयित परिणाम।

एक कार्य को कई छोटे चरणों में विभाजित करें। प्रत्येक चरण पर समानांतर में एक एजेंट चलाएँ। परिणामों को एक उत्तर में संश्लेषित करें।

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

यह पैटर्न व्यवहार में क्यों हावी है: यह एकल-संदर्भ कार्य की "एक साथ बहुत सी चीज़ें" की विफलता को हल करता है। प्रत्येक सबएजेंट केवल अपना टुकड़ा देखता है। ऑर्केस्ट्रेटर कभी भी 50 असंबंधित विवरणों से विचलित नहीं होता है।

प्रत्येक चरण अपनी स्वयं की साफ विंडो से लाभान्वित होता है ताकि वे एक-दूसरे को संदूषित न करें।

इसका उपयोग करें जब:

• आपके पास कार्य वस्तुओं की स्पष्ट रूप से गणना करने योग्य सूची हो (50 फ़ाइलें, 200 एंडपॉइंट, 100 समीक्षाएँ)।
• प्रत्येक वस्तु स्वतंत्र हो - किसी भी वस्तु को शुरू करने के लिए दूसरे के आउटपुट की आवश्यकता नहीं है।
• आप अंत में एक एकल समेकित उत्तर चाहते हैं, न कि आंशिक रिपोर्टों का ढेर।

1// फैन आउट: प्रति फ़ाइल एक एजेंट। बैरियर: सभी की प्रतीक्षा करें।
2const reviews = await parallel(
3  files.map(file => () => agent(
4    `सुरक्षा मुद्दों के लिए ${file} की समीक्षा करें`,
5    { model: "haiku", schema: IssueList }
6  ))
7)
8
9// संश्लेषित करें: एक Opus एजेंट सब कुछ मर्ज करता है।
10const report = await agent(
11  `इन समीक्षाओं को एक प्राथमिकता वाली रिपोर्ट में मर्ज करें:\n${JSON.stringify(reviews)}`,
12  { model: "opus" }
13)

07. प्रतिकूल सत्यापन

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

यह पैटर्न सबसे अधिक मायने रखता है:

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

युग्मन नियम: सत्यापनकर्ता को केवल रूब्रिक और आर्टिफैक्ट पता होना चाहिए, न कि यह कि इसे किसने बनाया। अन्यथा, प्रॉम्प्ट में संकेतों के माध्यम से स्व-पक्षपात वापस आ जाता है।

08. उत्पन्न करें और फ़िल्टर करें।

एक विषय पर कई विचार उत्पन्न करें, फिर उन्हें एक रूब्रिक या सत्यापन द्वारा फ़िल्टर करें। डुप्लिकेट हटाएँ। केवल उच्चतम गुणवत्ता वाले, परीक्षण किए गए विचार लौटाएँ।

यह पैटर्न कहाँ चमकता है:

• विचार-मंथन - 30 उत्पाद नाम, फिर एक सत्यापनकर्ता क्लिच, ट्रेडमार्क विवाद और कमजोर ध्वन्यात्मकता को मारता है। आप 3 देखते हैं।
• परिकल्पना निर्माण - एक समस्या के लिए 5 अलग-अलग दृष्टिकोण, फिर प्रत्येक को आपकी बाधाओं के विरुद्ध स्कोर किया जाता है। विजेता ने इसे अर्जित किया है।
• समाधान डिज़ाइन - एक समस्या के लिए 5 अलग-अलग दृष्टिकोण, फिर प्रत्येक को आपकी बाधाओं के विरुद्ध स्कोर किया जाता है। विजेता ने इसे अर्जित किया है।

Claude से "सबसे अच्छा उत्तर" माँगने के विपरीत। सबसे अच्छा उत्तर माँगने से Claude जल्दी प्रतिबद्ध हो जाता है। उत्पन्न करें और फ़िल्टर करें Claude को देर से प्रतिबद्ध कराता है, प्रत्येक विकल्प को चुनौती दिए जाने के बाद।

09. टूर्नामेंट। युग्मवार तुलना पूर्ण स्कोरिंग से बेहतर है।

काम को विभाजित करने के बजाय, एजेंटों को उस पर प्रतिस्पर्धा करने दें। N एजेंटों को स्पॉन करें जो प्रत्येक विभिन्न दृष्टिकोणों का उपयोग करके एक ही कार्य का प्रयास करते हैं, फिर परिणामों को युग्मवार तरीके से आंकें जब तक कि एक न जीत जाए।

तुलनात्मक निर्णय पूर्ण स्कोरिंग की तुलना में अधिक विश्वसनीय है - विशेष रूप से स्वाद-आधारित कार्यों के लिए।

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

ब्रैकेट स्वयं नियतात्मक लूप कोड में रहता है, संदर्भ में नहीं। प्रत्येक तुलना तेज़, निष्पक्ष और पृथक होती है। यही विचार स्वाद-आधारित रैंकिंग के लिए काम करता है: डिज़ाइन विकल्प, उम्मीदवार चयन, सामग्री प्राथमिकता।

10. तब तक लूप करें जब तक काम न हो जाए।

अज्ञात मात्रा में काम वाले कार्यों के लिए, एक निश्चित संख्या में पास चलाने के बजाय, एक रुकने की स्थिति पूरी होने तक एजेंटों को स्पॉन करते रहें - कोई नई खोज नहीं, लॉग में कोई और त्रुटि नहीं, सिद्धांत सत्यापित -।

यह पैटर्न "तब तक जारी रखें जब तक यह वास्तव में पूरा न हो जाए" का उत्तर है:

• अस्थिर परीक्षण डिबगिंग - पुनरुत्पादन करें, सिद्धांत बनाएँ, उनका परीक्षण करें, जब तक एक सिद्धांत टिक न जाए।
• बग हंटिंग - बग ढूँढते रहें जब तक कि एक पूर्ण पास शून्य न लौटाए।
• पैटर्न के लिए खनन - क्लस्टर करें, नियमों की पहचान करें, जब तक कोई नया क्लस्टर दिखाई न दे।

इस पैटर्न को /goal के साथ जोड़कर एक कठिन पूर्णता आवश्यकता निर्धारित करें ("जब तक एक सिद्धांत काम न करे तब तक मत रुकें") और /loop के साथ यदि आप चाहते हैं कि संपूर्ण वर्कफ़्लो स्वयं एक आवर्ती शेड्यूल पर चले।

ब्रैकेट और रुकने की स्थिति कोड में रहती है; केवल सक्रिय पुनरावृत्ति संदर्भ में रहती है।

11. वास्तविक उपयोग के मामलों के लिए पैटर्न बनाएँ। एक वर्कफ़्लो, कई पैटर्न।

6 पैटर्न शायद ही कभी अकेले दिखाई देते हैं। एक वास्तविक वर्कफ़्लो 2-4 को जोड़ता है। नीचे दिया गया मैट्रिक्स Anthropic लॉन्च लेखन के प्रत्येक उपयोग के मामले को उन पैटर्न के साथ जोड़ता है जिनका वह उपयोग करता है:

• माइग्रेशन और रीफैक्टर। फैन-आउट (एक वर्कट्री में प्रति कॉलसाइट/असफल परीक्षण एक एजेंट) → प्रतिकूल सत्यापन (एक अलग एजेंट प्रत्येक फिक्स की समीक्षा करता है) → तब तक लूप करें जब तक काम न हो जाए। यह वह पैटर्न है जिसका उपयोग Anthropic ने Bun को Zig से Rust में फिर से लिखने के लिए किया था।
• गहन शोध (/deep-research कौशल)। फैन-आउट (समानांतर वेब खोज) → प्रतिकूल सत्यापन (प्रत्येक दावा स्वतंत्र रूप से सत्यापित) → संश्लेषित करें (एक उद्धृत रिपोर्ट)।
• ड्राफ्ट का गहन सत्यापन। सभी तथ्यात्मक दावों की पहचान करें (एक एजेंट) → फैन-आउट (प्रति दावा एक सत्यापनकर्ता, प्रत्येक एजेंट स्रोत के विरुद्ध जाँच करता है) → मेटा-सत्यापनकर्ता (जाँचता है कि सत्यापनकर्ता के स्रोत उच्च गुणवत्ता वाले हैं)।
• 1,000+ आइटम सॉर्ट करना। टूर्नामेंट (चरण 5-9) - युग्मवार तुलना, बकेट-रैंक, या ब्रैकेट। तुलनात्मक निर्णय, कभी भी पूर्ण स्कोरिंग नहीं।
• मेमोरी और नियम पालन। प्रति नियम सत्यापनकर्ता (फैन-आउट) → संशयवादी व्यक्तित्व झूठी सकारात्मकता से बचने के लिए स्वयं नियमों की समीक्षा करता है।
• मूल कारण जाँच। असंबद्ध साक्ष्य से सिद्धांत उत्पन्न करें (विभिन्न एजेंट लॉग, फ़ाइलें, डेटा पढ़ते हैं) → प्रत्येक सिद्धांत के लिए सत्यापनकर्ताओं और खंडनकर्ताओं का पैनल → तब तक लूप करें जब तक एक जीवित न रह जाए।
• बड़े पैमाने पर ट्राइएज। वर्गीकृत करें और कार्य करें → मौजूदा टिकटों के विरुद्ध डुप्लिकेट हटाएँ → या तो फिक्स का प्रयास करें या एस्केलेट करें। निरंतर ट्राइएज के लिए /loop के साथ जोड़ें।
• अन्वेषण और स्वाद (डिज़ाइन, नामकरण, UI विकल्प)। उत्पन्न करें और फ़िल्टर करें (5-20 विकल्प) → एक रूब्रिक के साथ टूर्नामेंट → रैंक या चुनें।
• हल्के इवैल। उम्मीदवार को वर्कट्री में चलाएँ → तुलना एजेंट रूब्रिक के विरुद्ध ग्रेड करते हैं → परिष्कृत करें और फिर से ग्रेड करें। ग्रेडिंग के लिए टूर्नामेंट के समान आकार, लेकिन रैंकिंग के लिए नहीं।

इन्हें आंतरिक बनाने का सही तरीका: पहचानें कि आपका वर्तमान कार्य किस विफलता मोड के तहत विफल हो रहा है, फिर वह पैटर्न चुनें जो संरचनात्मक रूप से इसे रोकता है।

बहाव → फैन-आउट। स्व-पक्षपात → प्रतिकूल सत्यापन। खुला अंत → तब तक लूप करें जब तक काम न हो जाए। स्कोर करना कठिन → टूर्नामेंट।

12. /goal, /loop और टोकन बजट के साथ जोड़ें।

वर्कफ़्लो महंगे हो सकते हैं। तीन नियंत्रण उन्हें "अच्छे लेकिन महंगे" से "एक उपकरण जिसे मैं बिना निगरानी के चलाता हूँ" में बदल देते हैं।

• /goal एक कठिन पूर्णता आवश्यकता निर्धारित करता है। इसे लूप पैटर्न के साथ जोड़ें: "जब तक एक सिद्धांत काम न करे तब तक मत रुकें।" /goal के बिना, एक वर्कफ़्लो एक नरम पूर्णता बिंदु पर रुक जाता है। /goal के साथ, यह तब तक दोहराता है जब तक वास्तविक अंतिम स्थिति पूरी न हो जाए।
• /loop संपूर्ण वर्कफ़्लो को एक आवर्ती शेड्यूल पर चलाता है। इसका उपयोग उन वर्कफ़्लो के लिए करें जिन्हें आप लगातार चलाना चाहते हैं - ट्राइएज, साप्ताहिक शोध अपडेट, आवर्ती सत्यापन।
• स्पष्ट टोकन बजट। Claude को प्रॉम्प्ट में बताएँ: "10k टोकन का उपयोग करें।" यह वर्कफ़्लो रन पर एक सीमा निर्धारित करता है। एक सीमा के बिना, एक महत्वाकांक्षी वर्कफ़्लो आपके अपेक्षित टोकन से 5–10 गुना तक बढ़ सकता है।

1> ultracode इस धारणा की त्वरित प्रतिकूल समीक्षा:
2  "Postgres पर जाने से हमारा शार्ड रीबैलेंसिंग खत्म हो जाता है।"
3  5k टोकन का उपयोग करें। /goal तब तक मत रुकें जब तक आपके पास
4  या तो एक काउंटरएग्ज़ाम्पल या तीन स्वतंत्र पुष्टिकरण न हों।

Claude Code टीम को सीधे उद्धृत करते हुए: "सर्वोत्तम अभ्यास अभी भी विकसित हो रहे हैं। Dynamic workflows अक्सर अधिक टोकन का उपयोग करते हैं, इसलिए ध्यान से सोचें कि उनका उपयोग कब और कैसे करना है।" अधिकांश पारंपरिक कोडिंग कार्यों को 5 समीक्षकों के पैनल की आवश्यकता नहीं होती है।

अपने आप से पूछें: क्या इस कार्य को वास्तव में अधिक कंप्यूट की आवश्यकता है? यदि एक सामान्य Claude Code सत्र इसे पाँच मिनट में पूरा कर लेता, तो आपको वर्कफ़्लो की आवश्यकता नहीं है।

13. अविश्वसनीय इनपुट के लिए क्वारंटाइन पैटर्न का उपयोग करें।

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

समाधान: क्वारंटाइन। उन एजेंटों को रोकें जो अविश्वसनीय सामग्री पढ़ते हैं, किसी भी उच्च-विशेषाधिकार वाली कार्रवाई करने से। अलग एजेंट, कच्ची सामग्री के संपर्क में नहीं, कार्य करते हैं।

कोई भी वर्कफ़्लो जो उपयोगकर्ता-सबमिट की गई सामग्री (सहायता टिकट, बग रिपोर्ट, ग्राहक प्रतिक्रिया, सोशल मीडिया) को संसाधित करता है, सार्वजनिक वेब पेजों को स्क्रैप करता है, या किसी तृतीय-पक्ष API से आउटपुट के विरुद्ध चलता है।

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

14. वर्कफ़्लो सहेजें। उन्हें Skills के रूप में शिप करें।

एक बार वर्कफ़्लो काम कर जाए, तो इसे सहेजें: वर्कफ़्लो मेनू में s दबाएँ। सहेजे गए वर्कफ़्लो ~/.claude/workflows पर जाते हैं। वहाँ से आपके पास दो रास्ते हैं:

• इसे स्थानीय रखें - इसे अपनी परियोजनाओं में पुनः उपयोग करें।
• इसे एक Skill के रूप में शिप करें - JavaScript फ़ाइल को एक Skill फ़ोल्डर के अंदर बंडल करें, इसे SKILL.md में संदर्भित करें, और जो कोई भी Skill इंस्टॉल करता है वही वर्कफ़्लो चलाता है।

एक व्यावहारिक बारीकियाँ जानने लायक है: जब आप किसी वर्कफ़्लो को Skill में पैकेज करते हैं, तो Claude को प्रॉम्प्ट करें कि वर्कफ़्लो को एक टेम्पलेट के रूप में मानें, न कि शब्दशः चलाने के लिए एक स्क्रिप्ट के रूप में।

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

वे गलतियाँ जो वर्कफ़्लो पर टोकन बर्बाद करती हैं

• जब एक सामान्य Claude Code सत्र काम करेगा तब वर्कफ़्लो तक पहुँचना। अधिकांश पारंपरिक कोडिंग कार्यों को 5 समीक्षकों के पैनल की आवश्यकता नहीं होती है।
• कोई टोकन बजट नहीं। महत्वाकांक्षी वर्कफ़्लो बिना स्पष्ट सीमा के आपकी अपेक्षा से 5–10 गुना तक बढ़ जाते हैं।
• एक एजेंट काम और सत्यापन दोनों कर रहा है। स्व-पक्षपात पूर्वाग्रह सत्यापनकर्ता को कार्यकर्ता का पक्ष लेने के लिए प्रेरित करता है। उन्हें अलग होना चाहिए।
• parallel() और pipeline() को विनिमेय मानना। बैरियर मायने रखता है - parallel सभी की प्रतीक्षा करता है, pipeline स्ट्रीम करता है।
• लूप पैटर्न पर /goal छोड़ना। वर्कफ़्लो पहले नरम पूर्णता बिंदु पर जल्दी रुक जाता है। /goal कठिन पूर्णता को बाध्य करता है।
• अविश्वसनीय सामग्री को अभिनेता तक पहुँचने देना। एक बार जब आप उपयोगकर्ता-सबमिट की गई किसी भी चीज़ को संसाधित करते हैं तो क्वारंटाइन वैकल्पिक नहीं है।
• पूर्ण स्कोर के साथ सॉर्ट करना। तुलनात्मक निर्णय अधिक विश्वसनीय है। टूर्नामेंट का उपयोग करें।
• काम करने वाले वर्कफ़्लो को कभी सहेजना नहीं। हर हफ्ते एक ही आकार को फिर से प्रॉम्प्ट करना। s से सहेजें, Skill के रूप में शिप करें।

निष्कर्ष:

https://x.com/_catwu/status/2060054180379689074