Bunu yaşıyorsan

Çok ajanla çalışıyorsan

Kendi Mac'imde aynı anda onlarca ajanla çalışırken yaşadığım ve çözdüğüm durumlar. Seninkini bul, kararı ajanına ver.

Ajanın «bitti» cümlesini okumuyorum, tanığa bakıyorum; tanığın türünü işin değiştirdiği şey belirliyor: ekran değiştiyse görüntüsü, klasör düzeni değiştiyse önce ve sonra ağacı, kod değiştiyse commit, bir komut koştuysa çıktısının yazıldığı dosya. Bunu ajana her oturumda yüklenen talimatla söylüyorum. Commit'i ajanın cümlesinden değil durum çubuğundan okuyorum: çubuk git'e bakıyor, ajan yazmasa da görüyorum. Ajanın mesajında «bitti» arayıp turu geri çeviren bir kanca kurmuyorum. Doğrulama bir kez bozuk hâlde de koşuluyor, dışarı gidecek işi de onu hiç görmemiş ikinci bir ajan baştan uyguluyor.
önceajanın «doğrulandı» dediği 3 işin 3'ü bozuktu
sonraişi görmemiş ajanın son koşusunda kırık 0
her «bitti»nin yanına açılabilir tanığını koy: değişen dosyanın yolu, ekran görüntüsü ya da commit; bunu kalıcı talimatına yaz, commit'leri de durum çubuğunda git'ten göster
Ajana giden metin · 50 satır
Durum: ajan «bitti · düzelttim · testler geçti» diyor, cevabı uzun; okuyup inanıyorsun ya da her şeyi kendin açıp bakıyorsun. Açınca iş bitmemiş çıkıyor.

