30 दिनों में AI में महारत कैसे हासिल करें: सटीक रोडमैप

अधिकांश लोग दो साल से AI का उपयोग कर रहे हैं और फिर भी बॉक्स में वैसे ही टाइप करते हैं जैसे वे Google कर रहे हों। एक अस्पष्ट पंक्ति, उत्तर पर एक उचक्का, टैब बंद कर दें। वे "AI का उपयोग" उसी तरह करते हैं जैसे आप उस ट्रेडमिल का "उपयोग" करते हैं जिस पर आप शर्ट टांगते हैं।

यहाँ असुविधाजनक हिस्सा है: जो लोग इन मॉडलों से 10x प्राप्त करते हैं और जिन्हें कुछ नहीं मिलता, उनके बीच का अंतर प्रतिभा नहीं है, और यह कोई गुप्त मॉडल नहीं है। यह एक प्रणाली (सिस्टम) है। 10x वाली भीड़ समान मुट्ठी भर चालों का पुन: उपयोग करती है — हर प्रॉम्प्ट, हर दिन — जब तक कि चालें मांसपेशियों की स्मृति (मसल मेमोरी) न बन जाएँ।

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

यह वह प्रणाली है, जो 30 दिनों में संकुचित है। चार सप्ताह, बारह क्रमांकित नाटक (प्लेज़), प्रत्येक का अंत एक ऐसी चीज़ में होता है जो आप आज करते हैं। कॉपी करने योग्य प्रॉम्प्ट। वास्तविक, चलाने योग्य Python (एंथ्रोपिक SDK, v0.109.1 के विरुद्ध सत्यापित)। कोई सिद्धांत नहीं जिस पर आप आज रात तक कार्य न कर सकें।

सांस्कृतिक शुरुआती बंदूक आंद्रेज कार्पथी की अब प्रसिद्ध पंक्ति "वाइब कोडिंग" के बारे में थी — "आप पूरी तरह से वाइब्स के आगे झुक जाते हैं... और भूल जाते हैं कि कोड मौजूद भी है।" यह वाइब है। इसके नीचे का अनुशासन है जो वाइब को वास्तव में शिप करता है।

भाग 1 · सप्ताह 1 — मानसिक मॉडल और पहली जीत (दिन 1–7)

इस सप्ताह का लक्ष्य ज्ञान नहीं है। यह एक जीत है। दिन 7 तक आपको कम से कम एक वास्तविक कार्य किसी मॉडल को सौंप देना चाहिए और महसूस करना चाहिए कि समय आपके पास वापस आ गया है। बाकी सब कुछ उस भावना पर बनता है।

01. आज ही AI के साथ एक वास्तविक कार्य शिप करें।

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

शुरुआती लोगों की गलती एक विषय टाइप करना है ("ऑनबोर्डिंग के बारे में लिखें") एक संक्षिप्त विवरण (ब्रिफ) के बजाय। मॉडल को पहले दिन एक तेज नए कर्मचारी की तरह समझें: इसमें कौशल हैं लेकिन आपके संदर्भ (कॉन्टेक्स्ट) में से कोई नहीं। इसे एक भूमिका, कार्य, संदर्भ और सटीक आउटपुट दें जो आप चाहते हैं।

इसका उपयोग करें जब: आपके पास कोई भी कार्य हो जो आप सामान्य रूप से एक घंटे के भीतर अकेले करेंगे — लेखन, सारांश, पुन: स्वरूपण, विचार-मंथन, योजना बनाना।

1आप मेरे <भूमिका, जैसे "सीधा-सादा कार्यकारी संपादक"> हैं।
2कार्य: <एक वाक्य में एक ठोस कार्य>।
3संदर्भ: <2-3 पंक्तियाँ जो मॉडल नहीं जान सकता — दर्शक, लक्ष्य, बाधाएँ>।
4आउटपुट: <सटीक प्रारूप — लंबाई, संरचना, लहजा>।
5अगर कुछ भी अस्पष्ट है, तो अनुमान लगाने के बजाय पहले मुझसे पूछें।

