मेरा एआई रनिंग कोच एक Git रिपॉज़िटरी और एक Claude एजेंट है

मैं अपना सत्र ख़त्म करता हूँ। मेरी घड़ी हमेशा की तरह अपने आप Strava से सिंक हो जाती है। मैं नहाने चला जाता हूँ।

जब तक मैं बाहर निकलता हूँ, तीन चीज़ें मेरे कुछ किए बिना हो चुकी होती हैं। सत्र का विश्लेषण मेरी ट्रेनिंग रिपॉज़िटरी में लिखा जा चुका होता है। हफ़्ता दोबारा सेट हो चुका होता है, और बदलाव की वजह उसके बग़ल में दर्ज होती है। और Strava गतिविधि के नीचे मेरे कोच की एक टिप्पणी होती है, जो बताती है कि सत्र कितने काम का था और शुक्रवार के लिए वह क्या बदलता है।

वह कोच कोई ऐप्लिकेशन नहीं है जो मैंने बनाई हो। वह Markdown फ़ाइलों की एक Git रिपॉज़िटरी है, एक Claude सब्सक्रिप्शन है, और सबको जोड़कर रखने वाला AgentsRoom है। कोई सर्वर नहीं लिखा, प्रति token कोई बिल नहीं, जोड़ने में लगभग एक वीकेंड।

पूरी चीज़ एक टेम्पलेट के रूप में प्रकाशित है: github.com/AgentsRoomDev/running-performance-coach. आप इसे क्लोन करके, ख़ाली जगहें भरकर अपना बना सकते हैं। यह लेख टुकड़ा दर टुकड़ा समझाता है कि यह कैसे काम करता है, यह मानकर कि आपने API शब्द सुना है पर कभी कोई webhook नहीं लिखा।

संदर्भ के लिए: मैं लंबे समय से दौड़ रहा हूँ, मैराथन में 2:47, हाफ़ में 1:13:59, 10 किमी में 33:45। मौजूदा साइकिल का लक्ष्य 10 किमी में दोबारा 34 मिनट के नीचे जाना है। आगे की बात के लिए यह मायने रखता है: एक आम कोच जो मुझे दोबारा समझाए कि थ्रेशोल्ड सत्र क्या होता है, मेरे किसी काम का नहीं, और यही वह समस्या है जिसे यह सेटअप हल करता है।

मेरी दौड़ ख़त्म होने और टिप्पणी के बीच क्या होता है

पूरी शृंखला छह चरणों की है:

1. मेरी घड़ी गतिविधि Strava को भेजती है। यह हिस्सा तो सबके साथ पहले से होता है।
2. हर 15 मिनट में एक छोटी Python स्क्रिप्ट Strava से पूछती है कि कुछ नया है क्या।
3. जब उसे नया सत्र मिलता है, वह मेरी रिपॉज़िटरी में एक Markdown सत्र शीट बनाती है: लैप, स्प्लिट, वॉल्यूम, हृदय गति। सिर्फ़ मापा हुआ डेटा।
4. वह Strava पर गतिविधि का शीर्षक और विवरण भी दोबारा लिखती है, ताकि मेरी फ़ीड में Afternoon Run लिखा आना बंद हो।
5. फिर वह AgentsRoom को एक हस्ताक्षरित संदेश भेजती है, जो सत्र पहले से हाथ में लिए हुए एक Claude एजेंट खोलता है।
6. वह एजेंट कोच का काम करता है: पढ़ता है, तुलना करता है, विश्लेषण लिखता है, हफ़्ता ठीक करता है, कमिट करता है, पुश करता है, Strava पर टिप्पणी करता है, और लंबी रिपोर्ट मुझे ईमेल कर देता है।

पहले पाँच चरण प्लंबिंग हैं। छठा ही इस लेख का विषय है।

ट्रेनिंग लॉग एक Git रिपॉज़िटरी है, डेटाबेस नहीं

यही वह फ़ैसला है जो सब कुछ बदल देता है, और यही लोगों को सबसे ज़्यादा चौंकाता भी है।

एक सत्र = एक फ़ाइल, journal/2026/2026-09-03.md। एक हफ़्ता = एक फ़ाइल, plan/weeks/2026-W36.md। प्लान का एक बदलाव = एक कमिट, संदेश में उसकी वजह के साथ। कोई डेटाबेस नहीं, कोई स्कीमा नहीं, कोई माइग्रेशन नहीं, कोई इंटरफ़ेस नहीं।

