दिवालिया हुए बिना Claude Fable 5 का उपयोग कैसे करें

Fable 5 अब तक का सबसे अच्छा AI मॉडल है जिसका मैंने उपयोग किया है।

यह बहुत महंगा भी है।

परीक्षण के पहले कुछ घंटों में, मैंने लगभग अपनी पूरी उपयोग सीमा समाप्त कर दी।

और मैं कुछ भी पागलपन भरा नहीं कर रहा था।

Fable की कीमत Opus 4.8 से दोगुनी है।

और क्योंकि यह इतना स्मार्ट है, यह वास्तव में ओवरथिंक करता है — लूप चलाता है और टोकन को इस तरह से जलाता है जैसे पिछले किसी भी Claude मॉडल ने नहीं किया।

अधिकांश लोग इसका पूरी तरह से गलत उपयोग कर रहे हैं।

यहाँ वह सटीक सिस्टम है जो मैंने अपने Fable टोकन खर्च को 50%+ कम करने के लिए बनाया है।

कोई नया टूल नहीं। कोई कम आउटपुट नहीं। बस स्मार्ट रूटिंग।

पहले दिन हर कोई जो गलती करता है

आप Claude Code खोलते हैं।

Fable अब डिफ़ॉल्ट मॉडल है।

आप चैट करना शुरू करते हैं।

आप इसे एक टाइपो ठीक करने के लिए कहते हैं। आप इसे कुछ JSON फ़ॉर्मेट करने के लिए कहते हैं। आप इसे एक वेरिएबल का नाम बदलने के लिए कहते हैं।

Fable 12 सेकंड सोचता है, 8,000 टोकन रीज़निंग जलाता है, जवाब देता है।

लागत: $0.60 एक ऐसे कार्य के लिए जिसे Haiku $0.02 में कर देता।

आप छोटी-मोटी बातचीत के लिए सर्जन की दरें दे रहे हैं।

Fable एक आर्किटेक्ट है।

रूममेट नहीं।

जिस पल आप इसे आत्मसात कर लेते हैं, सब कुछ बदल जाता है।

10-80-10 सिस्टम (वही सटीक ढांचा जो Anthropic इंजीनियर स्वयं उपयोग करते हैं)

हर Fable प्रोजेक्ट के तीन चरण होते हैं।

अधिकांश लोग तीनों को Fable पर चलाते हैं।

स्मार्ट कदम उनमें से केवल दो को Fable पर चलाना है।

पहले 10% — योजना बनाना

यह वह जगह है जहाँ Fable अपनी कीमत कमाता है।

किसी भी प्रोजेक्ट को शुरू करने से पहले, Fable का उपयोग परिभाषित करने के लिए करें:

→ संरचना और दृष्टिकोण → सफलता के मानदंड → बाधाएं और किनारे के मामले → क्या गलत हो सकता है

एक घर बनाने के बारे में सोचें।

सबसे महंगी गलती बिल्डरों को एक खराब ब्लूप्रिंट देना है।

पहले आर्किटेक्चर को सही करें।

Fable इसमें असाधारण है।

मध्य 80% — निष्पादन

यह वह जगह है जहाँ अधिकांश टोकन जलते हैं।

आगे-पीछे। पुनरावृत्ति। कार्यान्वयन लूप। कार्यों को पूरा करने का साधारण काम।

Fable को यहाँ रहने की आवश्यकता नहीं है।

मानक कार्य के लिए Opus 4.8 पर स्विच करें। हल्के कार्यों के लिए Haiku का उपयोग करें। यांत्रिक निष्पादन के लिए Codex या GPT-5.5 का उपयोग करें।

आपको Fable-गुणवत्ता वाली आर्किटेक्चर मिलती है बिना निष्पादन के हर टोकन के लिए Fable की कीमत चुकाए।

अंतिम 10% — समीक्षा

Fable को वापस लाएं।

इसे मूल योजना के विरुद्ध आउटपुट की समीक्षा करने दें:

→ क्या परिणाम आर्किटेक्चर से मेल खाता है?

→ क्या कोई अंतराल या छूटे हुए किनारे के मामले हैं?

→ क्या शिप करने से पहले कुछ ठीक करने की आवश्यकता है?

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

[INSERT IMAGE 2 — PROMPT BELOW]

CLAUDE.md रूटिंग टेबल (एक फ़ाइल जो सब कुछ नियंत्रित करती है)

यह सबसे बड़ा अनलॉक है।

अपने CLAUDE.md में एक एकल रूटिंग टेबल रखें।

Fable को ऑर्केस्ट्रेटर के रूप में कार्य करने दें जो इसे पढ़ता है और स्वचालित रूप से काम को सही मॉडल को भेजता है।

यहाँ वह सटीक रूटिंग टेबल है जो मैं उपयोग करता हूँ:

1## मॉडल रूटिंग टेबल
2
3### Fable 5 (केवल ऑर्केस्ट्रेटर)
4इसके लिए उपयोग करें: योजना बनाना, आर्किटेक्चर, अंतिम आउटपुट की समीक्षा करना
5इसके लिए कभी उपयोग न करें: यांत्रिक कार्य, बल्क जनरेशन, बॉयलरप्लेट
6प्रयास स्तर: उच्च (कभी xhigh नहीं — यह खराब आउटपुट वाला एक फर्नेस है)
7
8### Opus 4.8 (गहन तर्क निष्पादक)
9इसके लिए उपयोग करें: जटिल डीबगिंग, बहु-चरणीय तर्क, ऐसा कुछ भी
10         जिसमें वास्तविक सोच की आवश्यकता है लेकिन आर्किटेक्चर नहीं है
11लागत स्तर: मानक
12
13### Sonnet 5 (यांत्रिक कार्य निष्पादक)
14इसके लिए उपयोग करें: कोड जनरेशन, रिफैक्टरिंग, मानक सुविधा कार्य
15लागत स्तर: सस्ता
16
17### Codex / GPT-5.5 (सहकर्मी निष्पादक)
18इसके लिए उपयोग करें: कार्यान्वयन कार्य, UI/UX सत्यापन,
19         अच्छी तरह से निर्दिष्ट निष्पादन कार्य
20नोट: Fable Codex को चलाना सीख सकता है — इसे एक बार सिखाएं
21लागत स्तर: अक्सर Codex योजना पर मुफ्त
22
23### Haiku (बल्क निष्पादक)
24इसके लिए उपयोग करें: फ़ॉर्मेटिंग, लिंट, सरल संपादन, बॉयलरप्लेट,
25         नाम बदलना रिफैक्टर, परीक्षण स्कैफोल्डिंग
26Haiku से कभी भी आगे सबएजेंट न बनाएं
27लागत स्तर: सबसे सस्ता
28
29### Kimi / GLM-5.2 (लंबा संदर्भ निष्पादक)
30इसके लिए उपयोग करें: बड़ी फ़ाइलें पढ़ना, लंबी अवधि का रेपो विश्लेषण
31         ताकि Fable उस पर कभी टोकन खर्च न करे
32लागत स्तर: बहुत सस्ता
33
34### DeepSeek / Qwen (बहुत सस्ता साधारण काम)
35इसके लिए उपयोग करें: बॉयलरप्लेट, परीक्षण लेखन, डेटा सफाई,
36         अनुवाद, पहला-ड्राफ्ट दस्तावेज़, बल्क जनरेशन
37लागत स्तर: लगभग मुफ्त

Fable कभी भी सीधे सस्ते काम को नहीं छूता।

यह योजना बनाता है, सही स्तर को सौंपता है, फिर योजना के विरुद्ध परिणामों की जाँच करता है।

महंगा दिमाग केवल निर्णय लेने पर टोकन खर्च करता है।