वह अंतिम पंक्ति चीट कोड है। यह एक बार के अनुमान को एक छोटी बातचीत में बदल देती है, और बातचीत लगभग हमेशा एकालाप को हरा देती है।

अभी यह करें: अपनी प्लेट में से एक कार्य चुनें, चार स्लॉट भरें, इसे चलाएँ। प्रॉम्प्ट को रखें — आप पूरे महीने इस स्केलेटन का पुन: उपयोग करेंगे।

02. एक प्रॉम्प्ट की शारीरिक रचना सीखें जो काम करता है।

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

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

इसका उपयोग करें जब: कोई उत्तर सामान्य, ऑफ-टोन, या तकनीकी रूप से सही लेकिन बेकार वापस आता है। दस में से नौ बार, तीन भागों में से एक गायब था।

1# कमज़ोर (विषय, संक्षिप्त विवरण नहीं)
2हमारी नई सुविधा के बारे में लिखें।
3
4# मजबूत (स्पष्टता + संदर्भ + प्रारूप)
5हमारी नई "फोकस मोड" के लिए 120-शब्द का उत्पाद घोषणा लिखें।
6दर्शक: मौजूदा उपयोगकर्ता जो ऐप को शोरगुल वाला पाते हैं।
7लक्ष्य: उन्हें इस सप्ताह इसे एक बार आज़माने के लिए प्रेरित करें।
8लहजा: शांत, आत्मविश्वासी, शून्य प्रचार।
9प्रारूप: 1 छोटा पैराग्राफ + एक-पंक्ति वाला CTA।

अभी यह करें: कल के कमज़ोर प्रॉम्प्ट को लें और इसे सभी तीन भागों के साथ लेबल करके फिर से लिखें। दोनों को चलाएँ। अंतर देखें।

03. 6 मुख्य तकनीकें चुराएँ — और कोड की एक पंक्ति।

ये छह हर गंभीर प्रॉम्प्ट-इंजीनियरिंग गाइड में दिखाई देते हैं क्योंकि ये काम करते रहते हैं: (1) स्पष्ट और प्रत्यक्ष रहें, (2) संदर्भ/प्रेरणा जोड़ें, (3) उदाहरण दें, (4) XML-शैली टैग के साथ संरचित करें, (5) एक भूमिका निर्दिष्ट करें, (6) उत्तर देने से पहले सोचने को कहें। आप सप्ताह 2 में प्रत्येक का अभ्यास करेंगे — यह नक्शा है।

दो तुरंत अपने हाथों में तार लगाने लायक हैं: भूमिकाएँ और टैग। सिस्टम इंस्ट्रक्शन में एक भूमिका पूरी बातचीत के लहजे और निर्णय को निर्देशित करती है; यहां तक कि एक वाक्य भी सुई को हिलाता है। <context> और <examples> जैसे टैग मॉडल को आपके निर्देशों को आपके डेटा के साथ भ्रमित करने से रोकते हैं। यहाँ भूमिका तकनीक वास्तविक, चलाने योग्य कोड के रूप में है — API का आपका पहला स्वाद जिसमें आप सप्ताह 3 तक रहेंगे।

इसका उपयोग करें जब: आप कई कॉलों में लगातार व्यवहार चाहते हैं (भूमिका) या आप निर्देशों को गंदे इनपुट के साथ मिला रहे हैं (टैग)।

1import anthropic
2
3client = anthropic.Anthropic()  # आपके वातावरण से ANTHROPIC_API_KEY पढ़ता है
4
5msg = client.messages.create(
6    model="claude-opus-4-8",
7    max_tokens=1024,
8    system="आप एक वरिष्ठ कॉपी संपादक हैं। आप फालतू सामग्री काटते हैं और लेखक की आवाज़ बनाए रखते हैं।",  # भूमिका
9    messages=[
10        {"role": "user", "content": "इस पैराग्राफ को संपादित करें, फिर सूची बनाएँ कि आपने क्या बदला:\n\n<draft>...</draft>"}
11    ],
12)
13print(msg.content[0].text)