तीन नतीजे, महत्व के क्रम में:

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

मैं अपना प्लान फ़ोन पर, GitHub ऐप में पढ़ता हूँ। रिपॉज़िटरी की README.md कोई परिचय पृष्ठ नहीं है: वह मेरा डैशबोर्ड है। CLAUDE.md में लिखा अनुबंध इस बारे में साफ़ है, कोई भी प्लानिंग तब तक पूरी नहीं जब तक README उसे न दिखाए। नतीजा: मुझे कोई इंटरफ़ेस संभालना नहीं पड़ता, फिर भी मेरे पास एक स्क्रीन है जो बताती है कि मुझे आज क्या करना है।

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

चरण 1: Strava एक छोटी स्क्रिप्ट को जगाता है

Strava एक API देता है: किसी प्रोग्राम के लिए यह पूछने का रास्ता कि इस एथलीट की हाल की गतिविधियाँ दो। strava_sync.py स्क्रिप्ट ठीक यही करती है, और जवाब को एक सत्र शीट में बदल देती है।

दिलचस्प हिस्सा नेटवर्क कॉल नहीं है, पुनर्निर्माण है। घड़ी कच्चे लैप रिकॉर्ड करती है। स्क्रिप्ट को यह निकालना पड़ता है कि वह कौन सा सत्र था:

Lap 1  : 4.40 km in 26'07 (5:56/km)   ← वॉर्म-अप
Lap 2  : 1.00 km in 3'41  (3:41/km)   ← रेप 1
Lap 3  : 0.20 km in 1'59  (9:55/km)   ← रिकवरी
...                                     → "5 x 1000m r' 2'"

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

सबसे ज़रूरी, सत्र का आकार घड़ी से बनाया जाता है, प्लान से कभी नहीं। उल्टा करने का लालच होता है (प्लान कहता है 5 x 1000m, तो वही लिख दो) और ठीक यही ग़लती है: सारा मतलब उन दिनों को पकड़ने का है जब मैंने कुछ और किया। जब दोनों अलग-अलग हों, वही अंतर असली जानकारी है, और कोच उसे देखता है:

Planned 3 x 8' → लगातार दौड़ा गया

शुरू करने से पहले दो चेतावनियाँ।

Strava के API के लिए जून 2026 से एक पेड डेवलपर सब्सक्रिप्शन ज़रूरी है। उसके बिना हर कॉल का जवाब आता है 403 Application Status Inactive। विकल्प मौजूद है और टेम्पलेट में शामिल है: अपनी घड़ी से एक TCX फ़ाइल एक्सपोर्ट करें और import_tcx.py को दे दें। आयात के बाद का सब कुछ बिल्कुल वैसे ही चलता है।

कोटा उदार हैं, पर असली हैं। मेरे ऐप्लिकेशन पर, पढ़ने के लिए हर 15 मिनट में 300 अनुरोध और दिन के 3,000। स्थिर स्थिति में स्क्रिप्ट हर चक्कर में एक इस्तेमाल करती है, यानी दिन के 96। यह छत से बहुत दूर है, पर यह उस तरह की चीज़ है जो पहले जाँची जाती है, बाद में नहीं।

चरण 2: स्क्रिप्ट एजेंट को जगाती है, एक हस्ताक्षर के साथ

यहीं से यह दिलचस्प होता है।

webhook सवाल का उल्टा है। हर पाँच मिनट में यह पूछने के बजाय कि कुछ नया है क्या, आप एक प्रोग्राम को एक वेब पता दे देते हैं, और घटना होने पर वही आपको संदेश भेजता है। जब तक कुछ नहीं होता, आप कुछ नहीं चुकाते।

AgentsRoom ठीक यही देता है: एक webhook ट्रिगर। आप ऐप में एक ट्रिगर बनाते हैं, वह आपको एक URL और एक सीक्रेट लौटाता है। उस URL पर JSON संदेश भेजने वाला कोई भी एक एजेंट खोल देता है, आपके लिखे प्रॉम्प्ट और संदेश की सामग्री पहले से उसमें डाली हुई के साथ।

मेरी स्क्रिप्ट जो संदेश भेजती है वह जानबूझकर बहुत छोटा है:

{
  "type": "created",
  "title": "03/09 · 5 x 1000m r' 2'",
  "body": "03/09/2026 का सत्र Strava से आयात किया गया।\n\nक्वालिटी सत्र: 5 x 1000m r' 2'\nस्प्लिट: 3'41 - 3'40 - 3'38 - 3'40 - 3'35\n\nकुल वॉल्यूम: 12.51 km in 1h07'42 (5:25/km), चढ़ाई+ 56 m\nनियोजित सत्र: RP10-5x1000\n\nसत्र शीट: journal/2026/2026-09-03.md\nसप्ताह शीट: plan/weeks/2026-W36.md"
}

ग़ौर करें कि उसमें क्या नहीं है: प्लान का टेक्स्ट। webhook नियोजित सत्र का कोड और शीटों का पथ ले जाता है, उनकी सामग्री कभी नहीं। जिस एजेंट के पास रिपॉज़िटरी है वह ख़ुद जाकर पढ़ लेगा; जिसके पास नहीं है उसका मेरे अंदरूनी निर्देश पाने से कोई वास्ता नहीं। यह वही नियम है जो Strava पर प्रकाशित विवरणों पर लागू होता है।

हस्ताक्षर, और उसके साथ आने वाला जाल

एक सार्वजनिक URL जो एक एजेंट खोल देता है, वह हर मिलने वाले के लिए खुला नहीं रह सकता। इसलिए ट्रिगर हस्ताक्षरित है: स्क्रिप्ट साझा सीक्रेट से संदेश की एक छाप निकालती है (एक HMAC-SHA256, अगर यह शब्द आपके लिए कुछ मायने रखता है) और उसे X-AgentsRoom-Signature हेडर में भेजती है। सर्वर अपनी तरफ़ वही छाप दोबारा निकालता है; अगर दोनों नहीं मिलतीं, वह मना कर देता है।

हस्ताक्षर के बिना जवाब दो-टूक है:

{"error":"REJECTED","message":"Signature missing."}

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

इसका इलाज एक वाक्य में समा जाता है: सीरियलाइज़ और हस्ताक्षर एक ही जगह करें। टेम्पलेट में post_json फ़ंक्शन दोनों करता है, और संदेश के मुख्य भाग को छूने की इजाज़त और किसी को नहीं है।

चरण 3: तीन परतें कोच को बताती हैं कि वह कौन है, यहाँ चीज़ें कैसे चलती हैं, और अभी क्या करना है

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

परत 1, पर्सोना: वह कौन है

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

आपका काम केवल ट्रेनिंग प्लान बनाना नहीं है। आप एथलीट की ट्रेनिंग का विश्लेषण करके, उसकी मौजूदा फ़िटनेस समझकर, आने वाले सत्रों को ढालकर लगातार उसे कोच करते हैं। […] एक अनुभवी कोच की तरह बात करें, किसी प्रेरणा देने वाले चैटबॉट की तरह नहीं।

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

आपको इसे ख़ुद लिखने की ज़रूरत नहीं: यह पर्सोना AgentsRoom एजेंट कैटलॉग में रनिंग परफॉर्मेंस कोच नाम से प्रकाशित है। एक क्लिक में इंस्टॉल, इस्तेमाल के लिए तैयार।

परत 2, CLAUDE.md: यहाँ चीज़ें कैसे चलती हैं

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

एक अंश, क्योंकि वह सटीकता का स्तर दिखाता है:

हफ़्ता पटरी से उतरने पर बलिदान का क्रम: पहले आसान दौड़ों के अतिरिक्त मिनट, फिर स्ट्रेंथ का काम, फिर लंबी दौड़ की लंबाई, फिर एक क्वालिटी सत्र। पूरा हफ़्ता कभी नहीं।

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

परत 3, ट्रिगर प्रॉम्प्ट: अभी क्या करना है

यही वह संदेश है जो सत्र आते ही एजेंट को सौंपा जाता है। उसे गतिविधि टेम्पलेट चरों के ज़रिए मिलती है: {{event.title}}, {{event.body}}, {{event.url}}। इसलिए एजेंट सत्र पहले से हाथ में लिए शुरू होता है, उसे ढूँढने जाने के बजाय।

यह रहा उसका ढाँचा, जैसा वह ट्रिगर में है:

Strava से एक नया सत्र आयात हुआ।

**{{event.title}}** · गतिविधि {{event.id}}
{{event.url}}

{{event.body}}

---

