ત્રણ Claude મોડલ્સ સાથેના એક સોલો ડેવલપરના પ્રયોગે માસિક API ખર્ચમાં 35% નો ઘટાડો કર્યો અને મધ્યસ્થ (median) કાર્ય લેટન્સીને 42 સેકન્ડથી ઘટાડીને 27 સેકન્ડ કરી દીધી. સરળ અને ઓછી અસ્પષ્ટતા (low-ambiguity) ધરાવતા કામોને સસ્તા Haiku મોડલ પર, રૂટિન કામોને Sonnet પર મોકલીને અને ભારેકામવાળા Opus ને ઉચ્ચ જોખમ ધરાવતા પ્રશ્નો માટે અનામત રાખીને, લેખકે સાબિત કર્યું કે “દરેક વસ્તુ માટે શ્રેષ્ઠ મોડલ” વાપરવાની આદત ખર્ચાળ છે.
રાઉટિંગ શા માટે મહત્વનું હતું
લેખક એક ઓટોનોમસ કોડિંગ એજન્ટ ચલાવે છે જે ડેવલપમેન્ટના કાર્યોનો સતત પ્રવાહ મેળવે છે—જેમ કે લિન્ટ ફિક્સ (lint fixes), ફીચર એડિશન, સિક્યુરિટી રિવ્યુ અને ઊંડું ડીબગિંગ (deep debugging). મહિનાઓ સુધી એજન્ટે દરેક વિનંતી સૌથી સક્ષમ Claude મોડલ Opus ને મોકલી હતી, એવું માનીને કે ઉચ્ચ ગુણવત્તા હંમેશા કિંમત કરતા વધુ મહત્વની રહેશે. Opus પ્રતિ ટોકન પ્રીમિયમ કિંમત લે છે, તેથી બિલ સતત વધતું જતું હતું.
જ્યારે લેખકે ટાયર્ડ રાઉટિંગ સ્કીમ (tiered routing scheme) રજૂ કરી, ત્યારે ખર્ચ તેના મૂળ સ્તરના 65% પર આવી ગયો અને કુલ કાર્યોમાં Opus નો ઉપયોગ ઘટીને 11% થઈ ગયો.
ત્રણ-સ્તરીય સિસ્ટમ કેવી રીતે કામ કરે છે
રાઉટિંગ લોજિક અસ્પષ્ટતા (ambiguity) પર આધારિત છે, નહીં કે કોઈ કાર્યમાં કોડની કેટલી લાઇન બદલાય છે તેના પર. લેખકે ત્રણ વિભાગો (buckets) વ્યાખ્યાયિત કર્યા છે:
- Haiku – ઓછી અસ્પષ્ટતા ધરાવતા, નિશ્ચિત (deterministic) કાર્યો. ઉદાહરણ તરીકે: લિન્ટ વોર્નિંગ્સ સુધારવા, વેરિયેબલ્સનું નામ બદલવા, લોગ ફાઇલોનો સારાંશ બનાવવો. સાચો જવાબ સામાન્ય રીતે કોડ અથવા ટેક્સ્ટની એક જ લાઇન હોય છે.
- Sonnet – ડિફોલ્ટ વર્કહોર્સ. ફીચર ઈમ્પ્લીમેન્ટેશન, રૂટિન બગ ફિક્સ અને સ્ટાન્ડર્ડ રિફેક્ટર્સ સંભાળે છે જ્યાં સમસ્યા સ્પષ્ટ હોય છે પરંતુ ઉકેલમાં ઘણા તબક્કાઓ સામેલ હોઈ શકે છે.
- Opus – ઉચ્ચ જોખમ અને ઉચ્ચ અસ્પષ્ટતા ધરાવતું કામ. આર્કિટેક્ચરના નિર્ણયો, સિક્યુરિટી ઓડિટ, જટિલ ડીબગિંગ સેશન્સ, અથવા કોઈપણ એવું કાર્ય જ્યાં સાચો માર્ગ અસ્પષ્ટ હોય અને એક નાની ભૂલ આખી પાઇપલાઇનને તોડી શકે છે.
એક સ્ટેટિક લુકઅપ ટેબલ આ નિયમોના આધારે દરેક આવતી વિનંતીને યોગ્ય મોડલ સાથે જોડે છે. લેખકે એક “સ્માર્ટ” મોડલ અજમાવ્યું હતું જે તરત જ (on the fly) સ્તર નક્કી કરે, પરંતુ વધારાના ટોકન વપરાશને કારણે બચત શૂન્ય થઈ ગઈ. સાદા સ્ટેટિક નિયમોએ અંદાજે 80% કાર્યભારને આવરી લીધો અને સિસ્ટમને સસ્તી અને અનુમાનિત (predictable) રાખી.
એસ્કેલેશન સેફ્ટી નેટ
સસ્તા મોડલ્સ હજુ પણ ભૂલો કરે છે. Haiku અથવા Sonnet ના ખોટા પ્રતિસાદને બિલ્ડને ખોરવી નાખતા અટકાવવા માટે, સિસ્ટમ બે નિષ્ફળતા પછી વિનંતીને એસ્કેલેટ કરે છે, તેને આગલા સ્તર પર મોકલે છે. આ સેફ્ટી નેટ ભૂલોને વહેલી પકડી લે છે અને માનવીય હસ્તક્ષેપ વગર પાઇપલાઇનને સરળતાથી ચલાવવામાં મદદ કરે છે.
આંકડા જે જાતે જ બોલે છે
ટાયર્ડ રાઉટર ચલાવ્યાના ચાર અઠવાડિયા પછી, લેખકે આ ફેરફારો નોંધ્યા:
- API ખર્ચ મૂળ કિંમતના 65% સુધી ઘટી ગયો (35% નો ઘટાડો).
- મધ્યસ્થ ટર્નઅરાઉન્ડ સમય 42 સેકન્ડથી ઘટીને 27 સેકન્ડ થયો.
- Opus નો ઉપયોગ દરેક વિનંતી સંભાળવાથી ઘટીને કુલ કાર્યોના માત્ર 11% થયો.
આ આંકડા દર્શાવે છે કે ગુણવત્તામાં નોંધપાત્ર ઘટાડો કર્યા વિના મોટાભાગનું ડેવલપમેન્ટ કાર્ય સસ્તા મોડલ્સને સોંપી શકાય છે, જ્યારે સૌથી મુશ્કેલ સમસ્યાઓ હજુ પણ Opus ના મોટા કોન્ટેક્સ્ટ વિન્ડોનો લાભ લઈ શકે છે.
અન્ય ડેવલપર્સ માટે પાઠ
- નીચેથી શરૂઆત કરો, ઉપરથી નહીં. મોટાભાગના રોજિંદા કોડિંગ કાર્યો માટે સૌથી શક્તિશાળી મોડલની જરૂર નથી. અસ્પષ્ટ કાર્યો માટે Sonnet ને ડિફોલ્ટ બનાવવાથી Haiku દ્વારા બધું કરવા કરતા વધુ પૈસા બચ્યા.
- મુશ્કેલી માપો, કદ નહીં. આખી ફાઇલ રિફેક્ટર કરવા કરતાં એક લાઇનનો રેસ-કન્ડિશન (race-condition) ફિક્સ વધુ અઘરો હોઈ શકે છે. ઉકેલ કેટલો અસ્પષ્ટ છે તેના આધારે રાઉટ કરો, બદલાયેલી લાઇનોની સંખ્યાના આધારે નહીં.
- એસ્કેલેશન રેટ પર નજર રાખો. વધતા જતા એસ્કેલેશન એ સંકેત આપે છે કે સ્ટેટિક નિયમો હવે કાર્યભાર સાથે મેળ ખાતા નથી. સસ્તા મોડલ્સ પાઇપલાઇનમાં વધુ નિષ્ફળતાઓ લાવે તે પહેલાં વિભાગો (buckets) ને એડજસ્ટ કરો.
સૌથી મોંઘા મોડલને સૌથી મુશ્કેલ સમસ્યાઓ માટે અનામત રાખવું અને બાકીનું કામ સસ્તા મોડલ્સને કરવા દેવું એ AI-સહાયિત ડેવલપમેન્ટને ઝડપી અને સસ્તું રાખે છે. સાચો ફાયદો શિસ્તબદ્ધ રાઉટિંગ વ્યૂહરચનામાં રહેલો છે જે યોગ્ય કાર્ય માટે યોગ્ય સાધન પસંદ કરે છે.