अभी यह करें: एक प्रॉम्प्ट को एक स्पष्ट भूमिका और इनपुट के चारों ओर <tags> के साथ फिर से लिखें। आपने अब 6 में से 2 का उपयोग किया है — सप्ताह 2 शेष सेट को पूरा करता है।

भाग 2 · सप्ताह 2 — वास्तविक आउटपुट के लिए प्रॉम्प्ट इंजीनियरिंग (दिन 8–14)

इस सप्ताह आप "यह लगभग काम करता है" को "यह हर बार काम करता है" में बदलते हैं। एक ही कार्य, एक ही आकार, एक ही गुणवत्ता — मांग पर। वह विश्वसनीयता ही है जो आपको सप्ताह 3 में स्वचालित करने देती है।

04. मल्टीशॉट उदाहरणों के साथ लहजा और प्रारूप लॉक करें।

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

यह दोहराए जाने वाले काम के लिए सबसे बड़ी गुणवत्ता वाली छलांग है — वर्गीकरण, निष्कर्षण, स्वरूपण, पुनर्लेखन। यदि आप एक ही तरह का कार्य सप्ताह में दो बार से अधिक करते हैं, तो यह उदाहरणों का हकदार है।

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

1प्रत्येक सहायता टिकट को बिल्कुल एक के रूप में वर्गीकृत करें: बग | बिलिंग | फीचर।
2
3<examples>
4<example>
5टिकट: "इस महीने मुझसे दो बार शुल्क लिया गया।"
6श्रेणी: बिलिंग
7</example>
8<example>
9टिकट: "एक्सपोर्ट बटन Safari पर कुछ नहीं करता।"
10श्रेणी: बग
11</example>
12<example>
13टिकट: "कृपया एक डार्क मोड जोड़ें।"
14श्रेणी: फीचर
15</example>
16</examples>
17
18टिकट: "जब मैं एक PDF अपलोड करता हूँ तो ऐप क्रैश हो जाता है।"
19श्रेणी:

अभी यह करें: एक आवर्ती कार्य लें, <example> टैग में 3 विविध उदाहरण लिखें, और आउटपुट को आकार में आते हुए देखें।

05. मॉडल को उत्तर देने से पहले सोचने दें।

तर्क, विश्लेषण, गणित, योजना, मुश्किल निर्णय वाली किसी भी चीज़ के लिए, सबसे बुरी बात जो आप कर सकते हैं वह है तुरंत उत्तर की मांग करना। इसे पहले सोचने की गुंजाइश दें। आप या तो नए मॉडलों को अनुकूली रूप से सोचने दे सकते हैं, या, सादे चैट में, इसे मजबूर करें: एक <thinking> ब्लॉक में चरण-दर-चरण तर्क माँगें, फिर एक <answer> ब्लॉक में एक संक्षिप्त अंतिम उत्तर। दोनों को अलग करने का मतलब है कि आपको बिना टेक्स्ट की दीवार के तर्क का लाभ मिलता है।

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

इसका उपयोग करें जब: कार्य में एक से अधिक चरण हों, एक सही उत्तर हो जिसके बारे में आप गलत हो सकते हैं, या तौलने के लिए ट्रेड-ऑफ हों।

1प्रश्न: <एक वास्तविक ट्रेड-ऑफ वाला प्रश्न>
2
3पहले, <thinking> टैग के अंदर तर्क करें: सूचीबद्ध करें कि आप क्या जानते हैं, क्या गायब है,
4और उनके ट्रेड-ऑफ के साथ दो उम्मीदवार उत्तर।
5फिर <answer> टैग के अंदर अपना निर्णय दें — अधिकतम 3 वाक्य।
6समाप्त करने से पहले, सत्यापित करें कि आपका उत्तर ऊपर किसी भी चीज़ का खंडन नहीं करता है।

