Kodlama ajanınız, çoktan seçmeli sorular için en üst düzey model fiyatları ödüyor.
Hangi notları yüklemeliyim? Bu adım büyük modele mi yoksa küçük bir modele mi gitmeli? Araç az önce hata verdi. Yeniden dene, düzelt, yoksa vazgeç mi? Hangi testler önce çalışmalı?
Bunların her biri dört ya da beş olası yanıtı olan birer soru. Ve günümüzdeki çoğu ajan kurulumunda, bu soruların her biri sahip olduğunuz en pahalı model tarafından, düşünme (thinking) modu açıkken, tüm bağlamı okuyarak ve kararını vermeden önce koca bir paragraf yazarak yanıtlanıyor.
Sızıntı tam da burada.
Bu makale, o sızıntıyı nasıl tıkayacağınızı gösteriyor. Opus 5.5 zorlu akıl yürütme işlerini üstleniyor: planlama, kod yazma, hata ayıklama. Jev ise neredeyse her adımda karşınıza çıkan dört kararı alıyor. Sizin kontrol mekanizmanız (harness) seçenekleri hazırlıyor, yanıtları kontrol ediyor ve son sözü söylüyor.
Aşağıdaki uygulamalı örnekte, tek bir özellik geliştirme oturumunun maliyeti 6,42 dolardan 2,00 dolara düşüyor. Bu %69 daha ucuz demek; üstelik matematiğin her satırı bu makalede yer alıyor, böylece kendi rakamlarınızla karşılaştırabilirsiniz.
Bu yazı, gerçek işler için bir kodlama ajanı çalıştıran herkes için kaleme alındı: Claude Code, API üzerinde kendi kurduğunuz yapı veya aradaki herhangi bir şey. Ajanınızı baştan yazmanıza gerek yok. Bu makaledeki her parça, mevcut döngünüze bir fonksiyon çağrısı olarak ve onu kapatmanızı sağlayacak bir bayrakla (flag) kolayca entegre edilebilir. Jev + Claude Code makalemi okuduysanız, bu onun yükseltilmiş versiyonu: aynı fikir, daha yeni bir akıl yürütme modeli ve genel bir ilke yerine dört spesifik karar.
Bir Jev API anahtarına, bir Anthropic API anahtarına ve kıyaslama yapabilmek için yaklaşık bir haftalık ajan loglarına ihtiyacınız olacak.
Hadi inşa edelim.
opus akıl yürütür jev karar verir.
Sorun: İki İşi Birden Yapan Tek Bir Model
Bir kodlama ajanının on dakika boyunca çalışmasını izleyin; iki çok farklı türde iş yaptığını göreceksiniz.
Birinci iş akıl yürütmektir. Bir özelliği planlamak. Bir fonksiyon yazmak. Bir stack trace'i okuyup tarih ayrıştırıcısının artık yıllarda neden bozulduğunu çözmek. Bu iş ucu açıktır. Yanıt bir listede hazır değildir. Burada bütçenizin yettiği en akıllı modeli istersiniz ve Opus 5.5 bu konuda gerçekten çok iyidir.
İkinci iş karar vermektir. Kırk proje notu arasından önemli olan üçünü seçmek. Bir yeniden adlandırma işleminin ucuz bir modele devredilebileceğine karar vermek. npm test zaman aşımına uğradığında ne yapılacağını belirlemek. Tamamı 1.400 dosyadan oluşan test havuzundan önce hangi 12 test dosyasının çalıştırılacağını seçmek. Bu yanıtlar bir listededir. Liste kısadır. Ve kodunuz bu yanıta doğrudan göre aksiyon alabilir.
Çoğu ajan, varsayılan davranış bu olduğu için her iki işi de aynı model üzerinden yürütür. Döngü Opus'u çağırır, Opus düşünür, Opus yanıtlar, döngü devam eder.
İşe yarıyor. Ancak fark etmesi kolay olmayan bir şekilde hem yavaş hem de pahalı; çünkü karar verme çağrıları tek tek bakıldığında pahalı görünmez. "Hangi notlara ihtiyacım var?" şeklindeki tek bir çağrı belki bir sent tutar. Ama bu her adımda gerçekleşir ve her seferinde yanında tüm bağlamı taşır.
Bir de fark etmesi çok daha kolay olan ikinci bir maliyet var: Ajan neyi yükleyeceğine karar veremediğinde her şeyi yükler. Her proje notu, her konvansiyon dokümanı, geçmişteki her karar, her çağrıya tıka basa doldurulur. Opus 5.5, milyon token başına 0,20 dolar ile önbellek okumalarını ucuzlattı ama "ucuz fiyat çarpı altmış adım çarpı tüm notlar klasörünüz" yine de ciddi bir toplam oluşturuyor.
Çözüm: Opus Akıl Yürütür, Jev Karar Verir, Kontrol Sizde Kalır
Jev, TypeSafe tarafından tam da bu ikinci iş için geliştirilmiş bir modeldir. Metin yazmaz. Ona bağlamı ve sabit seçeneklerden oluşan tipli soruları verirsiniz, o da size her seçenek için bir olasılık değeri döner. Milisaniyeler içinde yanıt verir, girdi maliyeti milyon token başına 0,042 dolardır ve çıktı tamamen ücretsizdir.
Bu da mimariyi açıklamayı oldukça basit hale getiriyor:
Opus 5.5 akıl yürütmeyi yapar. Planlama, kod, hata ayıklama; yani yanıtın bir listede olmadığı her şey.
Jev küçük kararları alır. Kontrol mekanizmanızın hazırladığı seçenekler arasından seçim yapar.
Kontrol sizde kalır. Seçenek listelerini o oluşturur, olasılıkları o okur, eşikleri o uygular ve Jev emin olmadığında Opus'a geri döner.
İnsanların atladığı üçüncü madde tam da budur ve tüm sistemi güvenli kılan da odur. Jev asla kendiliğinden bir seçenek uydurmaz. Geri alamayacağınız hiçbir konuda son söz Jev'e ait değildir. "Yeterince emin olmak" kavramının ne anlama geldiğine sizin kodunuz karar verir.
İşte bu makaledeki diğer her şeyin üzerine inşa edildiği yardımcı fonksiyon:
from dataclasses import dataclass
class Decision:
answer: str
prob: float
probs: dict
confident: bool
def jev_choice(context: str, question: str, options: list[str]):
Bunu kendi Jev istemcinize bağlayın: TypeSafe SDK, Vercel AI Gateway
veya LangChain paketi. Geçtiğiniz her seçenek için {seçenek: olasılık}
döndürmelidir.
raise NotImplementedError
def decide(context: str, question: str, options: list[str], threshold: float):
probs = jev_choice(context, question, options)
answer = max(probs, key=probs.get)
return Decision(answer, probs[answer], probs, probs[answer] >= threshold)
Burada neyin eksik olduğuna dikkat edin: Jev'e ne kadar emin olduğunu soran bir soru yok. Onun döndürdüğü olasılığı okuyorsunuz. Herhangi bir modele "Emin misin?" diye sormak, neredeyse her zaman "Evet" yanıtını almanıza yol açar. Asıl dürüst sinyal olasılıktır.
Şimdi gelelim dört karara.
ajan adımındaki dört karar
Karar 1: Bağlamı Yüklemeden Önce İlgili Proje Notlarını Seçin
Bu, elinizdeki en büyük kaldıraç ve neredeyse kimsenin henüz hayata geçirmediği bir adım.
Ajanınızın bir notlar klasörü vardır. Bir AGENTS.md, mimari dokümanlar, kodlama standartları, geçmiş kararlar, "migration olmadan fatura modülüne asla dokunma" uyarıları... Belki 30.000 token'lık bir içerik. Çoğu ajan, önemli notu dışarıda bırakan kişi olmak istemediği için her çağrıda bunların tamamını yükler.
O halde her şeyi yüklemek yerine, her not için Jev'e paralel olarak basit bir soru sorun: Ajanın bu görev için bu nota ihtiyacı var mı?
Önce notlarınızı başlıklara göre parçalara ayırın. AGENTS.md dosyasının her bölümü kendi parçası olur. Her mimari doküman bir veya daha fazla parçaya dönüşür.
import re
def chunk_notes(markdown: str, source: str):
parts = re.split(r"
(?=## )", markdown)
return [{"source": source, "text": p.strip()} for p in parts if p.strip()]
Ardından her parçayı mevcut göreve göre puanlayın:
from concurrent.futures import ThreadPoolExecutor
def pick_notes(task: str, notes: list[dict], keep: int = 6, floor: float = 0.55):
def score(note):
probs = jev_choice(
context=f"TASK:
{task}
NOTE ({note['source']}):
{note['text']}",
question="Would an engineer need this note to do the task correctly?",
options=["needed", "not_needed"],
)
return probs["needed"], note
with ThreadPoolExecutor(max_workers=16) as pool:
scored = sorted(pool.map(score, notes), key=lambda s: s[0], reverse=True)
picked = [n for p, n in scored[:keep] if p >= floor]
return picked or [n for _, n in scored[:2]]
Burada üç detay kritik önem taşıyor.
Tartışılamaz olanları her zaman yükleyin. Bazı notlar ne olursa olsun her çağrıda bulunmalıdır: güvenlik kuralları, "asla force push yapma" kuralı, hangi veritabanının production ortamına ait olduğunu söyleyen o tek satır. Bunları "always" (her zaman) olarak etiketleyin ve puanlama sürecini atlayın.
Bir alt sınır ve bir yedek plan belirleyin. Hiçbir şey 0,55 eşiğini geçemezse bile en yüksek puanlı ilk ikisini yine de yüklersiniz. Sıfır bağlamla çalışan bir ajan, biraz fazla bağlamla çalışan bir ajandan daha kötüdür.
Nelerin elendiğini loglayın. Ajan bir hata yaptığında kontrol ettiğiniz ilk şey, o hatayı önleyecek notun puanlama sonucu elenip elenmediği olmalıdır. keep ve floor parametrelerini bu loglara göre ayarlarsınız.
Uygulamalı örnekte sadece bu değişiklik, her çağrının not kısmını 30.000 token'dan 6.000 token'a düşürüyor. Tek başına bu bile oturum maliyetini yaklaşık %24 azaltıyor.
Karar 2: Uygun Görevleri Daha Hızlı Bir Çalışana Yönlendirin
Her adımın Opus'a ihtiyacı yoktur.
Sekiz dosyada bir fonksiyonu yeniden adlandırmak buna örnek değildir. Zaten benzer dokuz alanı olan bir forma yeni bir alan eklemek de öyle. Bir içe aktarma (import) yolunu güncellemek de gerektirmez. Bunlar, kod tabanında zaten mevcut bir kalıbı takip eden düzenlemelerdir.
Bu nedenle her adım çalışmadan önce Jev adımı sınıflandırır ve sizin kontrol mekanizmanız bu sınıfı bir çalışana eşler:
ROUTES = {
"rename_or_move": "fast",
"small_edit_following_existing_pattern": "fast",
"new_logic": "opus",
"debugging": "opus",
"design_decision": "opus",
}
def route(step: str, recent_diff: str):
d = decide(
context=f"STEP:
{step}
RECENT CHANGES:
{recent_diff}",
question="What kind of work is this step?",
options=list(ROUTES),
threshold=0.8,
)
if not d.confident:
return "opus"
return ROUTES[d.answer]
Seçeneklerin nasıl yazıldığına dikkat edin. "Kolay" ve "zor" değiller ve kesinlikle "küçük bir model bunu halledebilir mi?" de değiller. Bunlar, kodunuzun bir aksiyona dönüştürebileceği somut iş türleridir. Her Jev sorusu için kural budur: Her seçenek, kontrol mekanizmanızın nasıl aksiyon alacağını bildiği bir şey olmalıdır.
Ve varsayılan duruma dikkat edin. 0,8'in altında kalan adımlar Opus'a gider. Yönlendirme hataları burada yalnızca tek bir yöne gider: hızlı çalışana gönderilen zor bir görev size başarısız bir adım ve bir yeniden deneme kaybettirirken, Opus'a gönderilen kolay bir görev sadece biraz fazladan maliyet yaratır. Yani şüpheye düştüğünüzde işi yukarı devredin.
Hızlı çalışan olarak, girdi için milyon token başına 1 dolar ve çıktı için 5 dolar olan Haiku 4.5'i kullanıyorum. Uygulamalı örnekte, 36 gerçek iş adımının 12'si ona gidiyor.
Karar 3: Bir Araç Başarısız Olduğunda Kurtarma Yolunu Seçin
Araçlar sürekli hata verir. Testler zaman aşımına uğrar. Bir dosya yolu yanlıştır. Bir paket yüklü değildir. Bir shell komutu izin hatasına takılır. Bir linter alakasız bir şeyden şikayet eder.
Çoğu ajan bunu mümkün olan en pahalı şekilde ele alır: Tüm hatayı büyük modele geri iletir ve ne yapılacağını onun düşünmesine bırakır. Bazen bu doğrudur. Ancak çoğu zaman yanıt barizdir ve Opus, ENOENT'in dosyanın orada olmadığı anlamına geldiğini yeniden keşfetmek için 1.500 token harcar.
Daha da kötüsü, ajanlar döngülere girer. Yeniden dene, başarısız ol, yeniden dene, başarısız ol; her seferinde tam bir akıl yürütme adımının bedelini ödeyerek.
Bu yüzden hatayı, sabit bir kurtarma yolları listesiyle birlikte Jev'e verirsiniz:
from collections import deque
def tail(text: str, n: int = 4000):
return "".join(deque(text, maxlen=n)) # hatanın son n karakteri
def recover(tool: str, command: str, error: str, attempt: int):
if attempt >= 3:
return "stop_and_report"
d = decide(
context=f"TOOL: {tool}
COMMAND: {command}
ATTEMPT: {attempt}
ERROR:
{tail(error)}",
question="What is the best next move after this failure?",
options=RECOVERY,
threshold=0.8,
)
return d.answer if d.confident else "escalate_to_opus"
1RECOVERY = [2 "retry_unchanged", # kararsız ağ veya zaman aşımı3 "retry_after_install", # eksik paket veya araç4 "fix_path_and_retry", # yanlış dosya yolu veya cwd5 "switch_tool", # bu araç yapamaz, diğeri yapabilir6 "escalate_to_opus", # gerçek bir hata ayıklama gerekir7 "stop_and_report", # bir insan gerekiyor8]
Deneme sayısı üzerindeki katı sınır modelde değil, kodda yaşar. Hiçbir modelin, ne kadar ucuz olursa olsun, sonsuza kadar yeniden denemesine izin verilmemelidir.
Her kurtarma yolu, kontrol mekanizmanızdaki küçük bir fonksiyona eşlenir. retry_after_install, regex kullanarak eksik paketi hata mesajından okur ve onu yükler. fix_path_and_retry, mevcut yolları kontrol eder ve en yakın eşleşmeyi önerir. Gerçek parayı harcayan tek yol escalate_to_opus'tur ve o da yalnızca hata gerçekten düşünmeyi gerektirdiğinde tetiklenir.
Uygulamalı örnekte bu, oturumdaki 6 boşa harcanmış yeniden deneme adımını ortadan kaldırıyor.
Karar 4: Tam Test Paketine Geçmeden Önce Odaklı Kontrolleri Çalıştırın
Bu adım paradan çok zaman kazandırır ve bir ajanı hızlı hissettiren şey de zamandır.
Çoğu ajan, her değişiklikten sonra tüm test paketini çalıştırır. Test paketiniz dört dakika sürüyorsa, ajanınız her düzenlemeden sonra dört dakika bekler ve ardından önemli olan o tek hatayı bulmak için yüzlerce satırlık çıktıyı okur.
Çözüm, notlarla aynı mantıktır: Her test dosyasını diff'e göre puanlayın, en alakalı olanları önce çalıştırın ve tam paketi yalnızca odaklı kontroller geçtiğinde çalıştırın.
1def pick_tests(diff: str, test_files: list[str], keep: int = 12):2 def score(path):3 probs = jev_choice(4 context=f"DIFF:\n{diff[:12000]}\n\nTEST FILE: {path}",5 question="Could this change break tests in this file?",6 options=["likely", "unlikely"],7 )8 return probs["likely"], path910 with ThreadPoolExecutor(max_workers=16) as pool:11 scored = sorted(pool.map(score, test_files), key=lambda s: s[0], reverse=True)12 return [p for _, p in scored[:keep]]1314def check(diff: str, test_files: list[str]):15 focused = pick_tests(diff, test_files)16 if not run_tests(focused):17 return False # hızlıca başarısız ol, başka bir şeyden önce düzelt18 return run_tests(test_files) # tam paket yine de commit'in kapısıdır
Son satırı iki kez okuyun. Tam paket, herhangi bir şey commit edilmeden önce yine de çalışır. Odaklı kontroller bir erken uyarı sistemidir, tam paketin yerine geçmez. Çoğu kırılmayı dakikalar yerine saniyeler içinde yakalarsınız ve tam paketin yakalayacağı bir hatayı asla canlıya almazsınız.
Önce ucuz kontrolleri de ekleyin: Yalnızca değiştirilen dosyalarda tip kontrolü ve lint işlemi. Bunlar bir saniye sürer ve herhangi bir test çalışmadan önce şaşırtıcı derecede çok hatayı yakalar.
Hepsini Bir Araya Getirmek: Kontrol Döngüsü
İşte dört kararın döngünün tek bir adımına nasıl yerleştiği:
def run_step(task: str, step: str, state):
1. bağlam: yalnızca bu adımın ihtiyaç duyduğu notları yükle
notes = state.always_notes + pick_notes(step, state.notes)
2. yönlendirme: bu adım için çalışanı seç
worker = state.workers[route(step, state.recent_diff())]
result = worker.run(step, notes=notes, history=state.history)
3. kurtarma: bu adımdaki araç hatalarını yönet
for failure in result.failures:
action = recover(failure.tool, failure.command, failure.error, failure.attempt)
state.apply_recovery(action, failure)
4. kontroller: önce odaklı testler, commit öncesi tam paket
if result.diff:
state.log_check(check(result.diff, state.test_files))
Bir de Opus tarafı var: Bu sadece normal Opus 5.5 çağrınız. Adımlar arasında önbellekte kalması için sabit bağlamınızı (system prompt, araç tanımları, "always" notları) başa, adıma özel materyalleri ise sona koyun.
import os
import anthropic
client = anthropic.Anthropic()
OPUS = os.environ["OPUS_MODEL"] # opus 5.5 model kimliğiniz
def opus_step(system: str, notes: list[dict], history: list, step: str):
notes_text = "
".join(n["text"] for n in notes)
return client.messages.create(
model=OPUS,
max_tokens=8000,
system=[{"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}],
messages=history + [{"role": "user", "content": f"NOTES:
{notes_text}
STEP:
{step}"}],
)
Ortada egzotik bir şey yok. Tasarruf, zekice yazılmış bir prompt'tan değil, ona göndermeyi bıraktığınız şeylerden geliyor.
Adım Adım İzlenen Bir Süreç
Dört kararın da devrede olduğu bir durumda, loglarda tek bir adımın nasıl göründüğüne bakalım. Görev: herkese açık kayıt (signup) endpoint'ine hız sınırlaması (rate limiting) eklemek. Bu izleme temsili olsa da kendi loglarınızda göreceğiniz yapıyla birebir aynıdır.
adım 14 "POST /signup'a IP bazlı hız sınırı ekle"
[notlar] 41 parça paralel olarak puanlandı
tutulanlar: api/middleware.md (0.94), conventions/errors.md (0.88),
infra/redis.md (0.81), decisions/2025_auth.md (0.62)
elenenler: faturalama, e-posta şablonları, CI dahil 37 parça
[yön] new_logic (0.91) → opus
[opus] değişikliği planlar, middleware + config + handler düzenlemesini yazar
[araç] npm test BAŞARISIZ "Cannot find module 'bottleneck'"
[kurtar] retry_after_install (0.97) → npm install, yeniden çalıştır
[kontroller] değişen dosyalarda tip kontrolü: geçti
odaklı testler (1.388'den 12'si): geçti
tam paket: geçti
Yukarıdan aşağıya okuyun ve bu satırlardan kaçının eskiden tam bir Opus çağrısı olduğunu sayın. Not seçimi: Ya büyük bir çağrı ya da hiç seçim yapılmadan körü körüne yüklenen 30.000 token'lık not. Yönlendirme: Yoktu, her adım Opus'a gidiyordu. Eksik paket: Eksik bir modülün "modülü yükle" anlamına geldiğini çözmek için tam bir akıl yürütme adımı. Test seçimi: Yoktu, her düzenlemede tam paket çalışıyordu.
Şimdi ise o izlemede Opus olan yalnızca tek bir satır var ve o da gerçekten en üst düzey bir modele ihtiyaç duyan satır: hız sınırlayıcıyı planlamak ve yazmak.
Tüm fikir tek bir resimde özetleniyor. Pahalı model, zamanını yalnızca kendi yapabileceği iş kısmına harcıyor.
Uygulamalı Örnek: %69 Nereden Geliyor?
İşte tek bir özellik geliştirme oturumu için matematiğin tamamı: 60 ajan adımı artı tipik bir ajanın süreç boyunca biriktirdiği 6 boşa harcanmış yeniden deneme. Tüm fiyatlar güncel liste fiyatlarıdır.
Önce: Opus 5.5 her şeyi yapar
Her adım 70.000 token bağlam yükler: 15.000'i system prompt ve araçlar, 30.000'i tüm notlar klasörü, 25.000'i ise o ana kadarki konuşma için. Bunun %80'inin önbellekten geldiğini (cache hit) varsayıyorum. Opus 5.5'te düşünme modu her zaman açık olduğu için her adım yaklaşık 1.500 çıktı token'ı üretir.
önbellek okumaları: 56.000 × $0.20/M = $0.0112
yeni girdi: 14.000 × $4.00/M = $0.0560
çıktı: 1.500 × $20.00/M = $0.0300
adım başına = $0.0972
66 adım × $0.0972 = $6.42
Sonra: karar katmanı
Bağlam adım başına 46.000 token'a düşer, çünkü Jev 30.000 token'ın tamamını yüklemek yerine 6.000 token'lık not seçer. 24 saf karar adımı Jev'e taşınır. 6 yeniden deneme döngüsü ortadan kalkar. Kalan 36 iş adımının 12'si Haiku 4.5'e gider.
Opus 5.5: 24 adım × $0.0742 = $1.78
Haiku 4.5: 12 adım × $0.0169 = $0.20
Jev: 102 çağrı × 5.000 token
× $0.042/M, çıktı ücretsiz = $0.02
toplam = $2.00
6,42 dolardan 2,00 dolara. Aynı özellik için %68,8 daha ucuz.
eşiği, yanlış bir cevabın maliyetine göre belirle
Ve her bir kaldıracın sırasıyla dizilmiş katkısı:
yalnızca not seçimi $4.89 %23.7 tasarruf
- kararların Jev'e taşınması $3.13 %51.2 tasarruf
- kurtarma yolları $2.69 %58.1 tasarruf
- hızlı çalışana yönlendirme $2.00 %68.8 tasarruf
Bu matematikle ilgili iki dürüst not.
Birincisi, bunlar sizin altyapınızın ölçümü değil, açık varsayımlara dayanan modellenmiş rakamlardır. Sizin bağlam boyutunuz, önbellek isabet oranınız ve karar sayınız farklı olacaktır. Her satırı göstermemin amacı, kendi rakamlarınızı yerleştirebilmenizdir. Kendi gerçek "önce ve sonra" durumunuzu ölçtüğünüzde benimkini değil, kendi rakamınızı kullanın.
İkincisi, paranın aslında nereye gittiğine bakın. Jev'in 102 çağrısı toplamda iki sent tutuyor. Tasarruf, Jev'in çağrı başına ucuz olmasından gelmiyor. Jev kararı verdikten sonra gerçekleşmeyen her şeyden geliyor: şişirilmiş bağlam, çoktan seçmeli sorular için yapılan tam akıl yürütme adımları, yeniden deneme döngüleri ve yeniden adlandırma işleri için yapılan büyük model çağrıları.
Kararlar İçin Neden Sadece Haiku Kullanmıyoruz?
Makul bir soru. Haiku 4.5 ucuz ve hızlı. Neden yeni bir model ekleyelim ki?
Üç nedeni var.
Hâlâ metin yazıyor. Haiku metin olarak yanıt verir. Onu seçeneklerinizden biriyle yanıt vermesi için prompt'lamanız, ardından yanıtı ayrıştırmanız (parse), bazen açıklama eklediği, listede olmayan bir şeyi seçtiği veya yanıtı bir cümleye sardığı durumları yönetmeniz gerekir. Jev ise ilettiğiniz her seçenek için bir olasılık döner. Ayrıştırılacak bir şey ve listenin dışında bir sonuç yoktur.
Sadece bir yanıt değil, dağılımın tamamını alırsınız. Jev needed: 0.52, not_needed: 0.48 dediğinde bunun yazı tura gibi bir durum olduğunu anlarsınız ve kontrol mekanizmanız işi yukarı devredebilir. Bir metin modeli "gerekli" dediğinde, bundan ne kadar emin olduğu hakkında hiçbir fikriniz olmaz. Eşikler ancak olasılıkları görebildiğinizde işe yarar.
Maliyet matematiği farklıdır. Jev'in çıktısı ücretsizdir ve girdisi milyon token başına 0,042 dolardır. Her adımda 41 not parçasını puanlamak, adım başına 41 küçük çağrı demektir. Jev ile bu, bir sentin çok küçük bir kısmıdır. Ucuz bile olsa herhangi bir metin modeliyle bu, kendi çıktı maliyeti ve gecikmesi olan 41 üretim (generation) işlemidir.
Haiku'yu gerçekten kod yazması gereken küçük düzenlemelerde kullanın. Listelerden seçim yapmak için Jev'i kullanın. Düşünmek için Opus'u kullanın. Her model, tasarlandığı işi yapsın.
Hiçbir Şeyi Bozmadan Nasıl Hayata Geçirilir?
Dört kararın hepsini aynı anda açmayın. Benim kullanacağım sıra şu şekilde olurdu.
1. Hafta: gölge mod (shadow mode). Mevcut ajanınızı olduğu gibi bırakın. Verdiği her karar için aynı soruyu Jev'e de sorun ve her iki yanıtı artı Jev'in olasılığını loglayın. Jev'in yanıtına göre kesinlikle aksiyon almayın.
1def shadow(decision_name, context, question, options, current_answer):2 probs = jev_choice(context, question, options)3 jev_answer = max(probs, key=probs.get)4 log_row(5 decision=decision_name,6 current=current_answer,7 jev=jev_answer,8 prob=probs[jev_answer],9 agree=(jev_answer == current_answer),10 )
2. Hafta: anlaşmazlıkları okuyun. Yalnızca Jev ile mevcut ajanınızın farklı yanıt verdiği satırlara bakın. Bunları Jev'in olasılığına göre sıralayın. Genellikle net bir çizgi bulursunuz: Belirli bir olasılığın üzerinde Jev, Opus kadar sık doğru yanıt verir. O çizgi sizin eşiğinizdir. Bu anlaşmazlık satırları aynı zamanda gerçek trafiğinizden bedavaya oluşturulmuş test setiniz haline gelir.
3. Hafta: not seçimini açın. En büyük kaldıraç budur ve geri alınması en kolay olanıdır; çünkü gözden kaçan bir not loglarınızda hemen kendini belli eder.
4. Hafta: kurtarma ve testleri açın. Her ikisinin de kodda katı sınırları ve yedek planları vardır, bu yüzden en kötü senaryo bugün yaptığınıza geri dönmektir.
Son olarak: yönlendirme. Yönlendirme hataları kullanıcılar tarafından en kolay fark edilen hatalardır, çünkü hızlı çalışana gönderilen zor bir görev kötü kod üretir. Bunu en sona bırakın, muhafazakar bir eşik kullanın ve hızlı çalışandaki hata oranını izleyin.
Her kararı bir açma/kapama bayrağının arkasına koyun, böylece tek satırla geri alabilirsiniz.
Eşikleri Riske Göre Ayarlamak
Her şey için tek bir eşik kullanmak hatadır. Eşikleri, yanıt yanlış olduğunda ne olacağına göre belirleyin.
Tek bir özellik oturumu, aynı sonuç: 6,42 dolardan 2,00 dolara
Düşük riskli, geri alınması kolay: 0.55 - 0.65. Not seçimi. Testlerin sıralanması. Yanlış bir yanıt biraz bağlama veya birkaç saniyeye mal olur.
Orta riskli: 0.8. Yönlendirme ve kurtarma. Yanlış bir yanıt başarısız bir adıma mal olur ki bunu kontrol mekanizmanız yakalar.
Yüksek riskli, geri alınması zor: 0.9 veya asla. Dosya silme. Force push. Production konfigürasyonuna dokunma. Migration çalıştırma. Dürüst tavsiyem: Hiçbir modelin bu kararları tek başına vermesine izin vermeyin. Bunları bir insana veya en azından bir onay adımıyla Opus'a yönlendirin.
Eşiğin altında kalan her şey merdivenden yukarı çıkar: Akıl yürütme gerektiriyorsa Opus'a, muhakeme gerektiriyorsa bir insana.
Bu Yaklaşımın İşe Yaramadığı Yerler
Bu mimari, her iş yükünde sihirli bir çarpan etkisi yaratmaz.
Salt üretim (generation) iş yükleri pek değişmez. Ajanınız zamanının çoğunu net bir spesifikasyondan büyük miktarda yeni kod yazarak geçiriyorsa, taşınacak fazla karar yoktur. Not seçimi tasarrufunu elde edersiniz ama çok daha fazlasını değil.
Küçük projelerin buna ihtiyacı yoktur. Tüm notlar klasörünüz 2.000 token'sa ve test paketiniz sekiz saniyede çalışıyorsa, bunu kurmanın getireceği ek yük henüz buna değmez.
Jev son kararı tek başına vermekte pek iyi değildir. Bir şeyleri fark etmekte ve kısa bir listeden seçim yapmakta mükemmeldir. Ancak "bu pull request merge edilmeye hazır mı?" gibi tek bir soruya karar veren model olmasını istemezsiniz. Büyük soruları küçük sorulara bölün, her birini puanlayın ve sonuçları kendi kodunuzda kendi ağırlıklarınızla birleştirin.
Sabit bir soru için zaten etiketlenmiş verileriniz varsa, kendi barındırdığınız küçük bir model fiyat konusunda Jev'i geçebilir. Jev, soruların sürekli değiştiği ve eğitim verinizin olmadığı durumlarda parlar ki bu da çoğu kodlama ajanını tanımlar.
Kaçınmam Gereken Hatalar
Seçenek listesini modelin yazmasına izin vermek. Mimarinin tamamı, kodunuzun aksiyon alabileceği seçeneklere bağlıdır. Eğer seçenekleri bir model üretirse, serbest metni ayrıştırma noktasına geri dönersiniz.
Jev'e emin olup olmadığını sormak. Bunun yerine olasılığı okuyun. Öz değerlendirme neredeyse her zaman "evet"tir.
Yedek plan olmaması. Her Jev kararının "emin değilim" durumu için bir yolu olmalıdır ve bu yol Opus veya bir insandır, asla tahmin yürütmek değildir.
Yeniden deneme sınırlarını kod yerine prompt'a koymak. "Sadece 3 kez yeniden dene" denilen bir model ara sıra 30 kez yeniden deneyecektir. Kod ise denemez.
Tam test paketini iptal etmek. Odaklı kontroller sizi hızlandırır. Tam paket ise sizi dürüst tutar. İkisini de koruyun.
Hiçbir şeyi ölçmemek. Başlamadan önce oturum başına maliyeti kaydetmezsen, %20 mi yoksa %70 mi tasarruf ettiğini asla bilemezsin. Önce normal bir iş haftasının kullanım verilerini çek. On dakika sürer ve önemli olan tek rakam budur.
Bu Hafta Yapman Gerekenler
İşte her şeyin bir kontrol listesi hâli:
- Bir haftalık ajan oturumlarını kaydet: adımlar, token'lar, maliyet, hatalar.
- Döngünde gizlenen kararları bul: notlar, yönlendirme, kurtarma, testler.
- Her birini sabit seçenekli bir soru olarak yaz.
- Jev'i bir hafta boyunca mevcut ajanının yanında shadow (gölge) modda çalıştır.
- Anlaşmazlık günlüğünden risk seviyesine göre eşik değerleri belirle.
- Önce not seçimini, ardından kurtarma ve testleri, en son da yönlendirmeyi aç.
- Öncesi ve sonrası oturum başına maliyeti karşılaştır. Aradığın rakam bu.
Opus 5.5, kod için kullandığım en iyi akıl yürütme modeli. Hata, diğer her şeyi de ona yaptırmak.
Bırak düşünsün. Bırak Jev karar versin. Bırak kodun hüküm sürsün.
Bu içerik işine yaradıysa @cyrilXBT hesabını takip et. Her hafta en yeni AI modelleriyle nasıl geliştirme yapılacağını gerçek rakamlarla anlatıyorum.
Geliştirmeye başladığında elinin altında olması için bu sayfayı yer imlerine ekle.