वह एक फ़ाइल ही कारण है कि मेरा बिल नीचे गया जबकि मेरा आउटपुट ऊपर गया।

सटीक CLAUDE.md सेटअप जिसने मेरे 70% टोकन बचाए

यहाँ पूरा ऑर्केस्ट्रेशन सेक्शन है जो मैंने अपने CLAUDE.md में डाला:

1## ऑर्केस्ट्रेशन वर्कफ़्लो
2
3आप (Fable) ऑर्केस्ट्रेटर हैं। योजना बनाएं, विघटित करें, संश्लेषित करें।
4यांत्रिक कार्य स्वयं निष्पादित न करें।
5
6### प्रतिनिधिमंडल नियम:
7- तर्क-भारी चरण → गहन-तर्ककर्ता (Opus 4.8)
8- यांत्रिक कार्य → तेज़-कार्यकर्ता (Sonnet/Haiku)
9- कोडबेस विश्लेषण / बड़ी फ़ाइलें → Kimi (लंबा संदर्भ)
10- बॉयलरप्लेट / बल्क → DeepSeek या Qwen
11- विभिन्न दृष्टिकोण से सहकर्मी समीक्षा → Codex
12
13### Codex एक सहकर्मी है, समीक्षक नहीं:
14Codex को एक अलग दृष्टिकोण से एक क्रैक्ड Sr. इंजीनियर के रूप में
15मानें। उच्च-दांव वाले निर्णयों के लिए: एक ही समस्या पर Opus + Codex
16को समानांतर में कार्य सौंपें, बिना किसी को दूसरे का उत्तर दिखाए
17दोनों में से सर्वश्रेष्ठ को संश्लेषित करें।
18
19### संदर्भ अनुशासन:
20अपने स्वयं के संदर्भ को पतला रखें।
21उन फ़ाइलों को कभी दोबारा न पढ़ें जिन्हें आप पहले ही संसाधित कर चुके हैं।
22संदर्भ में वापस खिलाने से पहले टूल आउटपुट को संक्षेपित करें।
23मॉडलों से संक्षिप्त निष्कर्ष लौटाने के लिए कहें जिन पर आप कार्रवाई कर सकें।
24
25### प्रयास स्तर:
26- योजना और आर्किटेक्चर: उच्च प्रयास
27- समीक्षा पास: मध्यम प्रयास
28- डिफ़ॉल्ट रूप से कभी भी xhigh/max का उपयोग न करें — अधिक खर्च, अक्सर बदतर

अब Fable को एक टेक लीड की तरह प्रॉम्प्ट करें:

1लक्ष्य: [आप क्या चाहते हैं]
2संदर्भ: [फ़ाइलें, बाधाएं, आप किससे डरते हैं]
3
4आप लीड हैं।
5तर्क को गहन-तर्ककर्ता (Opus) को सौंपें।
6साधारण काम को तेज़-कार्यकर्ता (Sonnet/Haiku) को सौंपें।
7नए-दृष्टिकोण वाली समस्याओं के लिए Codex का उपयोग करें।
8
9पहले मुझे अपनी योजना दिखाएं, फिर निष्पादित करें।

बस इतना ही।

Fable योजना बनाता है। बाकी सब निष्पादित करता है। बिल स्थिर रहता है।

Codex प्लगइन इंस्टॉल करना — गुणक चाल

यह वह सेटअप है जिसे अधिकांश लोग छोड़ देते हैं।

Codex + Fable एक साथ अकेले Fable से 10x बेहतर है।

Fable आर्किटेक्चर करता है। Codex GPT-5.5 गुणवत्ता पर निष्पादित करता है। आप मुश्किल से अपनी Claude सीमाओं को छूते हैं।

5 मिनट से कम में सेटअप:

चरण 1: अपनी मशीन पर Codex CLI इंस्टॉल करें

1npm install -g @openai/codex

चरण 2: Claude Code के अंदर प्लगइन जोड़ें

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

चरण 3: Claude Code में दो सबएजेंट बनाएं