अभी यह करें: एक निर्णय लें जिस पर आप विचार कर रहे हैं, इसे सोच/उत्तर विभाजन के माध्यम से चलाएँ, और <thinking> पढ़ें — वहीं पर मूल्य छिपा है।

06. एक पुन: प्रयोज्य प्रॉम्प्ट लाइब्रेरी बनाएँ।

अब तक आपने एक दर्जन अच्छे प्रॉम्प्ट लिखे हैं और उनमें से आधे को चैट इतिहास में खो दिया है। रुकिए। पेशेवर प्रॉम्प्ट को फिर से नहीं लिखते — वे टेम्पलेट भरते हैं। अपने सबसे अच्छे प्रॉम्प्ट को बदलने वाले भागों के लिए {variables} के साथ एक ही फ़ाइल में खींचें, और आपने एक बार की चतुराई को बुनियादी ढाँचे में बदल दिया है।

यह पूरे 30 दिनों का धुरी है: यह वह क्षण है जब आपके प्रॉम्प्ट डिस्पोजेबल होना बंद कर देते हैं और संयोजित होने लगते हैं। शुरू करने के लिए आपको बस एक सादा Python dict और str.format चाहिए — कोई फ्रेमवर्क नहीं, कोई निर्भरता नहीं।

इसका उपयोग करें जब: आपने एक समान प्रॉम्प्ट तीन बार चलाया हो। तीसरी बार, इसे टेम्पलेटाइज़ करें।

1# prompt_library.py — पुन: प्रयोज्य बुनियादी ढाँचे के रूप में आपके प्रॉम्प्ट
2TEMPLATES = {
3    "summarize": (
4        "आप एक {role} हैं।\n"
5        "नीचे दिए गए पाठ का {audience} के लिए सारांश दें।\n"
6        "प्रारूप: {fmt}।\n\n"
7        "<text>\n{text}\n</text>"
8    ),
9}
10
11def build(name: str, **kwargs) -> str:
12    return TEMPLATES[name].format(**kwargs)
13
14prompt = build(
15    "summarize",
16    role="तकनीकी लेखक",
17    audience="गैर-तकनीकी उपयोगकर्ता",
18    fmt="3 बुलेट, प्रत्येक अधिकतम 15 शब्द",
19    text="...यहाँ रिलीज़ नोट्स चिपकाएँ...",
20)
21print(prompt)  # इसे सीधे client.messages.create(...) में फीड करें

अभी यह करें: prompt_library.py बनाएँ, अपने 3 सबसे अच्छे प्रॉम्प्ट को वेरिएबल्स के साथ टेम्पलेट के रूप में इसमें ले जाएँ। यह फ़ाइल पूरे महीने बढ़ती रहती है।

भाग 3 · सप्ताह 3 — API के साथ स्वचालित करें (दिन 15–21)

चैट वह जगह है जहाँ आप सीखते हैं। API वह जगह है जहाँ आप पैमाना बनाते हैं। इस सप्ताह आप एक-एक करके कार्य करने से लेकर उन्हें सैकड़ों की संख्या में, एक शेड्यूल पर, जब आप सोते हैं, चलाने तक की ओर बढ़ते हैं।

07. चैट से API की ओर बढ़ें।

API बस आपके चैट प्रॉम्प्ट हैं एक फंक्शन में जिसे आप कॉल कर सकते हैं। यदि आप एक प्रॉम्प्ट लिख सकते हैं, तो आप यह लिख सकते हैं — यह दस पंक्तियाँ हैं। अपनी कुंजी को एक पर्यावरण चर के रूप में सेट करें (इसे कोड में कभी पेस्ट न करें), कॉल को एक फंक्शन में लपेटें, और आपके पास एक पुन: प्रयोज्य AI कमांड है जिसे आप किसी भी स्क्रिप्ट में डाल सकते हैं।