तुम `training-plan` रिपॉज़िटरी में हो। पहले `CLAUDE.md` पढ़ो: वही क़ानून है।
तुम मेरी भाषा में लिखते हो और हर जगह सीधे मुझे संबोधित करते हो (§3).

§6 का कर्मकांड लागू है, पर उसका **चरण 1 पहले ही हो चुका है**: `strava_publish.py`
ने सत्र शीट बनाकर कमिट कर दी है। तुम चरण 2 से आगे बढ़ते हो और अंत
तक जाते हो। तीन डिलिवरेबल, इसी क्रम में: **रिपॉज़िटरी में विश्लेषण**,
**Strava गतिविधि के नीचे टिप्पणी**, **ईमेल**।

⚠️ **तुम बिना निगरानी चल रहे हो: कोई सवाल नहीं पढ़ेगा।** कभी भी
फ़ैसला मत माँगो: तुम तय करते हो, तुम करते हो, और अपनी रिपोर्ट में बताते हो कि
तुमने क्या तय किया और क्यों।

## 1 · विश्लेषण करो और प्लान ठीक करो (§6 कर्मकांड, चरण 2 से 6)

1. पहले `git pull --rebase`: शीट सर्वर से आ सकती है।
2. इसी क्रम में पढ़ो: आज की शीट, सप्ताह शीट,
   `athlete/zones-and-paces.md`, और **पिछली 3 सत्र शीट**:
   किसी सत्र को अकेले कभी नहीं आँका जाता।
3. `## Analysis` खंड लिखो: **पहले फ़ैसला**, फिर वे संकेत जो
   उसे थामते हैं, फिर वह क्या बदलता है।
   ⛔ अगर `## Analysis` पहले से भरा है, उसे दोबारा मत लिखो।
4. सप्ताह शीट अपडेट करो और प्लान का **हर** बदलाव उसकी वजह के साथ
   `## Adjustments` के नीचे दर्ज करो।
5. **`README.md` दोबारा बनाओ**: यही वह स्क्रीन है जो मैं फ़ोन पर पढ़ता हूँ।
6. कमिट और पुश करो, स्पष्ट पथ, ⛔ `git add -A` कभी नहीं।

## 2 · Strava पर Kudos और टिप्पणी
   ⛔ Strava टिप्पणी सार्वजनिक है: कोई लक्षित हृदय गति नहीं, कोई छोटी तकलीफ़ नहीं,
   कोई अंदरूनी फ़ैसला नहीं, कोई अनुमानित फ़िनिश समय नहीं।

## 3 · पूरी रिपोर्ट ईमेल से

सबसे ज़्यादा काम करने वाली पंक्ति बीच वाली है: कोई सवाल नहीं पढ़ेगा। स्क्रीन के सामने किसी के बिना चलता एजेंट जो फ़ैसला माँगता है, वह ग़लती नहीं कर रहा, वह बस रुक जाता है, और आपको अगले दिन पता चलता है।

कौन सा मॉडल, और दस लाख token दिखावा क्यों नहीं हैं

लंबा संदर्भ कोई सजावट नहीं है। एक सत्र को ठीक से आँकने के लिए कोच आज की शीट, सप्ताह शीट, संदर्भ गति तालिका, और पिछले तीन सत्र पढ़ता है। किसी सत्र को अकेले कभी नहीं आँका जाता: जमा हुआ भार, दिनों का क्रम और चल रहे निगरानी बिंदु फ़ैसले को पूरी तरह बदल देते हैं। दो घंटे की लंबी दौड़ के अगले दिन 3:38 पर तीन रेप वही कहानी नहीं कहते जो आराम के दिन के बाद वही 3:38 कहते हैं।

स्वायत्त मोड लापरवाही नहीं है, वह एक नतीजा है: स्क्रीन के सामने किसी के बिना चलने वाले रन में git push को मंज़ूरी देने वाला कोई नहीं होता। और ब्राउज़र ऐक्सेस ही वह चीज़ है जो एजेंट को Strava पर टिप्पणी करने और ईमेल भेजने देती है, दो ऐसी चीज़ें जिनके लिए यहाँ कोई सुविधाजनक API नहीं है।

क्या स्वचालित है, और क्या जानबूझकर नहीं है

यही वह डिज़ाइन फ़ैसला है जिससे मैं सबसे ज़्यादा ख़ुश हूँ, और इस पर नज़र न पड़ना आसान है।