1/agents
2
3→ गहन-तर्ककर्ता
4  मॉडल: Opus 4.8
5  निर्देश: "तर्क-भारी चरणों, आर्किटेक्चर,
6  जटिल मुद्दों के डीबगिंग के लिए उपयोग करें। पूरी तरह से सोचें,
7  एक संक्षिप्त निष्कर्ष लौटाएं जिस पर ऑर्केस्ट्रेटर कार्रवाई कर सके।"
8
9→ तेज़-कार्यकर्ता
10  मॉडल: Sonnet 5
11  निर्देश: "यांत्रिक कार्यों, बॉयलरप्लेट, परीक्षणों,
12  फ़ॉर्मेटिंग, सरल संपादनों के लिए उपयोग करें। कुशलतापूर्वक निष्पादित करें।"

चरण 4: Fable से Codex के लिए SKILL.md लिखने को कहें

1एक SKILL.md लिखें जो Codex को सिखाए कि कैसे:
2- कार्यान्वयन योजनाओं को पढ़ें और निष्पादित करें
3- परीक्षण चलाएं और परिणाम आपको वापस रिपोर्ट करें
4- इस प्रोजेक्ट में विशिष्ट फ़ाइल संरचना को संभालें

इसे ऐसा बनाएं कि Codex को यांत्रिक कार्य पर शून्य मार्गदर्शन की आवश्यकता हो।

Fable एक बार कौशल लिखता है।

Codex इसे हर भविष्य के रन पर पढ़ता है।

आपका Codex आउटपुट तुरंत 10x बेहतर हो जाता है।

/loop कमांड (अभी Fable का उपयोग करने का सबसे शक्तिशाली तरीका)

अधिकांश लोग अभी भी पुराने तरीके से प्रॉम्प्ट करते हैं।

आप प्रॉम्प्ट करते हैं → Fable जवाब देता है → आप समीक्षा करते हैं → आप फिर से प्रॉम्प्ट करते हैं → दोहराएं।

उस मॉडल में, आप लूप हैं।

आप मैन्युअल रूप से हर कदम, हर सुधार, हर अनुवर्ती को सत्यापित करते हैं।

लूप आपको बाधा के रूप में हटा देते हैं।

यह कैसे काम करता है:

आप Fable को पहले से एक लक्ष्य देते हैं।

यह उस लक्ष्य की ओर काम करने के लिए सबएजेंट शुरू करता है।

एजेंट स्वयं को प्रॉम्प्ट करते हैं और पूरा होने पर वापस रिपोर्ट करते हैं।

दो कमांड:

1/goal — कार्य और अंतिम स्थिति को परिभाषित करें
2
3संरचना:
4/goal [कार्य] until [मापने योग्य अंतिम स्थिति] without [बाधाएं]
5
6उदाहरण:
7/goal auth मॉड्यूल को रिफैक्टर करें until सभी 47 परीक्षण पास हो जाएं
8without भुगतान सेवा या डेटाबेस स्कीमा को छूना

1/loop — एक प्रॉम्प्ट को स्वचालित रूप से शेड्यूल पर चलाएं
2
3संरचना:
4/loop [आपका प्रॉम्प्ट] --interval 30m --expires 8h
5
6उदाहरण:
7/loop सभी API एंडपॉइंट पर सुरक्षा जांच चलाएं
8--interval 24h --expires 7d

संयोजन:

1/goal डैशबोर्ड घटक को पुनर्निर्मित करें until Lighthouse
2स्कोर मोबाइल पर 90 से अधिक हो जाए without मौजूदा परीक्षणों को तोड़ना
3
4/loop उपरोक्त /goal चलाएं --interval 6h --expires 48h

Fable लूप डिज़ाइन करता है। सस्ते मॉडल लूप के अंदर 80% निष्पादन चलाते हैं। Fable केवल तब वापस आता है जब लूप बंद हो जाता है या किसी बाधा से टकराता है।