साइमन विलिसन, जिन्होंने व्यावहारिक LLM उपयोग का लगभग किसी भी अन्य की तुलना में बेहतर दस्तावेजीकरण किया है, यह बताते हैं कि लाभ विदेशी सेटअप में नहीं है — यह मॉडलों को उन छोटे उपकरणों में तार करने में है जिनका आप पहले से उपयोग करते हैं। यह फंक्शन वह तार है।

इसका उपयोग करें जब: आप चाहते हैं कि एक ही प्रॉम्प्ट हर जगह उपलब्ध हो — स्क्रिप्ट में, क्रॉन जॉब में, अन्य प्रोग्राम में — न कि केवल एक ब्राउज़र टैब में।

1import os
2import anthropic
3
4client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
5
6def ask(prompt: str) -> str:
7    msg = client.messages.create(
8        model="claude-opus-4-8",
9        max_tokens=1024,
10        messages=[{"role": "user", "content": prompt}],
11    )
12    return msg.content[0].text
13
14if __name__ == "__main__":
15    print(ask("मुझे एक उत्पाद लॉन्च ईमेल के लिए 5 प्रभावी विषय पंक्तियाँ दें।"))

अभी यह करें: SDK इंस्टॉल करें (pip install anthropic), ANTHROPIC_API_KEY सेट करें, और इस फ़ाइल को चलाएँ। पहली सफल API कॉल = सप्ताह 3 अनलॉक।

08. एक दैनिक काम को स्क्रिप्ट में बदलें।

यहाँ वह जगह है जहाँ समय वास्तव में वापस आता है। कोई भी कार्य जो आप चीजों के एक फ़ोल्डर पर करते हैं — इन 50 ट्रांसक्रिप्ट का सारांश दें, इन 200 टिकटों को टैग करें, इन 30 उत्पाद विवरणों को फिर से लिखें — एक लूप है। एकल-आइटम संस्करण एक बार लिखें, इसे एक फ़ोल्डर पर इंगित करें, चले जाएँ। बल्क काम के लिए एक सस्ता, तेज़ मॉडल का उपयोग करें; आपको एक मेमो का सारांश देने के लिए अपने सबसे शक्तिशाली मॉडल की आवश्यकता नहीं है।

इसका उपयोग करें जब: आप खुद को बार-बार हाथ से एक ही AI कार्य करते हुए पकड़ते हैं। वह पुनरावृत्ति एक स्क्रिप्ट है जो आपने अभी तक नहीं लिखी है।

1import pathlib
2import anthropic
3
4client = anthropic.Anthropic()
5INBOX = pathlib.Path("./inbox")        # यहाँ .txt फ़ाइलें ड्रॉप करें
6OUT = pathlib.Path("./summaries")
7OUT.mkdir(exist_ok=True)
8
9def summarize(text: str) -> str:
10    msg = client.messages.create(
11        model="claude-haiku-4-5",      # सस्ता + तेज़: बल्क काम के लिए सही उपकरण
12        max_tokens=300,
13        system="3 ठोस बुलेट पॉइंट में सारांश दें। कोई फालतू सामग्री नहीं।",
14        messages=[{"role": "user", "content": text}],
15    )
16    return msg.content[0].text
17
18for f in INBOX.glob("*.txt"):
19    (OUT / f"{f.stem}.md").write_text(summarize(f.read_text(encoding="utf-8")), encoding="utf-8")
20    print("सारांशित किया गया:", f.name)

अभी यह करें: एक बैच काम खोजें, फ़ाइलों को ./inbox में ड्रॉप करें, लूप चलाएँ। आपने अभी एक मिनट में एक घंटे का काम किया है।

09. कैशिंग के साथ लागत और विलंबता कम करें।