आयात का काम दर्ज करता और प्रकाशित करता है, वह कभी आँकता नहीं।

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

व्यावहारिक फ़ायदा तुरंत मिलता है: जब एजेंट चला ही न हो (मशीन बंद, API ठप), शीट फिर भी मौजूद रहती है। कुछ नहीं खोता, बस टिप्पणी नहीं होती, और एक रीप्ले काफ़ी है।

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

अलगाव के दो और नियम, रिपॉज़िटरी में गढ़े हुए और जिन्हें घुमाकर पार नहीं करना:

• Strava पर प्रकाशित विवरण प्लान का टेक्स्ट कभी नक़ल नहीं करता: मेरी सप्ताह शीट में लक्षित हृदय गतियाँ और ऐसे समझौते हैं जिनका किसी सार्वजनिक गतिविधि पर कोई काम नहीं;
• हाथ से लिखा विवरण कभी अधिलेखित नहीं होता।

वह टिप्पणी जो गतिविधि के नीचे उतरती है

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

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

✅ 3'38 से 3'44 के लक्ष्य के लिए औसतन 3'39 पर पाँच रेप, और पूरे ब्लॉक में हृदय गति सपाट। गति तालिका टिकी हुई है। शुक्रवार आसान ही रहेगा: इस हफ़्ते का मार्जिन तुम ख़र्च कर चुके हो।

लंबा संस्करण, वह जिसमें हृदय गतियाँ, मेरा बताया निगरानी बिंदु और अगले हफ़्ते के वॉल्यूम पर फ़ैसला है, रिपॉज़िटरी में और ईमेल में जाता है। दो चैनल, दो दर्शक, और सीमा प्रॉम्प्ट ही थामे रखता है।

तीन चीज़ें जो सिर्फ़ प्रोडक्शन में टूटती हैं

इनमें से हर पंक्ति इसलिए मौजूद है क्योंकि उसके बिना कुछ टूटा था। ये लेख के बाक़ी हिस्से से ज़्यादा सिखाती हैं।

1. ब्राउज़र पिन करें। मेरे Chrome में दो Claude एक्सटेंशन जुड़े हैं। इसकी कोई गारंटी नहीं कि एजेंट को कौन सा मिलेगा, और Strava सत्र सिर्फ़ एक के पास है। नतीजा: हर दूसरे रन में एजेंट ग़लत ब्राउज़र में पहुँच जाता था, लॉग-आउट, किसी चीज़ पर टिप्पणी करने में असमर्थ। डिवाइस आईडी से ब्राउज़र चुनना एक सत्र से दूसरे सत्र तक नहीं टिकता: इसलिए उसकी जगह प्रॉम्प्ट में है, इस साफ़ मनाही के साथ कि जाकर उपयोगकर्ता से न पूछे कि कौन सा चुनें। बिना निगरानी चलते हुए, एक सवाल यानी गतिरोध।

2. Strava के टिप्पणी फ़ील्ड में कोई maxlength नहीं है। ब्राउज़र में कुछ भी आपको ज़्यादा लंबा लिखने से नहीं रोकता: सबमिट पर मना सर्वर करता है। जो एजेंट 600 अक्षरों का सुंदर पैराग्राफ़ रचता है, वह पूरा टाइप करता है, Post पर क्लिक करता है, और एक ऐसी नाकामी पाता है जो उसकी समझ में नहीं आती। इसलिए प्रॉम्प्ट को संक्षिप्तता लिखने से पहले लागू करनी होती है, और उस स्थिति के लिए तैयार रहना होता है: सबमिट नाकाम हो तो छोटा करके दोबारा पोस्ट करो, दो टिप्पणियों में कभी मत बाँटो।

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

इसका ख़र्च कितना है

इस सेटअप में प्रति token गिनी जाने वाली कोई API की नहीं है। यही वह बात है जो मुझे सबसे ज़्यादा कम आँकी गई लगती है: वही चीज़ अगर उपयोग पर बिल होने वाले API पर बनी होती तो हर सत्र पर एक मीटर चलता रहता, और शायद मैंने उसे रखा ही न होता।

इसे इसी वीकेंड बना लें

चरण, क्रम में। अगर आपके पास Strava अकाउंट और Claude सब्सक्रिप्शन पहले से हैं तो एक शाम मान लीजिए।

