रोल: (Role) तुम्ही {LANGUAGE} भाषेचे वरिष्ठ इंजिनियर (Senior Engineer) आहात आणि {COMPONENT_TYPE} तयार करत आहात.
ध्येय: (Goal) {FUNCTION_NAME} लागू करा, जे {FUNCTION_PURPOSE} करेल.
मर्यादा:
- {STYLE_GUIDE} चे पालन करा (नाव, डॉक्स, एरर हँडलिंग).
- वेळ गुंतागुंत लक्ष्य: (Time complexity target) {BIG_O}. मेमरी मर्यादा: (Memory constraints) {LIMITS}.
- नॉन-ऑब्व्हियस लॉजिकसाठी (Non-obvious logic) डॉकस्ट्रिंग (Docstring) आणि इनलाइन कमेंट्सचा (Inline comments) समावेश करा.
- आवश्यक नसल्यास बाह्य अवलंबित्व टाळा; जोडल्यास स्पष्ट करा.
इनपुट:
- इंटरफेस/प्रकार: (Interfaces/Types) {TYPES}
- एज केसेस: (Edge cases) {EDGE_CASES}
- उदाहरण इनपुट/आउटपुट: (Example inputs/outputs) {EXAMPLES}
वितरण:
1) फक्त अंतिम कोड ब्लॉक.
2) कोडनंतर संक्षिप्त तर्क (बुलेटेड).

रोल: (Role) तुम्ही डेटा क्लीनिंग युटिलिटी (Data cleaning utility) तयार करणारे एक वरिष्ठ पायथन इंजिनियर (Senior Python Engineer) आहात.
ध्येय: (Goal) युजर नेम स्टँडर्डाइज (User name standardize) करण्यासाठी `normalize_names` लागू करा.
मर्यादा:
- PEP8 चे पालन करा; अवैध प्रकारांवर ValueError वाढवा.
- O(n) वेळ; व्हाइटस्पेस (Whitespace) आणि ॲक्सेंटचा (Accent) विचार करा; मेमरी लीनियर (Memory linear) ठेवा.
- डॉकस्ट्रिंग (Docstring) + कमेंट्स (Comments).
इनपुट:
- प्रकार: (Types) List[str] किंवा Iterable[str]
- एज केसेस: (Edge cases) नल्स (Nulls), एकापेक्षा जास्त स्पेस (Space), ॲक्सेंट मार्क (Accent mark), हायफनेटेड लास्ट नेम (Hyphenated last names)
- उदाहरणे: (Examples) [" José Álvarez ", "ANNA-lou "] → ["jose alvarez", "anna-lou"]
वितरण:
1) फक्त अंतिम कोड ब्लॉक.
2) संक्षिप्त तर्क.