एक बार जब आप वास्तविक वॉल्यूम चला रहे हों, तो दो चीजें मायने रखने लगती हैं: गति और बिल। सबसे बड़ा लीवर प्रॉम्प्ट कैशिंग है। यदि हर कॉल एक लंबा, अपरिवर्तनीय उपसर्ग साझा करता है — एक स्टाइल गाइड, एक नॉलेज बेस, एक बड़ा सिस्टम इंस्ट्रक्शन — तो आप इसे हर बार फिर से पढ़ने के लिए भुगतान कर रहे हैं। इसे cache_control के साथ चिह्नित करें और मॉडल कैश किए गए संस्करण का पुन: उपयोग करता है: एक कैश रीड की लागत सामान्य इनपुट मूल्य का लगभग 10% होती है, बनाम +25% पर एक बार की राइट। बैच जॉब के लिए जो एक उपसर्ग साझा करते हैं, Batch API शीर्ष पर एक और ~50% छूट जोड़ता है।

इसका उपयोग करें जब: कई कॉल संदर्भ का एक बड़ा, स्थिर हिस्सा साझा करते हैं (क्लासिक मामला: एक लंबा सिस्टम प्रॉम्प्ट जो पूरे काम में पुन: उपयोग किया जाता है)।

1import anthropic
2
3client = anthropic.Anthropic()
4STYLE_GUIDE = open("style_guide.md").read()   # लंबा, हर कॉल पर समान
5
6msg = client.messages.create(
7    model="claude-opus-4-8",
8    max_tokens=1024,
9    system=[
10        {
11            "type": "text",
12            "text": STYLE_GUIDE,
13            "cache_control": {"type": "ephemeral"},  # इस बड़े उपसर्ग को कैश करें
14        }
15    ],
16    messages=[{"role": "user", "content": "गाइड से मेल खाने के लिए इस ईमेल को फिर से लिखें:\n\n..."}],
17)
18print(msg.usage)  # पहली कॉल के बाद cache_read_input_tokens को बढ़ते देखें

अभी यह करें: एक बड़े दोहराए गए उपसर्ग के साथ एक प्रॉम्प्ट खोजें, इसे cache_control ब्लॉक में लपेटें, और इसे दो बार चलाएँ। msg.usage प्रिंट करें और कैश की गई रीड को प्रभावी होते देखें।

भाग 4 · सप्ताह 4 — उपकरण, डेटा और शिपिंग (दिन 22–30)

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

10. मॉडल को उपकरण दें (फंक्शन कॉलिंग)।

एक मॉडल अकेला केवल टेक्स्ट उत्पन्न कर सकता है। इसे उपकरण दें और यह कार्रवाई कर सकता है — आपका कैलेंडर देखें, एक API को हिट करें, एक गणना चलाएँ। आप प्रत्येक उपकरण का वर्णन एक नाम, एक विवरण और इसके इनपुट के JSON स्कीमा के साथ करते हैं; मॉडल तय करता है कि इसे कब कॉल करना है और आपको निष्पादित करने के लिए संरचित तर्क सौंपता है। यह हर "AI एजेंट" के नीचे की नींव है जिसके बारे में आपने सुना है।

इसका उपयोग करें जब: कार्य को लाइव डेटा या एक ऐसी कार्रवाई की आवश्यकता होती है जो मॉडल अकेले टेक्स्ट से नहीं कर सकता (कुछ भी "देखो," "लाओ," "गणना करो," या "भेजो" के साथ)।

1import anthropic
2
3client = anthropic.Anthropic()
4
5tools = [
6    {
7        "name": "get_calendar_events",
8        "description": "किसी दी गई तारीख के लिए उपयोगकर्ता के ईवेंट लौटाएँ।",
9        "input_schema": {
10            "type": "object",
11            "properties": {
12                "date": {"type": "string", "description": "तारीख YYYY-MM-DD के रूप में"}
13            },
14            "required": ["date"],
15        },
16    }
17]
18
19msg = client.messages.create(
20    model="claude-opus-4-8",
21    max_tokens=1024,
22    tools=tools,
23    messages=[{"role": "user", "content": "अगले सोमवार को मेरे कैलेंडर पर क्या है?"}],
24)
25
26for block in msg.content:
27    if block.type == "tool_use":
28        print("मॉडल कॉल करना चाहता है:", block.name, "के साथ", block.input)
29        # अब आप get_calendar_events(**block.input) चलाएँ और परिणाम वापस भेजें