1. टेम्पलेट क्लोन करें और उसे अपना बनाएँ।

git clone https://github.com/AgentsRoomDev/running-performance-coach.git my-coach
cd my-coach
rm -rf .git && git init

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

फिर इसी क्रम में भरें: athlete/profile.md (धावक के तौर पर आप कौन हैं), athlete/records.md (आपके निजी रिकॉर्ड), athlete/constraints.md (वे समय जो सचमुच आपके पास हैं), athlete/zones-and-paces.md (आपकी संदर्भ गतियाँ), plan/objective.md (रेस और लक्ष्य), फिर CLAUDE.md, जहाँ आप हर {{...}} जगह भरते हैं।

आख़िर में, रिपॉज़िटरी अपने Claude एजेंट से खोलें और कहें: CLAUDE.md और athlete/ पढ़ो, फिर मेरे लिए पहला हफ़्ता बनाओ।

2. Strava जोड़ें।

cp .env.example .env && chmod 600 .env
python3 scripts/strava_oauth.py     # ब्राउज़र में एक क्लिक, एक ही बार
python3 scripts/strava_sync.py --dry-run

--dry-run बताता है कि क्या लिखा जाता, बिना कुछ लिखे। यही वह पल है जब जाँच लें कि सत्रों का पुनर्निर्माण आपको ठीक लगता है या नहीं।

3. AgentsRoom में ट्रिगर बनाएँ। Triggers के नीचे, New trigger:

AgentsRoom एक URL और एक साइनिंग सीक्रेट बनाता है। दोनों अपनी .env में डालें:

WEBHOOK_URL=https://agentsroom.dev/api/triggers/t_xxxxxxxxxxxx
WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxxxxxxxxxx

4. भरोसा करने से पहले जाँच लें।

python3 scripts/webhook_replay.py scripts/examples/webhook-session.json --dry-run
python3 scripts/webhook_replay.py scripts/examples/webhook-session.json

यह आपकी अगली दौड़ का इंतज़ार किए बिना और स्वचालित काम की स्थिति को छुए बिना एक सत्र को ट्रिगर में दोबारा चला देता है। आपको ✅ HTTP 202 दिखना चाहिए, और AgentsRoom में एक एजेंट टैब खुलनी चाहिए।

5. इसे हर 15 मिनट में चलाएँ।

bash scripts/systemd/install.sh          # एक Linux सर्वर पर

एक oneshot यूनिट और एक टाइमर: कोई स्थायी प्रोसेस नहीं, और मशीन बंद रहने के दौरान छूटा चक्कर अगले बूट पर पूरा कर लिया जाता है।

अगर आपके पास हमेशा चालू मशीन नहीं है, यह चरण छोड़ दें: जब मन हो strava_sync.py हाथ से चलाएँ, या बस बातचीत में एजेंट को अपना सत्र बता दें। CLAUDE.md का कर्मकांड बिल्कुल वैसे ही काम करता है। आप ऑटोमेशन खोते हैं, कोच नहीं।

दौड़ से परे, मैं इससे क्या लेता हूँ

इस सेटअप में कुछ भी दौड़ के लिए ख़ास नहीं है। यह जो दिखाता है वह लगभग हर उस क्षेत्र के लिए दोबारा इस्तेमाल होने वाला ढाँचा है जहाँ आप निजी डेटा जमा करते हैं और उस पर एक क़ाबिल राय चाहते हैं।

तीन हिस्से, और बस इतना ही। Markdown फ़ाइलों की एक Git रिपॉज़िटरी ऐसी याददाश्त के तौर पर जो मशीन भी पढ़ सके और आप भी। एक घटना जो एजेंट को जगाती है, न कि एक एजेंट जो लूप में पूछता रहे और बेवजह tokens जलाए। तीन कॉन्फ़िगरेशन परतें जो साफ़-साफ़ अलग करती हैं कि एजेंट कौन है, आपके यहाँ वह कैसे काम करता है, और अभी उसे क्या करना है।

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

अक्सर पूछे जाने वाले प्रश्न

एआई रनिंग कोच बनाने के लिए क्या कोडिंग आनी चाहिए?