आप एक पूर्ण कार्य के साथ जागते हैं।

[INSERT IMAGE 5 — PROMPT BELOW]

अभी Fable पर चलाने के लिए 7 प्रॉम्प्ट

किसी और चीज़ के लिए Fable का उपयोग करने से पहले ये सबसे अधिक लाभप्रद चीजें हैं।

वाइब कोडिंग नहीं।

सुविधाएँ शिप करना नहीं।

हर उस सिस्टम को तेज करना जो आपके पास पहले से है।

1. पता लगाएं कि वास्तव में Fable पर चलाने लायक क्या है

1आप Fable 5 हैं, जो अब तक का सबसे सक्षम मॉडल उपलब्ध है।
2
3मेरे प्रोजेक्ट्स, डॉक्स और मेमोरी के माध्यम से देखें।
4
5शीर्ष 5 कार्यों को सूचीबद्ध करें जो वास्तव में आप पर चलाने लायक हैं।
6
7प्रत्येक को एक-पंक्ति कारण के साथ रैंक करें।
8
9अभी काम न करें।

2. कुछ भी बनाने से पहले पुनः डिज़ाइन करें कि आप कैसे बनाते हैं

1मैं चाहता हूं कि आप मेरे कोडिंग वर्कफ़्लो का पूरी तरह से ऑडिट और पुनः डिज़ाइन करें।
2
3यहां बताया गया है कि मैं वर्तमान में कैसे काम करता हूं: [अपनी प्रक्रिया का वर्णन करें]
4
5मेरा लक्ष्य है: [आप क्या शिप करने का प्रयास कर रहे हैं]
6
7मेरे सिस्टम की समीक्षा करें, ऑडिट करें, तेज करें और सुधारें।
8
9कोड न लिखें। इसे चलाने से पहले फैक्ट्री को पुनः डिज़ाइन करें।

3. बड़े प्रोजेक्ट की योजना बनाएं — इसे अभी न बनाएं

1मैं योजना बनाना चाहता हूं: [प्रोजेक्ट का वर्णन करें]
2
3अभी न बनाएं।
4
5पूरी योजना बनाएं: चरण, प्रमुख निर्णय, जोखिम,
6और खुले प्रश्न।
7
8किसी भी ऐसी चीज़ को चिह्नित करें जो इसे डुबो सकती है।
9
10योजना को इतना स्पष्ट बनाएं कि Sonnet या Codex
11बिना मुझसे प्रश्न पूछे इसे चरण दर चरण निष्पादित कर सके।

4. शिप करने से पहले सब कुछ गलत खोजें

1मैं इस प्रोजेक्ट को शिप करने वाला हूं।
2
3पहले इसमें सब कुछ गलत खोजें।
4
5पूरा कोडबेस पढ़ें।
6
7वास्तविक बग, टूटे हुए किनारे के मामले, और ऐसी किसी भी चीज़ की तलाश करें
8जो उपयोगकर्ता के सामने टूट जाएगी।
9
10प्रत्येक मुद्दे को इसके साथ सूचीबद्ध करें: इसे कैसे पुन: उत्पन्न करें और समाधान।
11
12एक उच्च मानक रखें। निर्दयी बनें।

5. अपने CLAUDE.md को शुरू से पुनर्निर्मित करें

1मेरा वर्तमान CLAUDE.md पढ़ें।
2
3यह पुराने मॉडलों के लिए लिखा गया था और फूला हुआ है।
4
5छोटे, स्वच्छ निर्देश बेहतर प्रदर्शन करते हैं और Fable में
6कम खर्च करते हैं।
7
8इसे फिर से लिखें:
9- उन निर्देशों को हटा दें जिनकी Fable को अब आवश्यकता नहीं है
10- हर वर्कफ़्लो को कसें
11- हमारी बातचीत से मॉडल रूटिंग टेबल जोड़ें
12- जहां संभव हो प्रत्येक अनुभाग को 5 पंक्तियों से कम रखें
13
14Fable बाकी का पता अपने आप लगा लेगा।