अभी यह करें: एक ऐसी चीज़ के लिए एक उपकरण परिभाषित करें जिसका आप वास्तव में उपयोग करते हैं (कैलेंडर, मौसम, एक खोज), और मॉडल को एक साफ tool_use कॉल उत्पन्न करते देखें। आपको इसे अभी चलाने की भी आवश्यकता नहीं है — बस इसे निर्णय लेते देखें।

11. AI को MCP के साथ अपने डेटा से कनेक्ट करें।

हाथ से संदर्भ चिपकाना स्केल नहीं करता। मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP), जिसे नवंबर 2024 में एंथ्रोपिक द्वारा पेश किया गया था, मानक समाधान है — इसे AI के लिए USB-C पोर्ट की तरह समझें: एक कनेक्टर स्पेक, और कोई भी अनुरूप ऐप आपकी फ़ाइलों, डेटाबेस और टूल में प्लग इन कर सकता है। यह महीनों में एक आंतरिक विचार से उद्योग डिफ़ॉल्ट बन गया, जिसमें हजारों रेडी-मेड सर्वर हैं जिन्हें आप कॉन्फ़िग के माध्यम से ड्रॉप कर सकते हैं।

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

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

1{
2  "mcpServers": {
3    "filesystem": {
4      "command": "npx",
5      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/notes"]
6    }
7  }
8}

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

12. एक वर्कफ़्लो पैकेज करें जिसका आप हमेशा पुन: उपयोग करेंगे।

दिन 30. आपके पास प्रॉम्प्ट, स्क्रिप्ट और उपकरण हैं — अब उन्हें एक ऐसी चीज़ बनाएँ जिसे आप नाम से बुलाते हैं। एंथ्रोपिक के एजेंट स्किल्स (दिसंबर 2025 में एक खुला मानक बनाया गया) इसके लिए साफ प्रारूप है: एक SKILL.md के साथ एक फ़ोल्डर जिसमें एक नाम, इसका उपयोग कब करना है इसका विवरण, और चरण शामिल हैं। मॉडल इसे केवल तभी लोड करता है जब प्रासंगिक हो (एक डिज़ाइन सिद्धांत जिसे प्रगतिशील प्रकटीकरण कहा जाता है), इसलिए आप संदर्भ को फुलाए बिना दर्जनों को स्टैक कर सकते हैं। भले ही आप API को फिर कभी स्पर्श न करें, अपने दोहराए जाने योग्य कार्यों को कौशल के रूप में लिखना वह आदत है जो आपको तेज़ बनाती है।

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

1---
2name: weekly-report
3description: मेरे कच्चे नोट्स को मानक साप्ताहिक रिपोर्ट में बदलें। जब मैं नोट्स चिपकाऊँ और "द वीकली" के लिए पूछूँ तो उपयोग करें।
4---
5
6# साप्ताहिक रिपोर्ट
7
8## चरण
91. नोट्स को समूहित करें: शिप किया गया, प्रगति पर, अवरुद्ध।
102. प्रति समूह 2-3 बुलेट लिखें, भूतकाल, कोई फालतू सामग्री नहीं।
113. "अगला सप्ताह" के साथ समाप्त करें — बिल्कुल 3 प्राथमिकताएँ।
12
13## प्रारूप
14- शीर्षक: "साप्ताहिक — <तारीख>"
15- 200 शब्दों से कम। कोई प्रचार नहीं।