आपको बस टर्मिनल में एक कमांड चलाना और एक टेक्स्ट फ़ाइल एडिट करना आना चाहिए। टेम्पलेट रिपॉज़िटरी क्लोन करने के लिए तैयार है, Python स्क्रिप्ट स्टैंडर्ड लाइब्रेरी के अलावा कुछ इस्तेमाल नहीं करतीं (कोई pip install नहीं), और कोचिंग वाला हिस्सा Markdown फ़ाइलों में सादा गद्य लिखकर सेट होता है। असली काम तकनीकी नहीं है: वह है ईमानदारी से यह बताना कि एक धावक के तौर पर आप कौन हैं और आपका लक्ष्य क्या है।

हर महीने इसका खर्च कितना आता है?

एजेंट उसी Claude सब्सक्रिप्शन पर चलता है जो आपके पास पहले से है (Pro या Max): प्रति token गिनी जाने वाली कोई API की नहीं है। इसके ऊपर आप हर 15 मिनट में Strava से पूछने के लिए एक छोटी हमेशा चालू मशीन रखना चाह सकते हैं, VPS पर लगभग 5 यूरो महीना, या Raspberry Pi पर कुछ भी नहीं। प्राइवेट Git रिपॉज़िटरी मुफ़्त है। बचता है Strava API, जिसके लिए जून 2026 से एक पेड डेवलपर सब्सक्रिप्शन ज़रूरी है।

डेटाबेस की जगह Git रिपॉज़िटरी क्यों?

क्योंकि इतिहास पढ़ने लायक बन जाता है, कोच के लिए भी और आपके लिए भी। हर सत्र एक Markdown फ़ाइल है, प्लान का हर बदलाव अपनी वजह के साथ एक कमिट है। एजेंट तीन हफ़्ते पहले जो उसने बताया था उसे दोबारा पढ़कर देख सकता है कि वह काम आया या नहीं, और आप अपना प्लान फ़ोन पर GitHub ऐप में पढ़ते हैं, इंटरफ़ेस की एक लाइन लिखे बिना।

आसान शब्दों में webhook क्या है?

webhook एक ऐसी सेवा है जो आपको कॉल करती है, बजाय इसके कि आप उसे कॉल करें। हर पाँच मिनट में यह पूछने के बजाय कि कुछ नया है क्या, आप एक प्रोग्राम को एक वेब पता दे देते हैं, और घटना होने पर वही आपको संदेश भेजता है। यहाँ, जो स्क्रिप्ट सत्र आयात करती है वही यह संदेश AgentsRoom को भेजती है, जो एक सेकंड के भीतर एक Claude एजेंट खोल देता है। यही इस सेटअप को सस्ता भी बनाता है: लूप में पूछता रहने वाला एजेंट हर चक्कर पर tokens जलाता है, जबकि एक webhook ट्रिगर तब तक कुछ नहीं लेता जब तक कुछ होता नहीं।

क्या यह दौड़ के अलावा किसी और खेल के लिए भी चलेगा?

हाँ। आयात घड़ी के लैप दोबारा जोड़कर सत्र बनाता है, और साइक्लिंग तथा स्विमिंग भी लैप रिकॉर्ड करती हैं। जो बदलता है वे हैं रणनीति की फ़ाइलें और सत्रों की सूची, जो टेक्स्ट है और आप उसे दोबारा लिखते हैं। तंत्र (आयात, webhook, एजेंट, रिपॉज़िटरी) हिलता नहीं।

क्या एजेंट ग़लती करके मेरा प्लान बिगाड़ सकता है?

वह ग़लती कर सकता है, पर ज़्यादा कुछ बिगाड़ नहीं सकता: वह जो कुछ लिखता है वह एक Git कमिट है जिसे आप पढ़ सकते हैं, उस पर बहस कर सकते हैं और उसे पलट सकते हैं। CLAUDE.md फ़ाइल उसे साफ़ मना करती है कि वह इतिहास दोबारा न लिखे, आपके न दिए हुए आँकड़े न गढ़े, वजह दर्ज किए बिना प्लान न बदले, और चिकित्सकीय सलाह न दे। कोई संदिग्ध दर्द हो, तो वह आपको किसी पेशेवर के पास भेज देता है।

---

टेम्पलेट रिपॉज़िटरी यहाँ है: AgentsRoomDev/running-performance-coach. इसे क्लोन कीजिए, अपनी गतियाँ भरिए, और आपका कोच तैयार है। एजेंट को जगाने वाला हिस्सा देखना हो तो वह webhook ट्रिगर पृष्ठ पर बताया गया है, और AgentsRoom यहाँ से डाउनलोड होता है।