6. आपके बारे में जो कुछ भी जानता है उससे व्यावसायिक सलाह प्राप्त करें

1आप मेरे व्यावसायिक सलाहकार हैं।
2
3मेरा योजना दस्तावेज़, कनेक्टेड टूल और मेमोरी पढ़ें।
4
5मेरे व्यवसाय का एक-पृष्ठ मूल्यांकन लिखें और:
6- अगले 3 महीनों के लिए ध्यान केंद्रित करने के लिए शीर्ष 3 चीजें
7- क्या छोड़ना है और क्यों
8- एक चीज जिसके प्रति मैं शायद अंधा हूं

7. ऑटोपायलट पर सुरक्षा स्वीप

1/loop मेरे सभी API एंडपॉइंट पर सुरक्षा जांच चलाएं।
2
3इसके लिए देखें: उजागर कुंजियाँ, लापता प्रमाणीकरण, दर सीमा अंतराल,
4इंजेक्शन वेक्टर, और कोई भी चीज़ जिसका दुरुपयोग एक दुर्भावनापूर्ण उपयोगकर्ता कर सकता है।
5
6गंभीरता रेटिंग के साथ केवल वास्तविक मुद्दों की रिपोर्ट करें।
7
8--interval 24h --expires 7d

प्रयास स्तर — सबसे गलत समझी जाने वाली सेटिंग

अधिकांश लोग डिफ़ॉल्ट रूप से max या xhigh का उपयोग करते हैं।

यह गलत है।

यहां बताया गया है कि प्रत्येक स्तर पर वास्तव में क्या होता है:

→ निम्न: तेज़, सस्ता, आश्चर्यजनक रूप से सरल कार्यों में सक्षम। कई लोग यहां अद्भुत आउटपुट की रिपोर्ट करते हैं।

→ मध्यम: आदर्श बिंदु। मध्यम पर Fable, अतिरिक्त उच्च पर Opus को हराता है। डिफ़ॉल्ट रूप से इसका उपयोग करें।

→ उच्च: इसके लिए उपयोग करें: कठिन डीबगिंग, बहु-फ़ाइल रिफैक्टर, आर्किटेक्चर निर्णय। वास्तविक तर्क शक्ति।

→ xhigh / max: टोकन फर्नेस। अक्सर उच्च से भी बदतर आउटपुट उत्पन्न करता है। उन वास्तव में सबसे कठिन समस्याओं के लिए आरक्षित करें जिनका आपने कभी सामना किया है।

नियम: मध्यम से शुरू करें। उच्च पर तभी जाएं जब गुणवत्ता वास्तव में कम पड़ रही हो। कभी भी डिफ़ॉल्ट रूप से max का उपयोग न करें।

एक और सेटिंग जो बजट को मार देती है:

विस्तारित सोच — इसे डिफ़ॉल्ट रूप से बंद रखें।

इसे केवल उन समस्याओं के लिए चालू करें जिन्हें वास्तव में इसकी आवश्यकता है। इसे स्थायी रूप से चालू रखना आपके इंजन को ड्राइववे में चालू छोड़ने जैसा है।

/handoff ट्रिक — संदर्भ विंडो ब्लोट को ठीक करें

लंबे सत्र एक मूक हत्यारे हैं।

हर बारी पूरा वार्तालाप इतिहास फिर से भेजती है।

एक 200k-टोकन सत्र आपके बिल पर सबसे महंगी चीज़ बन जाता है।

समाधान: बार-बार नई चैट खोलें।

लेकिन जब आप ऐसा करते हैं तो आप संदर्भ खोना नहीं चाहते।

/handoff कौशल का उपयोग करें:

1मुझे एक प्रॉम्प्ट दें जिसका उपयोग मैं इस सत्र को एक नई चैट में
2पुनः आरंभ करने के लिए कर सकता हूं बिना अपना कोई संदर्भ खोए।
3
4इसमें शामिल करें:
5- हमने क्या तय किया
6- हमने क्या बनाया
7- अगले चरण क्या हैं
8- कोई भी महत्वपूर्ण बाधाएं जो मुझे याद रखनी चाहिए
9
10इसे 500 टोकन से कम रखें ताकि नया सत्र पतला शुरू हो।

उस आउटपुट को कॉपी करें।

नई चैट खोलें।

इसे पेस्ट करें।

संदर्भ लागत के एक अंश पर ठीक वहीं जारी रखें जहां आपने छोड़ा था।

हर 30-60 मिनट में ताज़ा सत्र = भारी टोकन बचत।

बचने के लिए 4 महंगी गलतियाँ

गलती 1: Fable अब डिफ़ॉल्ट है।

जब आप Claude Code खोलते हैं, तो यह स्वचालित रूप से Fable का उपयोग करता है।

प्रत्येक सत्र से पहले मॉडल चयनकर्ता की जाँच करें।

इस एक आदत ने मुझे सामान्य चैट पर गलती से Fable चलाने से कई बार बचाया है जितना मैं स्वीकार करना चाहता हूं।

गलती 2: कोई खर्च सीमा नहीं।

7 जुलाई को, Fable मानक सब्सक्रिप्शन से हट जाता है।

तुरंत एक क्रेडिट कार्ड जोड़ें और एक हार्ड मासिक कैप सेट करें।

सेटिंग्स → उपयोग → सीमा समायोजित करें।

Fable स्वायत्त रन और लंबे सत्रों पर तेजी से टोकन जलाता है।

हार्ड कैप के बिना, एक रात भर का एजेंट रन आपके जागने से पहले बिल जमा कर सकता है।

किसी को पहले ही एक ही प्रॉम्प्ट पर $960 का बिल मिल चुका है।

आज रात कैप सेट करें।

गलती 3: इससे अपने तर्क को समझाने के लिए कहना।

वह एक अनुरोध क्लासिफायर को ट्रिप कर सकता है और आपका काम चुपचाप एक कमजोर मॉडल द्वारा संभाला जाता है जबकि आपको लगता है कि आप अभी भी Fable पर हैं।

"क्यों" अनुरोधों को छोड़ दें। आउटपुट गुणवत्ता का न्याय करें, प्रक्रिया का नहीं।

गलती 4: इसे छोटे-छोटे प्रॉम्प्ट खिलाना।

Fable अपने दिमाग में घंटों का संदर्भ रखता है।

इसे एक बार में पूरी गड़बड़ चीज़ दें।

पूरा संदर्भ। बाधाएं। आप वास्तव में किससे डरते हैं।

मैंने Fable को एक रिफैक्टर दिया जिससे मैं हफ्तों से डर रहा था एक ही संक्षिप्त में। यह पूरा होकर वापस आया।

इसे छोटे-छोटे टुकड़ों में खिलाना उस एक चीज़ को बर्बाद करता है जिसमें यह सबसे अच्छा है।

मॉडल लागत तुलना — जानें कि आप वास्तव में क्या भुगतान कर रहे हैं

कुछ भी रूट करने से पहले, प्रत्येक मॉडल की कीमत जानें:

मॉडल इनपुट ($/M) आउटपुट ($/M) सर्वश्रेष्ठ के लिए

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Fable 5 ~$15 ~$75 योजना, समीक्षा

Opus 4.8 ~$5 ~$25 गहन तर्क

Sonnet 5 ~$3 ~$15 मानक निष्पादन

Kimi K2.7 ~$0.95 ~$4.00 बल्क कोडिंग, लंबा संदर्भ

GLM-5.2 ~$1.40 ~$4.40 रेपो-पैमाने का काम

DeepSeek v4 ~$0.28 ~$1.10 बहुत सस्ता साधारण काम

Haiku 4.5 ~$1 ~$5 सफाई, फ़ॉर्मेटिंग