अभी यह करें: अपना सबसे अधिक दोहराया जाने वाला कार्य चुनें, इसे एक तेज विवरण के साथ SKILL.md के रूप में लिखें। वह विवरण ही है जो इसे सही क्षण में सक्रिय करता है — इस पर वास्तविक प्रयास करें।

सामान्य गलतियाँ (और समाधान)

1. अस्पष्ट प्रॉम्प्ट। "X के बारे में लिखें" मॉडल को आपके इरादे का अनुमान लगाने पर मजबूर करता है — और यह औसत अनुमान लगाता है। समाधान: हमेशा भूमिका + संदर्भ + प्रारूप दें। आप <भूमिका> हैं। कार्य: <एक वाक्य>। आउटपुट: <सटीक प्रारूप>।

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

3. दिखाने के बजाय वर्णन करना। विशेषण ("इसे पेशेवर बनाएँ") कमज़ोर हैं; उदाहरण मजबूत हैं। समाधान: <example> टैग में 3-5 विविध उदाहरण जोड़ें और पैटर्न को काम करने दें।

4. "मत करो" के रूप में फ्रेम करना। "वाचाल मत बनो" मॉडल को वाचालता के बारे में सोचने पर मजबूर करता है। समाधान: कहें कि क्या करना है — "2 छोटे वाक्यों में उत्तर दें।" सकारात्मक निर्देश निषेधों की तुलना में अधिक प्रभावी होते हैं।

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

6. हाथ से करना जो एक लूप कर सकता है। एक ही प्रॉम्प्ट को चैट में 50 बार चलाना सबसे महंगी चीज़ है जो आप अपने दोपहर के साथ कर सकते हैं। समाधान: जिस क्षण आप पुनरावृत्ति पर पहुँचें, ब्लॉक 08 लूप लिखें। आपका समय दुर्लभ संसाधन है, टोकन नहीं।

निष्कर्ष: प्रणाली ही कौशल है

तीस दिन आपको AI शोधकर्ता नहीं बनाते। यह आपको कुछ और उपयोगी बनाता है: एक प्रणाली वाला व्यक्ति। आप किसी भी कार्य को ले सकते हैं, इसे एक साफ संक्षिप्त विवरण दे सकते हैं, इसे उदाहरण दिखा सकते हैं, इसे सोचने के लिए प्रेरित कर सकते हैं, और — जब यह दोहराता है — इसे स्वचालित कर सकते हैं, इसे कैश कर सकते हैं, और इसे एक ऐसे कौशल में पैकेज कर सकते हैं जिसे आप नाम से बुलाते हैं।

यह पूरा रहस्य है जिसे 10x वाली भीड़ कभी नहीं छिपा रही थी। अधिक प्रॉम्प्ट नहीं। एक बेहतर मॉडल नहीं। चालों का एक छोटा सेट, जब तक वे प्रतिवर्त न बन जाएँ, तब तक चलाया जाता है। अब आपके पास चालें हैं। एकमात्र चर जो बचा है वह है दोहराव।

आपकी 30-दिवसीय चेकलिस्ट — आज से शुरू करें:

1. भूमिका + संदर्भ + प्रारूप प्रॉम्प्ट के साथ एक वास्तविक कार्य शिप करें (ब्लॉक 01)।
2. prompt_library.py शुरू करें और अपने 3 सबसे अच्छे प्रॉम्प्ट को टेम्पलेट के रूप में इसमें ले जाएँ (ब्लॉक 06)।
3. 10-पंक्ति वाले ask() फंक्शन के साथ अपनी पहली API कॉल करें (ब्लॉक 07)।
4. फ़ोल्डर लूप के साथ एक बैच काम को स्वचालित करें (ब्लॉक 08)।
5. अपने सबसे अधिक दोहराए जाने वाले वर्कफ़्लो के लिए एक SKILL.md लिखें (ब्लॉक 12)।

वे पाँच करें और आप उन सभी लोगों के 90% से आगे हैं जो "AI में आने का इरादा रखते हैं।" फिर बस लूप चलाते रहें।