रोल: (Role) वरिष्ठ {LANGUAGE} रिफॅक्टरिंग (Refactoring) तज्ञ.
कार्य: (Task) {GOAL}: {READABILITY|PERFORMANCE|SAFETY} साठी प्रदान केलेल्या कोडला (Code) रिफॅक्टर (Refactor) करा.
नियम:
- सार्वजनिक API आणि वर्तन जतन करा.
- जिथे नसेल तिथे टाइप हिंट्स (Type hints) आणि डॉकस्ट्रिंग्स (Docstrings) जोडा.
- टेस्टेबिलिटीसाठी (Testability) शुद्ध फंक्शन्स (Functions) तयार करा.
- जादूचे आकडे बदला; (Magic numbers) {STYLE_GUIDE} लागू करा.
- पूर्वीचे/नंतरचे गुंतागुंतीचे नोट्स (Complexity notes) द्या.
इनपुट कोड:
```{LANGUAGE}
{SOURCE}

### 3) टेस्ट जनरेशन टेम्प्लेट (Test Generation Template) (युनिट + प्रॉपर्टी टेस्ट)
**कधी वापरावे**: जलद कव्हरेज (Coverage) वाढवण्यासाठी.

### 4) कोड रिव्ह्यू टेम्प्लेट (Code Review Template) (ऑटोमेटेड रिव्ह्यूअर मोड)
**कधी वापरावे**: मानवी मंजुरीपूर्वी जलद, सुसंगत रिव्ह्यूजसाठी.

{UNIFIED_DIFF}

### 5) डिबगिंग टेम्प्लेट (Debugging Template) (किमान रिप्रो → मूळ कारण)
**कधी वापरावे**: बग्स (Bugs) शोधण्यासाठी आणि निराकरण करण्यासाठी, रिप्रोज (Repros) तयार करण्यासाठी.

---
## उदाहरण: Grok 4 Fast सह तिकीट ते PR
एक वास्तववादी परिस्थिती पाहूया: प्रॉडक्ट तिकीटमध्ये (Product ticket) “टाइप करताना सर्च (Search-as-you-type), डिबाउंस्ड API कॉल्स (Debounced API calls) आणि ऑप्टिमिस्टिक UI (Optimistic UI)” ची विनंती आहे.
1) **हुक (Hook) चा मसुदा तयार करा**

2) **टेस्टसाठी विचारा**

3) **रिव्ह्यू पास (Review pass) चालवा**

4) **सुधारा**

परिणाम: तुमच्याकडे प्रोडक्शन-रेडी (Production-ready) कोड (Code) आणि टेस्ट्स (Tests) असतील, आणि AI ने (AI) त्याच्या कारणांचे दस्तावेजीकरण केले जाईल, ज्यामुळे टीममधील सदस्याला ते समजेल.
---
## प्रॉम्प्ट पॅटर्न्स (Prompt Patterns) जे आउटपुटची (Output) गुणवत्ता वाढवतात
- **रोल + ध्येय + मर्यादा + इनपुट + वितरण**: हे स्ट्रक्चर (Structure) Grok 4 Fast ला योग्य मार्गावर राहण्यासाठी आवश्यक असलेले सर्व काही देते.
- **एज-केस इन्युमरेशन**: (Edge-Case Enumeration) नेहमी कठीण प्रकरणांची यादी करा. मॉडेल (Model) त्यांना टेस्ट्स (Tests) आणि गार्ड्समध्ये (Guards) बेक (Bake) करेल.
- **कॉम्प्लेक्सिटी टार्गेट्स**: (Complexity Targets) O(n) किंवा मेमरी लिमिट्सची (Memory limits) मागणी केल्याने चांगले अल्गोरिदम्स (Algorithms) मिळण्यास मदत होते.
- **API करार**: (API Contracts) लवकरच प्रकार/इंटरफेस (Types/interfaces) पेस्ट (Paste) करा; मॉडेल (Model) त्यांच्याशी जुळेल.
- **आउटपुट करार**: (Output Contracts) प्रथम अंतिम कोडची (Code) विनंती करा, नंतर तर्क. यामुळे कॉपी/पेस्टसाठी (Copy/paste) प्रतिसाद स्वच्छ राहतात.
---
## स्टाइल गाइड्स (Style Guides) आणि सातत्य: (Consistency) टीमसाठी तयार करा
जर तुम्हाला टीममध्ये सातत्यपूर्ण आउटपुट (Output) हवा असेल, तर प्रमाणित करा:
- **भाषा शैली मार्गदर्शक तत्त्वे**: (Language style guides) PEP8, Effective Go, Airbnb JS, Rust API Guidelines.
- **एरर कन्व्हेन्शन्स**: (Error conventions) रिटर्न (Return) वि. थ्रो (Throw), एरर कोड्स (Error codes), रीट्राय सिमेंटिक्स (Retry semantics).
- **टेस्टिंग नॉर्म्स**: (Testing norms) नेमिंग (Naming), फिक्स्चर डायरेक्टरीज (Fixture directories), कव्हरेज थ्रेशोल्ड्स (Coverage thresholds).
- **सुरक्षा डिफॉल्ट्स**: (Security defaults) इनपुट व्हॅलिडेशन (Input validation), एस्केपिंग (Escaping), सिक्रेट्स हँडलिंग (Secrets handling).
यांना तुमच्या टेम्प्लेट्समध्ये (Templates) स्थिरांक (Constants) म्हणून समाविष्ट करा, जेणेकरून Grok 4 Fast प्रत्येक वेळी ते आत्मसात करेल.
---
## सुरक्षित कोडसाठी सुरक्षा-प्रथम प्रॉम्प्ट्स (Security-First Prompts)
तुमच्या टेम्प्लेट्समध्ये (Templates) हे सुरक्षा क्लॉज (Security clauses) जोडा:
- **इनपुट व्हॅलिडेशन**: (Input validation) “सर्व अविश्वसनीय इनपुट (Untrusted input) व्हॅलिडेट (Validate) आणि सॅनिटाइज (Sanitize) करा.”
- **सिक्रेट्स स्वच्छता**: (Secrets hygiene) “कोडमध्ये सिक्रेट्स (Secrets) नको. env मधून वाचा आणि आवश्यक व्हेरिएबल्सचे (Variables) दस्तावेजीकरण करा.”
- **अवलंबित्वाचे परीक्षण**: (Dependency scrutiny) “कोणत्याही नवीन अवलंबित्व (Dependency) स्पष्ट करा आणि त्याचे समर्थन करा; स्टँडर्ड लायब्ररीला (Standard library) प्राधान्य द्या.”
- **सिरियलायझेशन सुरक्षा**: (Serialization safety) “सुरक्षित पार्सर (Parser) वापरा; eval/Function/ असुरक्षित डिसेरियलायझेशन (Deserialization) टाळा.”
- **AuthZ चेक्स**: (AuthZ checks) “संवेदनशील मार्गांवर अधिकृतता (Authorization) लागू करा; बायपास प्रयत्नांसाठी टेस्ट्स (Tests) जोडा.”
---
## कार्यक्षमतेसाठी प्रॉम्प्ट्स: (Performance Prompts) नेहमीच्या चुका टाळा
- “ॲलोकेशन्स (Allocations) कमी करा; मोठे पेलोड्स (Payloads) असताना बफरचा (Buffer) पुनर्वापर करा.”
- “N+1 क्वेरीज (Queries) टाळा; बॅच (Batch) किंवा प्रीफेच (Prefetch) करा.”
- “मोठ्या डेटासाठी स्ट्रीमिंग/इटरेटर्स (Streaming/iterators) वापरा.”
- “शुद्ध फंक्शन्स (Functions) मेमोइज (Memoize) करा; हॉटस्पॉट्स (Hotspots) प्रोफाइल (Profile) करा.”
- “ बेंचमार्क (Benchmarks) जोडा आणि ट्रेड-ऑफ (Trade-offs) स्पष्ट करा.”
---
## रिव्ह्यू चेकलिस्ट्स (Review Checklists) ज्या तुम्ही PR मध्ये पेस्ट (Paste) करू शकता
एक लहान चेकलिस्ट (Checklist) समाविष्ट करा, जेणेकरून प्रत्येक रिव्ह्यू (Review) सुसंगत असेल:
- API सुसंगतता निश्चित केली
- नल/अनडिफाइन्ड (Null/undefined) आणि रिक्त कलेक्शन हँडलिंग (Empty collection handling)
- रिसोर्स क्लीनअप (फाईल्स, सॉकेट्स, सबस्क्रिप्शन्स)
- कंकरन्सी गार्ड्स (Concurrency guards) (लॉक्स, ॲटॉमिक्स, आयडेमपोटेंसी)
- लॉगिंग लेव्हल्स (Logging levels) योग्य आहेत; संवेदनशील डेटा नाही
- टेस्ट्स (Tests) अपडेट (Update) केल्या; स्थलांतरणाचे (Migrations) दस्तावेजीकरण केले
---
## टीम वर्कफ्लो: (Team Workflow) प्रॉम्प्ट टेम्प्लेट्सला (Prompt Templates) सामायिक ॲसेट (Asset) बनवा
- तुमच्या रेपोमध्ये (Repo) टेम्प्लेट्स (Templates) सेंट्रलाइज (Centralize) करा (उदा. `/.prompts` डायरेक्टरी).
- स्निपेट्स (Snippets) किंवा एडिटर मॅक्रोज (Editor macros) वापरून `{LANGUAGE}`, `{STYLE_GUIDE}`, `{BIG_O}` सारखे व्हेरिएबल्स (Variables) पॅरामीटराइज (Parameterize) करा.
- तुमच्या प्रॉम्प्ट टेम्प्लेट्सची (Prompt Templates) आवृत्ती (Version) तयार करा आणि कोडप्रमाणे त्यांचे पुनरावलोकन करा.
- फिचर ड्राफ्टिंग (Feature drafting), रिफॅक्टरिंग (Refactoring), टेस्ट रायटिंग (Test writing) आणि रिलीज चेक्ससाठी (Release checks) प्लेबुक्स (Playbooks) तयार करा.
तसेच, जर तुमच्या टीमला ब्राउझरमध्ये (Browser) आणि डॉक्समध्ये (Docs) साइड-बाय-साइड (Side-by-side) कोडिंग कोपायलट (Coding copilot) आवडत असेल, तर हे लक्षात घेणे महत्त्वाचे आहे की [Sider.ai](https://sider.ai/) तुम्हाला प्रॉम्प्ट टेम्प्लेट्स (Prompt Templates) स्टोअर (Store) आणि पुन्हा वापरण्यात, डिफ्सवर (Diffs) कोड रिव्ह्यूज (Code reviews) चालविण्यात आणि टॅबमध्ये (Tabs) संदर्भ ठेवण्यात मदत करू शकते. कॉपी/पेस्टच्या (Copy/paste) त्रासाशिवाय तुमच्या संस्थेमध्ये हे Grok 4 Fast प्रॉम्प्ट्स (Prompts) कार्यान्वित करण्याचा हा एक सोयीस्कर मार्ग आहे.
---
## कॉपी-पेस्ट लायब्ररी: (Copy-Paste Library) वापरण्यासाठी तयार प्रॉम्प्ट्स (Prompts)
### TypeScript API हँडलर (Node/Express)

### पायथन डेटा पाइपलाइन स्टेप (Python Data Pipeline Step)

### Go कंकरन्सी गार्ड (Go Concurrency Guard)

### React ॲक्सेसिबल कंपोनंट (React Accessible Component)

---
## Grok 4 Fast (जलद अभिप्राय लूप) सह कसे इटरेट करावे
1) **लहान सुरुवात करा**: संपूर्ण सेवेऐवजी एका फंक्शनसाठी विचारा.
2) **आउटपुट मर्यादित करा**: “एक कोड ब्लॉक, नंतर बुलेट्स.”
3) **टेस्टची मागणी करा**: प्रत्येक फीचरसाठी एकाच वेळी टेस्ट तयार करा.
4) **निर्णय निश्चित करा**: “फायदे-तोटे स्पष्ट करा. खात्री नसल्यास, स्पष्ट करणारे प्रश्न विचारा.”
5) **रेटचेटिंग**: स्तरांमध्ये सुधारणा करा—प्रथम अचूकता, नंतर कार्यक्षमता, नंतर वाचनीयता.
---
## यशाचे मापन: टेम्प्लेटने मदत केली का?
साधे मेट्रिक्स (metrics) ट्रॅक करा:
- पीआर सायकल वेळ (तयार → मर्ज)
- पुनरावलोकन रीवर्क दर (PR नुसार विनंती केलेले बदल)
- प्रत्येक फीचरनुसार टेस्ट कव्हरेज डेल्टा
- AI द्वारे पुनरावलोकन केलेल्या कोडशी संबंधित प्रोडक्शन घटना
जर आकडे योग्य दिशेने वाढत असतील, तर प्रयत्न वाढवा. नसेल, तर तुमचे टेम्प्लेट ट्यून करा आणि अधिक संदर्भ (प्रकार, लॉग, डिफ) समाविष्ट करा.
---
## टाळण्यासाठी सामान्य चुका
- “बॅकएंड (backend) तयार करा” यासारखे व्यापक प्रॉम्प्ट टाळा. युनिट्समध्ये विभाजित करा.
- एज केसेस (edge cases) विसरू नका. त्यांची नेहमी यादी करा.
- लायब्ररी (library) वाढू देऊ नका. त्याचे समर्थन मागा.
- “नंतरसाठी” टेस्ट वगळू नका. त्यांना प्रॉम्प्टमध्ये बेक करा.
- अस्पष्ट पुनरावलोकने स्वीकारू नका. चेकलिस्ट आणि सिव्हिअरिटी लेव्हलची (severity levels) मागणी करा.
---
## त्वरित सुरुवात चेकलिस्ट
- तुमच्या रेपोमध्ये `/prompts` फोल्डर तयार करा.
- ड्राफ्टिंग, पुनरावलोकन आणि चाचणी टेम्प्लेट जतन करा.
- स्निपेट व्हेरिएबल्ससह (snippet variables) सामान्य फील्ड्स पॅरामीटराईज (parameterize) करा.
- या आठवड्यात एका फीचरवर पायलट करा; परिणामांचे मापन करा.
- समीक्षकांच्या अभिप्रायावर आणि घटनांवर आधारित इटरेट करा.
---
## अंतिम विचार
Grok 4 Fast जलद कोड तयार करण्यासाठी उत्कृष्ट आहे—परंतु वास्तविक शक्ती चांगल्या संरचित प्रॉम्प्ट टेम्प्लेटमधून येते जी तुमचे मानक एन्कोड (encode) करते. प्रॉम्प्टला पायाभूत सुविधांसारखे (infrastructure) वागवा. त्यांची आवृत्ती तयार करा. त्यांचे पुनरावलोकन करा. आणि Grok 4 Fast ला बॉयलरप्लेट (boilerplate) हाताळू द्या जेणेकरून तुमची टीम आर्किटेक्चर (architecture) आणि प्रॉडक्टवर (product) लक्ष केंद्रित करू शकेल.
पुढील पायरी: वरीलपैकी एक टेम्प्लेट निवडा, तो तुमच्या एडिटरमध्ये (editor) पेस्ट करा, तुमचा संदर्भ टाका आणि आजच एक PR पाठवा.
### FAQ
प्रश्न 1: सातत्यपूर्ण शैलीसह कोड ड्राफ्टिंगसाठी मी Grok 4 Fast चा वापर कसा करू?
रोल, ध्येय, मर्यादा आणि शैली मार्गदर्शन निश्चित करणारे संरचित प्रॉम्प्ट टेम्प्लेट वापरा. गुंतागुंतीचे लक्ष्य, एज केसेस आणि डिलिव्हरेबल्स (deliverables) समाविष्ट करा जेणेकरून Grok 4 Fast सातत्यपूर्ण, उत्पादन-तयार कोड आउटपुट करेल.
प्रश्न 2: प्रॉम्प्ट टेम्प्लेटसह Grok 4 Fast विश्वसनीय कोड पुनरावलोकने करू शकते?
होय. एक डिफ (diff), तुमच्या टीमचे मानक आणि सुरक्षा, कार्यप्रदर्शन आणि API सुसंगततेसाठी एक चेकलिस्ट प्रदान करा. सिव्हिअरिटी-रँक असलेल्या (severity-ranked) निष्कर्षांची आणि किमान पॅच सूचनांची मागणी करा.
प्रश्न 3: Grok 4 Fast वापरून टेस्ट तयार करण्याचा सर्वोत्तम मार्ग कोणता आहे?
फ्रेमवर्क, कव्हरेज ध्येय आणि एज केसेस निर्दिष्ट करणारे टेस्ट जनरेशन टेम्प्लेट वापरा. युनिट आणि प्रॉपर्टी-आधारित (property-based) टेस्ट तसेच एक संक्षिप्त कव्हरेज योजनेची मागणी करा.
प्रश्न 4: मी AI आउटपुटमधून असुरक्षित कोड कसा प्रतिबंधित करू?
तुमच्या प्रॉम्प्टमध्ये सुरक्षा क्लॉज (clauses) जोडा: इनपुट व्हॅलिडेशन (input validation), सिक्रेट्स हायजीन (secrets hygiene), अवलंबित्व औचित्य आणि सुरक्षित सिरियलायझेशन (serialization). सुरक्षा फायद्या-तोट्यांवर स्पष्ट नोट्स आवश्यक आहेत.
प्रश्न 5: Grok 4 Fast सह प्रॉम्प्ट टेम्प्लेट PR सायकलला गती कशी देतात?
टेम्प्लेट संदिग्धता कमी करतात, आउटपुट प्रमाणित करतात आणि टेस्ट आणि पुनरावलोकने फ्रंट-लोड (front-load) करतात. यामुळे वारंवारता कमी होते, रीवर्क कमी होते आणि तुम्हाला जलद मर्ज करण्यात मदत होते.