स्थानीय (Qwen/Llama) $0 $0 ऑटोकम्पलीट, बॉयलरप्लेट

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Fable और DeepSeek के बीच का अंतर: इनपुट पर 53x। आउटपुट पर 68x।

वही 30-चरणीय रिफैक्टर एजेंट: → सभी Fable: ~$25 प्रति रन → Fable योजना + Kimi निष्पादन: ~$1.40 प्रति रन → वही शिप किया गया कोड। वही परीक्षण पास।

रूटिंग सस्ता होने के बारे में नहीं है।

यह सटीक होने के बारे में है।

पूरा सिस्टम — यह चलने पर कैसा दिखता है

इस सिस्टम से पहले:

→ सब कुछ Fable पर रूट होता है

→ हर बार जब आप शिप करते हैं तो बिल बढ़ जाता है

→ उपयोग सीमाएं सत्र के बीच में लग जाती हैं

→ आप एक बजट यात्री की तरह प्रॉम्प्ट का राशन करते हैं

इस सिस्टम के बाद:

→ Fable उस 10% को संभालता है जिसे वास्तव में इसकी आवश्यकता है

→ सस्ते मॉडल निष्पादन के 80% को संभालते हैं

→ /loop आपकी सीमा को छुए बिना रात भर चलता है

→ आप अधिक शिप करते हैं, कम खर्च करते हैं, कभी दर सीमा नहीं मारते

तीन-पंक्ति सारांश:

Fable योजना बनाता है। अन्य निष्पादित करते हैं। Fable समीक्षा करता है।

वह एक नियम कुछ और बदलने से पहले आपके बिल को 50%+ कम कर देता है।

बाकी ऑप्टिमाइज़ेशन है।

इसे आज रात चलाएं

इसे अभी Fable में डालें:

मेरा वर्तमान CLAUDE.md और मेरे सभी सक्रिय प्रोजेक्ट पढ़ें।

आपका काम: मेरे वर्कफ़्लो के लिए 10-80-10 रूटिंग सिस्टम सेट करना।

बनाएं:

1. पूर्ण मॉडल रूटिंग टेबल के साथ अद्यतन CLAUDE.md
2. मेरे वर्तमान सक्रिय कार्यों की एक सूची जो इस आधार पर रैंक की गई है कि प्रत्येक को किस मॉडल को संभालना चाहिए
3. तीन /goal प्रॉम्प्ट जो मैं आज रात आपके प्रोजेक्ट्स में जो देखते हैं उसके आधार पर सस्ते मॉडल पर चला सकता हूं

कुछ भी निष्पादित न करें। बस योजना बनाएं और रूट करें।

Fable योजना बनाता है।

आप एक पूर्ण रूटिंग सिस्टम के साथ जागते हैं।

और एक बिल जो आपको दिल का दौरा नहीं देता।

अगर इसने आपके पैसे बचाए:

→ दोबारा पोस्ट करें ताकि अन्य बिल्डर अपने बजट को जलाना बंद करें

→ अधिक ऐसे सिस्टम के लिए @sairahul1 को फॉलो करें

→ इसे बुकमार्क करें — CLAUDE.md कॉन्फ़िगरेशन काम करते हैं, उन्हें आज रात पेस्ट करें

ऐसे और दिलचस्प लेखों के लिए theaibuilders.co की सदस्यता लें

मैं AI, उत्पाद बनाने और ऐसे सिस्टम के बारे में लिखता हूं जो आपके सोते समय काम करते हैं।

संसाधन:

→ Entelligence टोकन राउटर: entelligence.ai/blogs/entelligence-token-router

→ तीन-मॉडल वर्कफ़्लो जिसने बिल 80% कम किया: entelligence.ai/blogs/our-three-model-coding-workflow-that-cut-our-ai-bill-80

→ Claude Code: claude.ai/code

→ Codex CLI: npmjs.com/package/@openai/codex