Neden: ajanın cümlesi işin durumu değildir; denetimi cümleye değil tanığa bakarak yaparsın (ekran görüntüsüne bakmak, commit'i açmak, komutun çıktısını görmek uzun metni okumaktan hızlıdır). Ajan kendi doğrulamasını kendisi yazıp kendisi koşunca doğrulama satırı bozuk hâlde de geçebilir: hiçbir şey bulamayınca boş dönen bir arama, yalnız ana süreci sayan bir kontrol. Bende ajanın «Doğrula satırları geçti» dediği üç işi onları hiç görmemiş bir ajan temiz bir makinede baştan uyguladı; üçünde de iş bozuktu (birinde git'in 16 arka plan süreci sahipsiz koşuyordu, birinde sır commit'e girmişti) ve doğrulama yine «geçti» demişti. Tanığı ajandan kancayla zorlamıyorum: mesajdaki kelimeye bakan denetim güvenilmez, aynı şey her seferinde başka kelimeyle söylenir. Tur sonunda commit'ini göstermeyen cevabı geri çeviren bir kanca tanımını geçmişte denedim: bir günün commit atılan 273 turunda 44 kez geri çevirirdi, yalnız 10'u yerindeydi (2026-11-13). Talimat yetiyor, gerisini git söylüyor: durum çubuğu ajanın ne dediğine değil depoya bakar.

Yap (Claude Code, proje içinde; jq gerekir: command -v jq · macOS 27.2'de /usr/bin/jq hazır gelir, yoksa brew install jq):
1. Proje kökündeki CLAUDE.md dosyasına (yoksa aç) şu bölümü ekle. Aşağıdaki blokların başındaki üç boşluk bu listenin girintisidir, dosyaya yazarken sil.
   ## Tanık
   «bitti · düzelttim · geçti» dediğin her işin yanına açıp bakabileceğim tanığını koy; tanığın türünü işin değiştirdiği şey belirler:
   - kod ya da dosya değiştiyse: commit kimliği; commit atmadıysan değişen dosyanın yolu
   - ekranda görünen bir şey değiştiyse: ekran görüntüsünün dosya yolu
   - klasör düzeni değiştiyse: önce ve sonra ağacı
   - bir komut koştuysan (test, ölçüm): çıktısını yazdığın dosyanın yolu
   - tanığın yoksa: «ölçülmedi: <ne>» satırı
   Kendi özetin («testleri koştum, geçti») tanık değildir. Doğrulamayı bir kez bilerek bozuk hâlde de koş: bozukken de geçiyorsa hiçbir şey ölçmüyordur.
2. Commit'i ajanın yazmasına bırakma, durum çubuğunda git'ten göster.
   .claude/statusline-tanik.sh:
   #!/bin/sh
   d=$(jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null)
   cd "${d:-.}" 2>/dev/null || exit 0
   git rev-parse --git-dir >/dev/null 2>&1 || { echo "git deposu değil"; exit 0; }
   n=$(git log --since='1 hour ago' --oneline 2>/dev/null | wc -l | tr -d ' ')
   m=$(git --no-optional-locks status --porcelain 2>/dev/null | wc -l | tr -d ' ')
   son=$(git log -1 --since='1 hour ago' --format='%h %s' 2>/dev/null)
   echo "son 1 saat: $n commit · commit'lenmemiş $m değişiklik${son:+ · son: $son}"
   .claude/settings.json (dosya yoksa bu satırla aç; varsa "statusLine" anahtarını ekle; zaten bir "statusLine" komutun varsa ona dokunma, bu betiğin çıktısını kendi komutunun çıktısına ekle):
   {"statusLine":{"type":"command","command":"sh \"$CLAUDE_PROJECT_DIR\"/.claude/statusline-tanik.sh"}}
   Çubuk Claude Code penceresinde giriş kutusunun altında durur ve ajan çalışırken kendiliğinden yenilenir. Ajan «bitti» deyince çubuğa bak: commit sayısı artmadıysa ve commit'lenmemiş değişiklik de yoksa depoda hiçbir şey değişmemiştir.
3. Başkasına gidecek ya da geri alınamayan bir iş bitince (yayın, paket, başka birinin deposu) doğrulamayı yazan ajana bırakma: işi hiç görmemiş ikinci bir ajana (Claude Code'da yeni bir oturum ya da alt ajan) yalnız işin talimatını ver, temiz bir klasörde harfiyen uygulasın ve her doğrulama komutunu gerçek çıktısıyla getirsin. Eksik bulduğu her yer bir bulgudur; bulgu 0 olana dek talimatı düzelt ve yeniden uygulat.

Doğrula:
- Talimat (proje kökünde): grep -c '^## Tanık' CLAUDE.md → 1
- Çubuk, sahte bir depoda (proje kökünde koş; tanımı ve çağrıları aynı komutta koş, her araç çağrısı yeni kabuk açar):
  k="$PWD/.claude/statusline-tanik.sh"; s=$(mktemp -d); git -C "$s" init -q
  p() { jq -nc --arg d "$1" '{workspace:{current_dir:$d}}' | sh "$k"; }
  c() { git -C "$s" add -A && git -C "$s" -c user.name=t -c user.email=t@t commit -qm "$1"; }
  p "$s"                                  → son 1 saat: 0 commit · commit'lenmemiş 0 değişiklik
  touch "$s/a.txt"; p "$s"                → son 1 saat: 0 commit · commit'lenmemiş 1 değişiklik
  GIT_AUTHOR_DATE=2020-01-01T00:00:00 GIT_COMMITTER_DATE=2020-01-01T00:00:00 c eski; p "$s"
                                          → son 1 saat: 0 commit · commit'lenmemiş 0 değişiklik (eski commit sayılmaz)
  touch "$s/b.txt"; c yeni; p "$s"        → son 1 saat: 1 commit · commit'lenmemiş 0 değişiklik · son: <7 haneli kimlik> yeni
  n=$(mktemp -d); p "$n"                  → git deposu değil
  rm -rf "$s" "$n"
  Çubuk her yerde aynı satırı basıyorsa ikinci ve dördüncü satır tutmaz; tek başına okunan bir satır bunu ayırmaz.
- Kayıt: jq -r '.statusLine.command' .claude/settings.json → içinde statusline-tanik.sh geçen komut
- Canlı: projede Claude Code'u aç (klasöre güvenip güvenmediğini sorarsa «Yes, I trust this folder»ı seç). Giriş kutusunun altında «son 1 saat: … commit · commit'lenmemiş … değişiklik» satırı görünür. Ajana küçük bir dosya değişikliği yaptırıp commit attır: çubuktaki commit sayısı bir artar ve «son:» o commit'i gösterir; bunu görmek için ajanın cevabını okuman gerekmez.

Yapma:
- Tanık yerine ajanın kendi özetini kabul etme («testleri koştum, hepsi geçti» bir tanık değil, tanığın anlatısıdır).
- Doğrulamayı yalnız sağlam hâlde koşma: bozuk hâlde de geçen doğrulama hiçbir şey ölçmez.
- Ajanın ya da kendi mesajındaki kelimeye bakan kanca kurma («bitti» arayıp turu geri çeviren tur sonu kancası gibi): söz her seferinde başka kelimeyle söylenir; kanca doğru cevabı geri çevirir, yanlışı kaçırır. Kanca kuracaksan söze değil yapıya bağla: koşan komut, dokunulan dosya.
Git'in her commit'ten sonra kendiliğinden başlattığı bakımı kapattım; bakım artık saatte bir, tek kopya koşuyor.
önceaynı anda 76 git bakımı
sonraen çok 1
git'in otomatik bakımını (gc.auto · maintenance.auto) kapat, saatlik zamanlanmış bakıma geç
Ajana giden metin · 23 satır
Durum: aynı git deposunda çok ajan sık commit atıyor. Etkinlik Monitörü'nde aynı anda çok sayıda `git maintenance run --auto`, `git repack` ve `git pack-objects` süreci var; makine ısınıyor.

Neden: git her commit'ten sonra eşik aşılınca arka planda bakım başlatır (`git maintenance run --auto --detach`). Bu arka plan koşusu kilit tutmuyor (git 2.54'te gözlendi): bir repack dakikalarca sürerken gelen her commit yenisini başlatır. Bende 10 dakikada 76 eşzamanlı repack oldu, her biri 11 GB'lık geçmişi baştan paketledi ve yarışta bir commit nesnesi kayboldu.

Yap:
1. Bu depoda commit'e bağlı bakımı kapat:
   git config --local gc.auto 0
   git config --local maintenance.auto false
2. Koşan bakımları çocuk süreçleriyle birlikte durdur, bir dakika sonra geride bıraktıkları geçici paketleri sil (bu, makinedeki bütün depoların bakımını durdurur; push, fetch ve clone koşmaya devam eder):
   pkill -TERM -f 'git(-core/git)? (maintenance run|repack|pack-objects .*objects/pack/)'
   sleep 60; find "$(git rev-parse --git-path objects/pack)" -name 'tmp_*' -mmin +1 -delete
3. Bakımı tek kopya, zamanlanmış koşacak şekilde kur:
   git maintenance start
   git config --local maintenance.gc.enabled false
   git config --local maintenance.prefetch.enabled false
   git config --local maintenance.loose-objects.schedule hourly
   git config --local maintenance.incremental-repack.schedule daily

Doğrula:
- git fsck --connectivity-only --no-reflogs --no-dangling → hiçbir şey basmaz (kayıp nesne yok)
- pgrep -f 'git(-core/git)? (maintenance run|repack|pack-objects .*objects/pack/)' | wc -l → 0 (yalnız saatlik zamanlanmış koşu sürerken 0'dan büyük)

Yapma: bu sırada tam `git gc` ya da `git repack -a` başlatma.
Bu durum şurada da: Laptop ısınıyorsa
Her ajan kendi git worktree'sinde çalışıyor; worktree'yi git'in kopyasıyla değil Mac'in dosya klonuyla (APFS) açıyorum, böylece ek disk neredeyse sıfır. Ortak çalışma ağacında ajanın commit'i reddediliyor; ben notlarımı orada commit'lemeye devam ediyorum.
öncetek ortak ağaç · her worktree deponun tam kopyası
sonra115 worktree · worktree başına ek disk ≈ 0
her ajana ayrı bir git worktree aç, ortak ağaçta commit atma
Ajana giden metin · 36 satır
Durum: birden çok ajan aynı depo klasöründe çalışıyor. Bir ajan commit atınca ötekinin sahnelediği (staged) değişiklik de commit'e giriyor ya da ajanlar birbirinin dosyasının üstüne yazıyor.

Neden: bir git çalışma klasörünün tek index'i ve tek dosya kümesi var. Aynı klasördeki bütün ajanlar ikisini de paylaşıyor: `git add` ile sahnelenen her şey bir sonraki commit'e girer, kimin sahnelediğine bakılmaz; aynı dosyayı düzenleyen ajanlar birbirinin üstüne yazar.

Yap:
1. Her ajana kendi worktree'sini aç. `git worktree add` her dosyayı yeniden yazar: her worktree deponun tam kopyası kadar disk yer (200 MB'lık depoda +200 MB). Mac'te (APFS) dosyaları kopyalama, klonla; ek disk ≈ 0. Ortak klasör temizken (git status --short boş) orada koş; `?? .env` görünüyorsa önce `echo .env >> .git/info/exclude` koş (commit istemez, .env'i bütün worktree'lerde yok sayar), yoksa ilk commit'te sır dala girer:
   git worktree add --no-checkout ../<ajan-adı> -b <ajan-adı>
   git ls-tree --name-only -z HEAD | xargs -0 -I{} cp -c -R ./{} ../<ajan-adı>/
   (cd ../<ajan-adı> && git read-tree HEAD && git update-index -q --refresh)
   APFS değilse (Linux, Windows) ya da depoda alt modül varsa düz `git worktree add ../<ajan-adı> -b <ajan-adı>` kullan.
   Yeni worktree'de git'in izlemediği üst düzey dosyalar (.env, node_modules) yoktur: .env'i kopyala, bağımlılıkları orada yeniden kur.
2. Ajan yalnız kendi worktree'sinde düzenler ve commit atar.
3. Ortak klasörde ajanın commit'ini git yapılandırma kancasıyla reddet (core.hooksPath ya da husky .git/hooks'u kapatmış olsa da koşar). Kanca yalnız ajanın ortamını (Claude Code, Codex) reddeder; sen terminalde orada commit atmaya devam edersin:
   git config hook.ortak-kapisi.event pre-commit
   git config hook.ortak-kapisi.command 'i="${GIT_INDEX_FILE:-index}"; case "${i##*/}" in index|index.lock) ;; *) exit 0;; esac; [ -z "${CLAUDECODE:-}${CLAUDE_CODE_SESSION_ID:-}${CODEX_THREAD_ID:-}" ] || [ "$(git rev-parse --path-format=absolute --git-dir)" != "$(git rev-parse --path-format=absolute --git-common-dir)" ] || { echo "ortak klasörde ajan commit atamaz: kendi worktree klasöründe commit at" >&2; exit 1; }'
   Kanca bütün worktree'lerde ortaktır; koşulu ortak klasörü ayırır (yalnız orada git-dir = git-common-dir). `git commit --no-verify` kancayı atlar; yol verilen commit (`git commit -- <yol>`) de kancadan geçer ve o yolda başkasının sahnelediğini alır: ajanına ortak klasörde ikisini de kullanmamasını söyle.
   Bu kanca biçimini git 2.54'te ölçtüm (git --version). Daha eski git yapılandırma kancasını tanımaz ve bu iki satır hata vermeden etkisiz kalır: ortak klasörde commit geçer. Sürümün eskiyse önce git'i güncelle (brew install git), sonra bu adımı koş; Doğrula'daki git hook run satırı kancanın gerçekten koştuğunu gösterir.
4. İşi ana dala tek tek indir. İki iniş aynı anda koşarsa biri «index.lock: File exists» ile düşer ∨ ortak klasörün index'inde öteki ajanın dosyası sahnelenmiş kalabilir (bende 40 denemenin 33'ünde kaldı, başka bir makinede 50'de 0); bu yüzden inişi bir kilitle sırala (fonksiyonun tanımı ∧ çağrısı aynı komutta koşar; ajan kabukları komutlar arasında fonksiyon taşımaz):
   inis() { L="$(git rev-parse --path-format=absolute --git-common-dir)/inis.lock"; got=; for n in $(seq 300); do mkdir "$L" 2>/dev/null && { got=1; break; }; sleep 0.2; done; [ -n "$got" ] || { echo "iniş kilidi 60 sn dolu: $L (iniş sürmüyorsa sil)"; return 1; }; git merge --ff-only "$1"; rc=$?; rmdir "$L"; return $rc; }
   git -C ../<ajan-adı> rebase <ana-dal>
   (cd <ortak-klasör> && inis <ajan-adı>)
   Ortak klasörde yalnız bu iniş koşar. «Not possible to fast-forward» derse araya başka iniş girmiştir: rebase adımına dön; git'in önerdiği `merge --no-ff`'i kullanma.
5. İş bitince:
   git worktree remove ../<ajan-adı>
   git branch -d <ajan-adı>
   remove «modified or untracked files» diyorsa: dosya çöpse sil; işse önce o worktree'de commit at, 4. adımla indir, sonra kaldır. --force ∨ branch -D kullanma: ana dala inmemiş iş kaybolur. (Kopyaladığın .env de silinir; asıl .env ortak klasörde durur.)

Doğrula:
- yeni worktree'de, .env'i kopyaladıktan sonra git status --short → boş
- git worktree list → çalışan ajan sayısı + 1 satır (ilk satır ortak klasör); işi biten worktree listede kalmamalı
- git -C <ortak-klasör> status --short → boş
- ajan ortak klasörde git hook run pre-commit koşar → «ortak klasörde ajan commit atamaz» ∧ çıkış 1 (commit atmadan kancayı koşar); aynı komutu sen terminalde koşarsan çıkış 0
- bir ajanın worktree'sinde git hook run pre-commit → çıkış 0
- git hook list --show-scope pre-commit → «local	ortak-kapisi» (core.hooksPath ∨ husky .git/hooks'u kapatmış olsa da görünür)

Yapma: aynı worktree'yi iki ajana verme; git bunu engellemez, sen tutarsın.
Ajanlara önden ortak arayüz yazdırıp onları sıraya sokmuyorum: hepsi aynı anda, her biri kendi worktree'sinde başlıyor. Birleştirirken iki ajanın ayrı yazdığı aynı parça ya da aynı satırdaki çakışma bana paylaşılan parçanın yerini söylüyor; onu o an tek dosyaya topluyorum, kopyayı aynı commit'te siliyorum.
önceortak parçayı yazan ajan inene dek onu kullanacak ajan bekliyordu
sonrahepsi aynı anda · kopya inişte 6 dk 43 sn'de tek yere indi · haftada 3.393 ajan dalı commit'i main'e iniyor
ajanlara önden ortak arayüz yazdırma; hepsini aynı anda kendi dalında çalıştır, birleştirmeden önce iki dalın aynı adla yazdığı ya da çakıştığı parçayı listele, onu tek dosyaya topla ve kopyayı sil
Ajana giden metin · 30 satır
Durum: birden çok ajanı ayrı dallarda (git worktree) aynı anda çalıştırıyorsun. Birleştirirken ya iki ajanın aynı işi yapan iki ayrı fonksiyonu çıkıyor ya da aynı dosyada çakışma. Önerilen yol «önce ortak arayüzü yaz, ajanları ondan sonra başlat».

Neden: ortak parçanın nerede olduğu önden bilinmez, birleştirmede görünür. Önden yazılan arayüz bir ajanın işini ötekinin inişine bağlar; bende bu sıra okuyucu ajanı üreticinin inişine dek bekletiyordu, kaldırınca hepsi aynı anda doğdu. İki ajanın aynı adla yazdığı fonksiyon ya da aynı satırdaki çakışma paylaşılan parçanın kendisidir: bende ikinci ajanın yazdığı kopya birleştirmeden 6 dk 43 sn sonra tek yere toplandı ve silindi. Kopyanın bedeli bir birleştirme turu; bekleyişin bedeli her ajanın turu.

Yap:
1. Her ajan kendi dalında ve worktree'sinde çalışır; ortak arayüz için ayrı ön iş açma, ajanları aynı anda başlat.
2. Birleştirmeden önce dalları yan yana tarayan betiği proje köküne .agents/twins.sh olarak yaz (git 2.38 ya da yenisi gerekir: git --version); dosya aşağıdaki bloktur:
   for r in "$@"; do git rev-parse -q --verify "$r^{commit}" >/dev/null || { echo "dal yok: $r"; exit 1; }; done
   for b in "$@"; do git diff --no-color --no-ext-diff -U0 "HEAD...$b" -- . | sed -nE 's/^\+([a-z]+[[:space:]]+)*(function|const)[[:space:]]+([A-Za-z_][A-Za-z0-9_]*).*/\3/p' | sort -u | sed "s|\$| $b|"
   done | while read -r n b; do git grep -qE "(function|const)[[:space:]]+$n([^A-Za-z0-9_]|$)" HEAD -- . || echo "$n $b"; done \
     | awk '{n[$1]++; w[$1]=w[$1]" "$2} END {for (k in n) if (n[k]>1) print "aynı ad: " k " ·" w[k]}' | sort
   i=0
   for a in "$@"; do i=$((i+1)); j=0
     for c in "$@"; do j=$((j+1)); [ $j -le $i ] && continue
       r=$(git merge-tree --write-tree --name-only "$a" "$c") && continue
       echo "çakışma: $a ↔ $c · $(printf '%s\n' "$r" | awk 'NR>1 && $0=="" {exit} NR>1 {printf "%s%s", s, $0; s=" "}')"
     done
   done
3. Ajanların işi bitince, proje kökünde taban dal (ajanların ayrıldığı dal, ör. main) açıkken koş: sh .agents/twins.sh <dal-1> <dal-2> … Betik iki tür satır basar: «aynı ad» (tabanda olmayan ama iki ya da daha çok dalın girintisiz satırda function ya da const ile yeni tanımladığı ad) ve «çakışma» (birleşmeyen dal çifti ve çakışan dosyaları).
4. Dalları tabana sırayla birleştir; «çakışma» satırındaki dosyaları o birleştirmede elle çöz. Hepsi inince her «aynı ad» satırının kopyaları aynı işi yapıyorsa doğru davrananı bırak, ötekileri sil ve onları çağıranları kalana bağla.
5. Ajanının her oturumda okuduğu talimat dosyasına (Claude Code: CLAUDE.md · Codex: AGENTS.md) iki satır ekle:
   Ortak parça için önden arayüz isteme ya da başka bir ajanı bekleme; kendi dalında ihtiyacın olanı yaz.
   Birleştirmeden önce taban dal açıkken sh .agents/twins.sh ve ardından birleşecek her dalın adı koşulur; bastığı parçalardan aynı işi yapanlar tek dosyaya toplanır, kopya silinir.

Doğrula (proje kökünde, tek komut olarak: betiği kendi açtığı geçici depoda sınar ve sonunda siler, senin dallarına dokunmaz):
- sh -c 's=$1; d=$(mktemp -d) && cd "$d" || exit 9; g() { git -c user.name=t -c user.email=t@t -c commit.gpgsign=false -c core.hooksPath=/dev/null "$@"; }; g init -q -b main; printf "export function tarih() {}\nexport function slugifyAll() {}\nexport function eski() {}\n" > taban.ts; g add -A; g commit -qm taban; for b in a b c; do g branch $b; done; printf "export function tarih() {}\nexport function slugifyAll() {}\n" > taban.ts; g commit -qam ilerle; g checkout -q c; for f in c c2; do printf "export function baska() {}\n" > $f.ts; done; g add -A; g commit -qm c; for b in a b; do g checkout -q $b; k="function slugify(s) { return s }"; [ $b = b ] && k="const slugify = (s) => s"; printf "export $k\nexport function tarih() {\n  const r = 1\n}\n" > $b.ts; for f in ortak yan; do printf "x = $b\n" > $f.txt; done; g add -A; g commit -qm $b; done; g checkout -q main; sh "$s" a c b; sh "$s" a d b; cd /; rm -rf "$d"' _ "$PWD/.agents/twins.sh"
- → harfiyen bu üç satır: «aynı ad: slugify · a b» · «çakışma: a ↔ b · ortak.txt yan.txt» · «dal yok: d».

Yapma:
- Ortak arayüzü önden yazdırıp ajanları onun inişine bekletme: hangi parçanın paylaşıldığını birleştirme gösterir, önceden yazılan arayüz çoğu zaman yanlış yerde durur.
Kuralı metin olarak tekrarlamıyorum: ajan yanlış komutu çalıştırmak üzereyken bir kanca onu reddediyor ve yerine geçen komutu söylüyor. Reddi yalnız hamlenin değişmesi şart olan yerde kuruyorum, çünkü her ret ajana bir adım daha ödetiyor; önerdiği yolun da gerçekten geçtiğini sınıyorum.
önceuyarıdan sonra düzeltme %36
sonraretten sonra %95 durdu · önerilen yolu ayrıca sına
kuralı uyarı olarak değil, yanlış komutu reddedip yerine geçeni söyleyen bir kanca olarak kur; yalnız geri alınamayan ya da pahalı hatada
Ajana giden metin · 58 satır
Durum: ajanına bir kural yazdın (CLAUDE.md, istem ya da bir kancanın bastığı uyarı) ama ajan aynı hamleyi yapmaya devam ediyor.

Neden: ajan uyarıyı okur ama hamlesini çoğu kez değiştirmez; reddi düzeltir. Bende (Claude Code, 1–12 Kasım, 34.053 kanca olayı) bir kanca eylemi geçirip uyarı bastıktan sonra ajan aynı eylemi yeniden denediğinde %36'sında düzeltti, eylemi reddettiğinde %95'inde. Uyarı oranı tek bir uyarı kancasından, ret oranı dokuz ret kancasından geliyor. Komut koşmadan önce ajana eklenen bağlam notu komutu durdurmadı: küçük bir modelle 3 denemenin 3'ünde pahalı komut yine koştu.
Ret durdurur ama önerdiği yolu her zaman seçtirmez: denemede ret 3 denemenin 3'ünde durdurdu, önerilen komutu 1'inde seçtirdi. Önerilen yol başka bir kural tarafından reddediliyorsa ajan yol uydurur; bende bir ret kendi önerdiği okumayı da reddediyordu.
Ret bedava değil: reddedilen araç çağrısı baştan üretilir (yazılacak dosya yeniden yazılır), her ret ajana bir model adımı daha ödetir. Kanca eşleşen her araç çağrısında koşar: yavaşlarsa bütün ajanlar bekler, çökerse hepsi durur. Ret, ajanın gerçekten üretemeyeceği bir şeyi (gerekçe, kaynak, «test ettim») isterse ajan reddi geçmek için onu uydurur.

Yap:
(1–4 kendi kuralın içindir. Elinde kural yoksa ve yalnız yöntemi deniyorsan 5'teki örnek kuralla kur.)
1. Önce kancasız yolları dene; ilk tutan kazanır, kanca kurulmaz:
   a. Kuralla çelişen ya da yanlışı öğreten kendi metnin var mı (CLAUDE.md'de eski bir satır, bir betiğin bastığı örnek komut)? Onu düzelt; üstüne kanca koyma.
   b. Yanlışı yapan komut ya da betik senin elindeyse reddi oraya koy (betik yanlış argümanla hata verip doğrusunu söylesin); her araç çağrısında koşan kancaya değil.
   c. Hata kendini zaten söylüyorsa (derleyici hatası, komutun hata çıkışı) kanca kurma; ajan onu görür ve düzeltir.
2. Yanlış tek bir araç çağrısının girdisinden (komut metni, dosya yolu, içerik) tanınabiliyor mu? «Yeterince düşünmedi» gibi girdiden tanınmayan bir yanlışa kanca kurma.
3. Ret mi, uyarı mı, hiç mi:
   - Yanlış geri alınamıyorsa (silme, yayımlama, paylaşılan dalı ezme) → ret.
   - Geri alınabiliyor ve sonra kendini söylüyorsa → kanca yok.
   - Arası için tart: ret ⟺ isabet × (0,95 − 0,36) × kaçan bir yanlışın bedeli > bir ek model adımı. İsabet, kancanın ateşlediği çağrıların gerçekten yanlış olan payıdır; doğru hamlede de ateşleyen kancada ret pahalıdır, önce eşleşmeyi daralt.
   - Uyarı yazacaksan kural değil sonuç yaz («bu komut 40 sn sürdü, 2 GB yazdı»). Kural cümlesi ya da «şu dosyayı oku» basma: ajan adresi açmaz, kopyalanan kural da asıl kural değişince eskir.
4. Ret metni iki parça: reddedilen ve yerine geçen tam komut, örnek:
   RED: git push --force → git push --force-with-lease · başkasının gönderdiğini ezmez
   Yerine geçen yol yazılmazsa ajan kendi yolunu uydurur. Yerine geçen komut ajanın makinesinde zaten var olmalı: kurulum isteyen bir aracı ret metnine yazma.
5. Kur (Claude Code, proje içinde; jq gerekir: command -v jq, yoksa brew install jq). Aşağıdaki blokların başındaki üç boşluk bu listenin girintisidir, dosyaya yazarken sil. Örnek tek bir kuralı taşıyor: «paylaşılan dalı --force ile ezme». Kendi kuralın için yalnız `yanlis` desenini ve ret metnini değiştir.
   .claude/hooks/kural.sh:
   #!/bin/sh
   command -v jq >/dev/null 2>&1 || { echo "kural.sh: jq bulunamadı, kanca karar veremiyor" >&2; exit 2; }
   cmd=$(jq -r '.tool_input.command // empty')
   log="$(dirname "$0")/kural.log"
   yanlis='(^|[;&|(])[[:space:]]*([A-Za-z_][A-Za-z0-9_]*=[^[:space:]]*[[:space:]]+)*git[[:space:]]+push([[:space:]]+[^;&|]*)?[[:space:]](--force|-[A-Za-z]*f[A-Za-z]*)([[:space:];&|)]|$)'
   if printf '%s' "$cmd" | grep -Eq "$yanlis"; then
     printf '%s\tret\n' "$(date +%FT%T)" >> "$log"
     jq -n '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:"RED: git push --force → git push --force-with-lease · başkasının gönderdiğini ezmez"}}'
     exit 0
   fi
   .claude/settings.json (varsa hooks altına ekle):
   {"hooks":{"PreToolUse":[{"matcher":"Bash","hooks":[{"type":"command","command":"sh \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/kural.sh","timeout":5}]}]}}
   Günlük dosyasını depoya sokma: printf '\n.claude/hooks/kural.log\n' >> .gitignore (baştaki boş satır, .gitignore yeni satırla bitmiyorsa son kuralına yapışmayı önler)
   Eşleyiciyi dar tut ("matcher": "Bash"). Günlüğe komut metni yazılmaz (komut satırında sır olabilir), yalnız zaman ve karar yazılır.

Doğrula:
- Sahte olayı kancaya veren yardımcı. Proje kökünde koş (.claude klasörünün durduğu yer); tanımı ve çağrıları aynı komutta koş (her araç çağrısı yeni kabuk açar). Yardımcı kancayı settings.json'da yazılı komutla çağırır.
  ev() { command -v jq >/dev/null || { echo "jq yok"; return 1; }; k=$(jq -r '.hooks.PreToolUse[].hooks[] | (.command // "") | select(test("kural[.]sh"))' .claude/settings.json | head -1); [ -n "$k" ] || { echo "settings.json'da kural.sh yok"; return 1; }; jq -nc --arg c "$1" '{tool_name:"Bash",tool_input:{command:$c}}' | CLAUDE_PROJECT_DIR="$PWD" sh -c "$k"; echo "çıkış $?"; }
- Eşleyici: jq -r '.hooks.PreToolUse[] | select(any(.hooks[]; (.command // "") | test("kural[.]sh"))) | .matcher' .claude/settings.json → Bash (büyük B ile; "bash" yazılırsa Claude Code kancayı hiç çağırmaz). Bu satır yalnız settings.json'u okur; kancanın kendisini aşağıdaki üç satır sınar.
- Üç satır birlikte okunur:
  ev 'git push --force'            → "deny" içeren JSON, sonra «çıkış 0»
  ev 'git push --force-with-lease' → yalnız «çıkış 0» (retin önerdiği yol kancadan geçmeli)
  ev 'git push'                    → yalnız «çıkış 0»
  «çıkış 0» dışında bir sayı görürsen kanca bozuk.
- En yakın komşular. Reddedilmeli: ev 'git push -f origin main' · ev 'git push -fu origin main' · ev 'git push origin main --force' · ev 'cd repo && git push --force' · ev 'GIT_TRACE=1 git push --force' · ev 'git push origin "$(git branch --show-current)" --force'. Geçmeli: ev 'git push -u origin dal' · ev 'echo git push --force' · ev 'git commit -m "push --force yapma"' · ev 'git push origin main && rm -f x'. Bu iki grup da birlikte okunur: yalnız «Geçmeli» her şeyi geçiren, yalnız «Reddedilmeli» her şeyi reddeden kancada da tutar. Bu sürümün bilinen yanlış reddi: desen tırnağı görmez; tırnak içinde satır başından ya da ; & | ( işaretinden sonra gelen «git push --force» da reddedilir: ev 'git commit -m "düzelt; git push --force yapma"' → "deny".
- Kaçanlar, bilerek kapatılmadı; hepsi ret vermeden yalnız «çıkış 0» basar: ev 'git -C repo push --force' · ev 'git push origin +main' · ev 'sudo git push --force' · ev 'command git push --force' · ev 'git push origin main 2>&1 --force' · ev 'git push --mirror' · ev "$(printf 'git push \\\n--force')" (satır sonu ters eğik çizgiyle bölünen komut) · printf 'git push --force\n' > gonder.sh; ev 'sh gonder.sh'; rm gonder.sh (içinde yazan betik). Bu satır kancayı sınamaz, neyin kapatılmadığını gösterir. Liste örnektir, tam değildir: kanca yalnız komut metnini, satır satır görür. Kaçanın bedeli büyükse kancayı büyütme, reddi yanlışın kendisine koy (adım 1b). Bu örnekte: uzak depoda dalı zorla göndermeye kapat (dal koruması); o engel kancadan ve ajandan bağımsız çalışır.
- Süre: time sh .claude/hooks/kural.sh </dev/null → 0,2 saniyenin altında (sh «real», zsh «total» diye yazar). Bu satır kancanın doğruluğunu değil yalnız süresini ölçer: kanca dosyası yokken de küçük bir sayı basar, yanında «No such file» görürsen dosya yok. Kanca dosya okuyor, ağa çıkıyor ya da süreç başlatıyorsa süre büyür; settings.json'daki "timeout": 5 kancayı o saniyede keser ve komut koşar.
- Elle koştuğun satırları sil: rm -f .claude/hooks/kural.log
- Canlı: proje kökünde claude -p 'git push --force --dry-run komutunu koş' (--dry-run uzak depoya hiçbir şey göndermez), ardından cat .claude/hooks/kural.log → bir «ret» satırı, Claude'un cevabı da git push --force-with-lease'i anıyor: kanca Claude Code içinde koşuyor ve reddi ajana ulaşıyor.

Yapma:
- Her kuralı kancaya taşıma: her ret ajana bir adım, her kanca her çağrıya gecikme ekler.
- Kancaya kuralın metnini kopyalama; yalnız sonucu ve yerine geçen yolu yaz.
- Gerekçe, kaynak ya da «test ettin mi» gibi ajanın uydurabileceği bir şeyi retle isteme.
- Kaçan her yazımı desene ekleyerek kancayı büyütme: desen büyüdükçe doğru komutu da reddeder.
Büyük klasörde aramayı macOS'un kendi grep'ine bırakmıyorum: Claude Code'u güncel tutuyorum, 2.1.117'den beri ajanın Bash'te yazdığı grep'i kendi hızlı grep'iyle koşturuyor; ona düşmeyen büyük aramayı rg ile yapıyorum. grep'i rg'ye çeviren kancamı söktüm: bir haftada çevirdiği gerçek arama 0'dı.
önce96 GB sohbet geçmişinde macOS grep 491 sn
sonrarg 8,7 sn
Etkinlik Monitörü'nde «grep» görürsen kill ile durdur, ajana o aramayı rg ile yazdır; Claude Code'da type grep «function» basmıyorsa claude update
Ajana giden metin · 22 satır
Durum: macOS'ta bir ajanla (Claude Code ya da Codex) çalışıyorsun. Etkinlik Monitörü'nde «grep» adlı bir süreç dakikalarca bir çekirdeği %100 dolduruyor. Ajan büyük bir klasörü (~/.claude/projects, ~/.codex/sessions, log klasörü) arıyor ya da bir klasörde yüzlerce kalıbı birden arıyor (grep -rlF -e … -e … ya da grep -rlF -f kaliplar.txt) ve komut yarım saattir bitmiyor. Etkinlik Monitörü'nde %100'de duran süreç «grep» değil de bir sürüm numarasıysa (ör. 2.1.322) bu durum değil: o, Claude Code'un kendisi ya da onun hızlı grep'i.

Neden: «grep» adıyla koşan, macOS'un kendi grep'idir (/usr/bin/grep, BSD grep 2.6.0). Büyük metinde ripgrep'ten (rg) birkaç kat, Türkçe gibi ASCII dışı harfle dolu metinde onlarca kat yavaştır ve süre diskten değil işlemciden gelir; kalıp sayısı yavaşlığı çarpar. Bende 96 GB'lık Codex sohbet geçmişinde grep -rl 491 sn (8 dakika) sürdü, rg -l soğuk diskte 19 sn; 1.147 kalıplı bir grep 435 MB'ta 29 dakika %100 işlemcide koşup bitmedi.
Claude Code 2.1.117'den beri ajanın grep'ini buna vermiyor: Bash'i açarken `grep` adında bir kabuk fonksiyonu kuruyor ve aramayı kendi içindeki ugrep'le yapıyor (macOS ve Linux; npm ile kurulan Claude Code da bugün aynı ikiliyi kurar). Bu süreç Etkinlik Monitörü'nde ve top'ta «grep» diye değil, Claude Code'un sürüm numarasıyla (ör. 2.1.322, Claude Code'un kendi süreciyle aynı ad), ps -axo args'ta «ugrep» adıyla görünür. Mac mini'de Claude Code 2.1.322 ile, önbellek ısınmışken: 457 MB'lık bir Codex sohbet gününde macOS grep 2,20 sn, Claude Code'un grep'i 0,03 sn, rg 0,02 sn, üçü aynı 2 dosya; 1.147 kalıp -F -f ugrep 0,06 ↔ rg 0,05 sn.
macOS grep'ine üç yoldan düşülür: (a) Codex: grep'i gölgelemez, ajanın yazdığı her grep /usr/bin/grep'tir (Codex'in kendi komut çıktısı: «grep is /usr/bin/grep»); Codex çoğu aramayı zaten rg ile yazar, yavaş olan grep yazdığı aramadır. (b) Claude Code 2.1.117'den eski ya da Claude Code'u açan komut Grep ya da Glob aracını istiyor (--allowedTools, --tools, Agent SDK'nın allowedTools ya da tools listesi): bu araçlardan biri istenince Claude Code Bash'teki grep'i macOS grep'ine bırakır (ayarlardaki izin listesi bunu yapmaz). Claude masaüstü uygulamasının Mac'te açtığı yerel ajan da grep'i gölgelemez. (c) Claude Code'da grep başka bir programın içinden koşuyor (timeout 60 grep …, … | xargs grep …, find … -exec grep …, bash -c '… grep …', bir .sh betiği, command grep, /usr/bin/grep) ya da Claude Code'un kendi grep'ine vermediği bir bayrak taşıyor (-z, --null ve başkaları). Claude Code'un grep'i .{0,80}kelime.{0,80} gibi iki yanlı çevre kalıbını «exceeds complexity limits» diye reddeder; ajan aynı aramayı /usr/bin/grep ile yeniden yazar (bende 324 MB'lık tek dosyada macOS grep 10 dakikayı geçti, rg 0,04 sn).
Claude Code'un grep'i .gitignore'daki dosyaları ve ikili dosyaları atlar, sürüm denetimi klasörlerine (.git, .hg, .svn, .jj …) girmez. Aradığın şey bunlardaysa ajan bulmaz; o zaman rg -uuu yazdır (her şeyi arar).

Yap:
1. Terminalde hangi komutun koştuğunu oku: ps -axo pid,etime,%cpu,args | awk '$4 == "grep" || $4 == "/usr/bin/grep"'. Satır başına bir macOS grep'i, ne kadar süredir ve yüzde kaç işlemciyle koştuğunu basar; Claude Code'un ugrep'i bu listede çıkmaz. Ajanın aramasını taşıyan satırı durdur: kill <pid> (satırın ilk sayısı); durdurmazsan rg araması bitse de o grep çekirdeği tutmaya devam eder. Öldürülen grep sonuç vermez: ajan «143» ya da «eşleşme bulunmadı» derse arama yapılmamıştır, 3. adımda rg ile yeniden yazdırırsın. Codex'teysen 3. adıma geç.
2. Claude Code'daysan ajana şunu yaz: «type grep komutunu koş, çıktıyı aynen göster». İçinde «function» geçen bir satır basarsa (zsh: «grep is a shell function from …/shell-snapshots/…», bash: «grep is a function») ajanın grep'i zaten Claude Code'un ugrep'idir; 1. adımda gördüğün komut fonksiyondan kaçmıştır: 3. adıma geç. «grep is /usr/bin/grep» basarsa terminalde: claude --version. 2.1.117'den küçükse: claude update. Claude Code'u kapatıp yeniden aç ve bu adımı tekrarla. 2.1.117 ya da yeniyse ve ajanı Claude masaüstü uygulaması açtıysa: 3. adıma geç. Değilse Claude Code'u açan komutta (ya da Agent SDK'nın allowedTools/tools listesinde) Grep ya da Glob var; güncelleme bunu değiştirmez. Listeden çıkar ya da Grep aracını tutacaksan 3. adıma geç.
3. Ajana 1. adımda durdurduğun aramayı grep yerine rg ile yazmasını söyle (rg -uuu …, timeout 60 rg -uuu …, … | xargs rg -uuu …; -uuu, grep gibi gizli ve .gitignore'daki dosyaları da arar). rg yoksa (Codex kendi rg'sini getirir, Claude Code ve terminal getirmez): brew install ripgrep. Yüzlerce kalıp varsa tek çağrı: rg -uuu -lF -f kaliplar.txt <klasör>.
4. Bu paketin eski sürümündeki grep-rg.pl kancasını kurduysan kaldır. Claude Code'un kendi grep'i varken kanca hız kazandırmaz, iki şey bozar: (a) .gitignore'daki klasörleri (node_modules, derleme çıktıları) de arattırır: bir depoda grep -rl useState . ajanın grep'iyle 0,6 sn ve 0 dosya, kancanın çevirdiği rg ile 59 sn ve 125 dosya; (b) izinleri atlamayan modda (--dangerously-skip-permissions değilken) grep onaysız koşarken kancanın yazdığı /opt/homebrew/bin/rg --no-config … «This command requires approval» döner, ayarda Bash(grep:*) izni olsa da. Kaldırmak için ~/.claude/settings.json'da "PreToolUse" altında grep-rg.pl geçen kancayı sil, sonra: rm -f ~/.claude/hooks/grep-rg.pl ~/.claude/hooks/grep-rg.log. Claude Code'u yeniden aç.

Doğrula:
- Claude Code'da ajana: «type grep; grep -V | head -1 komutlarını koş» → «function» geçen satır ve «ugrep 7…». İkincisi «grep (BSD grep, GNU compatible) 2.6.0-FreeBSD» basarsa Claude Code kendi grep'ini kurmamış: 2. adım.
- Codex'te ajana: «type grep; grep -V | head -1» → «grep is /usr/bin/grep» ve «BSD grep»: Codex'te grep yazılan her arama macOS grep'idir, büyük klasörde 3. adım.
- Eski kanca kalktı mı (4. adımı yaptıysan, terminalde): grep -c grep-rg ~/.claude/settings.json → 0.

Yapma:
- grep'i rg'ye takma adla (alias) ya da PATH'e «grep» adlı rg koyarak değiştirme: bayraklar farklı (rg'de -h yardım, -E kodlama; düz grep'te + ? | ( ) harftir, rg'de özel), sessizce yanlış sonuç verir. Claude Code kendi fonksiyonunu kurarken grep takma adını zaten siler.
- Ajanın komutunu rg'ye çeviren kanca kurma (PreToolUse updatedInput): Claude Code izni çevrilmiş komuta göre sorar. grep ve düz rg -uuu -lH … onaysız koşar, ama tam yollu rg, --no-config, --include-zero ya da -I taşıyan rg onay ister: kanca her aramaya bir onay ekler.
- Kalıp başına ayrı grep ya da rg çağıran döngü kurma (for p in …; do grep …; done): her kalıp klasörü baştan okur. Kalıpları bir dosyaya yaz, tek çağrı: rg -uuu -lF -f kaliplar.txt <klasör>.
Bu durum şurada da: Laptop ısınıyorsa