Claude Code Hooks: İş Akışı Otomasyonuna Pratik Bir Rehber

Claude Code ile çalışırken yaygın bir sorunla karşılaşırsınız: İyi kod yazar ama biçimlendirme, testleri çalıştırma veya güvenlik protokollerine uyma gibi önemli adımları unutur. Aynı hatırlatmaları tekrar tekrar yapmak zorunda kalırsınız. 

Claude Code Hooks, iş akışınızın belirli noktalarında kabuk komutlarını otomatik olarak çalıştırarak bu hatırlatmaları otomatikleştirmenizi sağlar.

Bu eğitim, kod biçimlendirme, test çalıştırma, bildirimler ve dosya koruması için kancaları nasıl kuracağınızı gösterir. Manuel müdahale olmadan geliştirme standartlarınızı tutarlı şekilde uygulayan bir otomasyon sistemi kuracaksınız.

Claude Code'un arkasındaki büyük dil modeli (LLM) hakkında daha fazla bilgi edinmek için Claude Sonnet 4.5 ile ilgili bu makaleye göz atın. Ayrıca Moltbot (Clawdbot) eğitimi ve Claude Cowork eğitimimizi de öneririm.

Claude Code Hooks Nedir?

Claude Code Hooks, yapay zekâ kodlama oturumunuz sırasında belirli olaylar gerçekleştiğinde otomatik olarak çalışan kabuk komutlarıdır. Bunları, tam zamanında özel betiklerinizi çalıştıran otomatik tetikleyiciler gibi düşünün—Claude bir dosya yazmadan önce, bir komutu çalıştırdıktan sonra veya size bir bildirim gönderdiğinde.

Sistem, Claude Code'un eylemlerini izleyip bunları bir yapılandırma dosyasında tanımladığınız kurallarla eşleştirerek çalışır. Eşleşme olduğunda, belirlediğiniz komut, az önce ne olduğuna dair bağlama erişerek çalışır. Bu size Claude'un davranışı üzerinde kontrol sağlar ve aksi takdirde manuel müdahale gerektirecek tekrarlı görevleri otomatikleştirmenize imkân tanır.

İşte Claude her Python dosyası yazdığında bir kod biçimlendiriciyi çalıştıran temel bir kanca:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python -m black ."
          }
        ]
      }
    ]
  }
}

Bu kanca üç bölümden oluşur: 

• Olay: PostToolUse (Claude bir işlemi tamamladıktan sonra)

• Eşleştirici (matcher): Write (yalnızca dosya yazarken)

• Komut: python -m black . (geçerli dizindeki Python dosyalarını biçimlendirir)

Kanca, betiğin girdisine gönderilen JSON verileri aracılığıyla Claude'un az önce ne yaptığına dair ayrıntılı bilgi alır; böylece belirli dosya değişikliklerine tepki veren daha gelişmiş otomasyonlar oluşturabilirsiniz.

Kodlama iş akışlarının ötesinde otomasyonla ilgileniyorsanız, Claude Cowork dosya ve belge görevleri için benzer yapay zekâ destekli otomasyon sunar.

Sırada, bu tür kancaları sıfırdan nasıl oluşturacağımızı ve iş akışlarınıza eklemek için Claude Code'a nasıl kaydedeceğimizi inceleyeceğiz.

Önkoşullar

Claude Code Hooks'a dalmadan önce birkaç şeyi kurmuş olmanız gerekir:

• Claude Code kurulmuş ve çalışıyor: Temel kodlama görevleri için Claude Code kullanmaya aşina olmalısınız

• Komut satırına aşinalık: Kancalar kabuk komutları çalıştırır; bu nedenle işletim sisteminiz için temel terminal komutlarını yazmayı bilmeniz gerekir

• Metin düzenleyici erişimi: Kancalarınızı kurmak için JSON yapılandırma dosyalarını düzenleyeceksiniz

• Proje dizini: Önemli işleri etkilemeden kancaları güvenle test edebileceğiniz bir kodlama projesi

Kabuk betikleme uzmanı olmanız gerekmez, ancak ls, cd ve temel dosya işlemleri gibi komutları nasıl çalıştıracağınızı bilmek örnekleri takip etmenize yardımcı olur. Bash betiklemeye veya terminale yeniyseniz Introduction to Shell kursumuzu öneririm.

Claude Code Hooks ile Başlarken

Artık kancaların ne olduğunu anladığınıza göre, ilk otomasyonunuzu kuralım. Süreç, ihtiyacınıza uygun doğru olayı seçmeyi, basit bir kuralı yapılandırmayı ve bunu temel bir komutla test etmeyi içerir.

Kanca olaylarını anlama

Claude Code, komutlarınızı çalıştırabileceğiniz on farklı olay sağlar. Her olay belirli bir anda tetiklenir ve iş akışınızın farklı bölümleri üzerinde kontrol sağlar:

PreToolUse ve PostToolUse en yaygın olaylardır. PreToolUse, Claude bir dosya yazmak veya bir komut çalıştırmak gibi bir eylemi gerçekleştirmeden önce çalışır; bu nedenle doğrulama veya tehlikeli işlemleri engelleme için idealdir. PostToolUse ise Claude bir eylemi tamamladıktan sonra çalışır; bu da kod biçimlendirme veya testleri çalıştırma gibi temizlik görevleri için uygundur.

UserPromptSubmit, siz Claude'a bir istem gönderdiğinizde, işleme başlamadan önce tetiklenir. Bunu, konuşmanıza bağlam eklemek veya istemlerin belirli gereksinimleri karşıladığını doğrulamak için kullanabilirsiniz.

Notification, Claude size bir komut çalıştırma izni istemek veya girdinize ihtiyaç duymak gibi uyarılar gönderdiğinde çalışır. PermissionRequest, Claude Code bir izin iletişim kutusu gösterdiğinde tetiklenir ve kullanıcının adına isteği otomatik olarak onaylamanıza veya reddetmenize olanak tanır.

Stop ve SubagentStop, Claude yanıt vermeyi bitirdiğinde tetiklenir; bu da son kontroller veya rapor oluşturma için kullanışlıdır. İkisi arasındaki fark, Stop'un Claude genel yanıtını bitirdiğinde, SubagentStop'un ise bir aracın başlattığı yardımcı (bir “alt ajan”) işini bitirdiğinde tetiklenmesidir.

Kalan olaylar PreCompact ve SessionStart, konuşma temizliği ve oturum başlatma gibi özel durumları ele alır.

Kalan olaylar, PreCompact, SessionStart ve SessionEnd, yaşam döngüsüne özgü durumları ele alır. PreCompact, Claude konuşma geçmişini kısaltmadan hemen önce çalışır. ‘SessionStart’, varsayılanları ayarlamak için yeni bir oturumun başında tetiklenir ve SessionEnd oturum kapandığında tetiklenir; bu da temizlik veya son raporlama için olanak sağlar.

Eşleştiricileri (matcher) anlama

Eşleştiriciler, hangi Claude Code eylemlerinin bir kancayı tetikleyeceğine karar veren filtrelerdir. Teknik olarak, düzenli ifadeler olarak yorumlanan dizgelerdir; dolayısıyla birebir eşleşmeler veya daha esnek kalıplar kullanabilirsiniz. 

En alakalı eşleştiriciler, Write (Claude bir dosya yazdığında tetiklenir) veya Edit (içerik düzenlenirken tetiklenir) gibi basit olanlar ve birden fazla eylemi kapsamak için Edit|Write gibi birleşimlerdir. 

Ayrıca “Notebook” ile başlayan tüm araçları eşleştirmek için Notebook.* gibi ön ek kalıpları kullanabilirsiniz. Kancanın her eylemde tetiklenmesini istiyorsanız, evrensel regex .*, boş bir dizge ("") veya matcher'ı boş bırakmayı kullanın.

Eşleştiriciler büyük/küçük harf duyarlıdır ve yalnızca eylem adlarında çalışır; bu yüzden mümkün olduğunca özel tutmak en iyisidir. Daha ince kontrol gerektiğinde (örneğin kancayı belirli dosya türleriyle sınırlamak için) Claude'un kancaya aktardığı JSON yükünü okuyabilir ve kendi regex'inizi veya koşullarınızı burada uygulayabilirsiniz.

Claude Code'da ilk kancanızı oluşturma

Claude Code, kancaları kurmak için iki yol sunar: etkileşimli /hooks komutu veya doğrudan yapılandırma dosyalarını düzenlemek. Başlangıç seviyesine daha uygun olduğu için etkileşimli yaklaşımla başlayalım.

/hooks komutunu kullanma:

1. Claude Code'u açın ve sohbet arayüzüne /hooks yazın

2. Tetikleyici olayınızı seçin (bu örnek için PostToolUse seçin)

3. Menüden "Yeni kanca ekle" seçeneğini seçin

4. Eşleştirici desenini ayarlayın (dosya yazmayı hedeflemek için Write girin)

5. Komutunuzu girin:

• Mac: say "Task complete"

• Windows: powershell -c [console]::beep()

• Linux: spd-say "Task complete"

6. Yapılandırmayı kaydedin ve Esc'e üç kez basarak Claude Code'a geri dönün

/hooks komutu ayar dosyanızı otomatik olarak günceller ve yapılandırmayı yeniden yükler. Mevcut kancalarınızı görüntülemek veya değişiklik yapmak için istediğiniz zaman /hooks kullanabilirsiniz.

Yapılandırma dosyalarını doğrudan düzenlemeyi tercih ediyorsanız, kancalar ~/.claude/settings.json (genel ayarlar) veya proje dizininiz içinde .claude/settings.json olarak bulunur. Yukarıdaki örneğimiz için şöyle görünür:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "say 'Task complete'"
          }
        ]
      }
    ]
  }
}

Dosyayı elle düzenledikten sonra Claude Code'u yeniden başlatın veya yapılandırmanızı yeniden yüklemek için /hooks komutunu kullanın. Artık Claude her dosya yazdığında bir sesli bildirim duyacaksınız.

Kancanızı test etme

İlerlemeden önce kancanızın gerçekten çalıştığını doğrulayın:

1. Claude'dan herhangi bir Python dosyası yazmasını isteyin (ör. "hello.py adlı, hello world yazdıran bir dosya oluştur")

2. Claude yazma işlemini tamamladığında sesli bildirimi duymanız gerekir

3. Hiçbir şey duymuyorsanız, hata iletilerini görmek için Ctrl-O tuşlarına basarak Claude Code'un dökümünü kontrol edin

4. Yaygın sorunlar arasında kanca komutunun bulunamaması, yanlış dosya izinleri veya yapılandırma dosyanızda sözdizimi hataları bulunur

Bu temel testi çalıştırmak, daha karmaşık kancalar oluştururken size hata ayıklama zamanı kazandırır. Ayar dosyasını yeni düzenlediyseniz, eşleştiriciyi veya olayı değiştirdiyseniz ya da bir kanca komutunda kullanmak istediğiniz yeni araçlar kurduysanız, yapılandırmayı yeniden yüklemek için /hooks'u yeniden açmak veya Claude'u yeniden başlatmak yardımcı olabilir.

Bu temel desen—olay, eşleştirici, komut—tüm kanca otomasyonunun temelini oluşturur. Aynı olay tetiklendiğinde eşzamanlı olarak çalışacak birden çok komut ekleyerek bunu genişletebilirsiniz. Örneğin, Claude bir dosya yazdığında hem bir ses çalmak hem de bir yedek oluşturmak isteyebilirsiniz. 

Aynı olay içinde farklı araçlar için ayrı eşleştiriciler de oluşturabilirsiniz; böylece dosya yazma, kod düzenlemeden farklı eylemleri tetikler. Aynı araç desenini eşleştiren tüm kancalar paralel çalışır. Aynı olay için birden fazla eşleştirici yapılandırırsanız, her kanca kendi eşleştiricisi tetiklendiğinde çalışır.

Kanca Girdileriyle Çalışma

Claude Code bir kancayı tetiklediğinde, olan bitenle ilgili bilgileri, komutunuz çalıştığında doğrudan komutunuza akan bir veri akışı olan standart girdi (stdin) üzerinden gönderir. Kancaları, rastgele zamanlarda çalışan betiklerden güçlü kılan şey bu veridir. 

Claude Code bu bilgileri JSON olarak paketler ve basit bir terminal komutu ya da özel bir betik olsun, yapılandırdığınız her komuta iletir.

Kanca girdilerinin anatomisi

Her kanca, geçerli oturumla ilgili temel alanları içeren bir JSON nesnesi alır:

{
  "session_id": "abc123",
  "transcript_path": "/Users/you/.claude/projects/my-project/conversation.jsonl", 
  "cwd": "/Users/you/my-project",
  "hook_event_name": "PostToolUse"
}

Her bir bileşeni çevirelim:

• session_id: geçerli sohbetinizi tanımlar

• transcript_path: konuşma geçmişine işaret eder

• cwd: çalışma dizinini gösterir

• hook_event_name: hangi olayın tetiklendiğini bildirir

Bu bağlam, kancalarınızın akıllı kararlar almasını sağlar: Hangi sohbetin bir eylemi tetiklediğini takip edebilir, gerekirse tüm sohbet geçmişine erişebilir veya doğru dizinde komutlar çalıştırabilirsiniz.

Olaya dayalı girdi farklılıkları

PreToolUse ve PostToolUse gibi araç olayları, eylemle ilgili ekstra ayrıntılar içerir; kancaların otomasyon için gerçekten faydalı hale geldiği yer burasıdır. PreToolUse'ta tool_input belirtilir; ayrıca PostToolUse'ta tool_response yer alır:

{
  "session_id": "abc123",
  "hook_event_name": "PostToolUse",
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.py",
    "content": "print('Hello world')"
  },
  "tool_response": {
    "filePath": "/path/to/file.py", 
    "success": true
  }
}

Kanca girdisinde file_path, yazılan veya düzenlenen dosyanın yolunu gösterirken, content aracın yazmak üzere olduğu metnin tamamını içerir. Yürütmeden sonra aracın yanıtı, dokunulan dosyayı doğrulamak için son filePath'i (camelCase yazıma dikkat) yineler ve işlemin doğru şekilde tamamlanıp tamamlanmadığını belirten bir success bayrağı içerir. 

Bu ayrıntılı bilgiler, kancalarınızın gerçekten olan bitene göre farklı tepkiler vermesini sağlar. Yalnızca Python dosyalarını biçimlendirebilir, yalnızca önemli dizinleri yedekleyebilir veya yalnızca belirli dosya türleri değiştirildiğinde bildirim gönderebilirsiniz.

UserPromptSubmit gibi olaylar daha basittir; çünkü araçları içermezler:

{
  "session_id": "abc123",
  "hook_event_name": "UserPromptSubmit", 
  "prompt": "Write a function to calculate factorial"
}

UserPromptSubmit kancalarının yapılandırmalarında eşleştirici kullanmadığını unutmayın. Araç işlemleri değil, tüm istemlerde tetiklenirler. Bu da onları sohbetleri günlüğe kaydetmek, proje bağlamını otomatik olarak eklemek veya Claude işlemeden önce istemleri doğrulamak için mükemmel kılar.

Uygulamada kanca girdisini okuma

Her kullanıcı istemini günlüğe kaydeden bir kanca oluşturalım. Bu, özellikle uzun kodlama oturumlarında, Claude'dan ne yapmasını istediğinizi takip etmeyi kaybetme sorununu çözer. Önce kanca yapılandırması:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/log_prompts.py"
          }
        ]
      }
    ]
  }
}

Ardından ~/.claude/log_prompts.py yolunda aşağıdaki içerikle Python betiğini oluşturun:

#!/usr/bin/env python3
import json
import sys
from datetime import datetime

# Read JSON data from stdin
input_data = json.load(sys.stdin)

# Extract information
session_id = input_data.get("session_id", "unknown")
prompt = input_data.get("prompt", "")
timestamp = datetime.now().isoformat()

# Log the prompt
log_entry = f"{timestamp} | Session: {session_id[:8]} | {prompt}\n"
with open("prompt_history.txt", "a") as f:
    f.write(log_entry)

Betik, Claude Code'un gönderdiği JSON verilerini okur ve istemi oturum bağlamıyla birlikte kaydeder. Bu, haftalar sonra bir sorunu nasıl çözdüğünüzü hatırlamanız gerektiğinde çok değerli olan aranabilir bir etkileşim geçmişi oluşturur.

Kanca Çıktılarıyla Çalışma

Kanca komutunuz çalıştıktan sonra, ne olduğunu ve normal şekilde devam edilip edilmeyeceğini Claude Code'a bildirmesi gerekir. Bu kontrol mekanizması, kancaları basit günlükleme araçlarından, Claude'un davranışını yönlendirebilen güçlü iş akışı otomasyonlarına dönüştürür. Bu, üç kanal üzerinden gerçekleşir: standart çıktı (stdout), standart hata (stderr) ve çıkış kodları.

Çıkış kanalları ve çıkış kodları

Standart çıktı (stdout) normal çıktı demektir. Örneğin bir şey yazdırırsanız, stdout'a gider. Çoğu kanca için, bu, Ctrl-O tuşlarına bastığınızda Claude Code'un dökümünde görünen şeydir ve ana konuşmayı kalabalıklaştırmadan otomasyonunuzun ne yaptığının kaydını verir.

Standart hata (stderr) hata iletilerini ifade eder. stderr'a şunlarla yazabilirsiniz 

• Python: print("message", file=sys.stderr) veya

• Komut satırı: echo "message" >&2

Temel fark, stderr'ın otomatik işlem için doğrudan Claude'a gönderilebilmesi ve kancalarınızın tespit ettiği sorunlara cevap vermesini sağlamasıdır.

Çıkış kodları, Claude Code'a sonraki adımı söyler:

• Çıkış kodu 0: Başarı (kullanıcıya stdout gösterilir)

• Çıkış kodu 2: Engelleyici hata (stderr Claude'a gönderilir)

• Çıkış kodu 3: Ertelenmiş yürütme (komutun hatasız tamamlandığını, ancak etkilerinin ek koşullar karşılanana kadar ertelendiğini belirtir) 

• Diğer kodlar: Engelleyici olmayan hata (stderr kullanıcıya gösterilir, ancak devam edilir)

Bu sistem, Claude'un ne zaman duracağını, devam edeceğini veya otomasyonunuzun keşfettiği şeyler hakkında geri bildirim alacağını ince ayarda kontrol etmenizi sağlar. En önemli iki çıkış kodu için örneklere bakalım.

Çıkış kodu 0: Normal işlem

Çoğu kanca, her şeyin yolunda gittiğini belirtmek için çıkış kodu 0 kullanır. İşte dosya işlemlerini günlüğe kaydedip kullanıcıyı bilgilendiren eksiksiz bir kanca:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import datetime; open('activity.log','a').write('File written: ' + datetime.datetime.now().isoformat() + '\\n'); print('Logged file operation')\""
          }
        ]
      }
    ]
  }
}

Bu kanca iki komut çalıştırır: bir dosyaya günlük yazma, ardından dökümde bir ileti yazdırma. Bunu yapmanın birçok yolu vardır; ancak bu yaklaşım, platformdan bağımsızdır ve komut satırı özgüllüklerine bağımlı değildir.

Açık bir çıkış kodu olmadığından varsayılan olarak 0'dır. Yazdırılan ileti Claude Code'un dökümünde görünür ve size günlüğe kaydetmenin çalıştığına dair geri bildirim sağlar. Bu desen, denetim izleri oluşturmak veya Claude'un zaman içinde projenizde yaptığı değişiklikleri takip etmek için idealdir.

Çıkış kodu 2: Geri bildirimle engelleme

Çıkış kodu 2, hata iletinizi doğrudan Claude'a gönderir ve onun otomatik yanıt vermesini sağlar. İşte kancaların, yalnızca otomasyondan bir güvenlik mekanizmasına dönüştüğü yer. İşte tehlikeli dosya işlemlerini engelleyen bir kanca:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/security_check.py"
          }
        ]
      }
    ]
  }
}

Güvenlik kontrol betiğini ~/.claude/security_check.py yolunda oluşturmanız gerekir:

#!/usr/bin/env python3
import json
import sys

# Read hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Check for dangerous patterns
dangerous_paths = ["/etc/", "/usr/", "production.conf"]
is_dangerous = any(pattern in file_path for pattern in dangerous_paths)

if is_dangerous:
    # Block the operation and tell Claude why
    print(f"Blocked modification of {file_path} - this appears to be a system or production file", file=sys.stderr)
    sys.exit(2)  # Sends stderr message to Claude
else:
    # Allow the operation
    print(f"Approved modification of {file_path}")
    sys.exit(0)  # Shows stdout in transcript

Bu kanca tehlikeli bir yol tespit ettiğinde 2 koduyla çıkar. Claude Code, stderr iletisini Claude'a gönderir; böylece neden engellendiğini size açıklayabilir ve alternatifler önerebilir. Bu, sistem dosyalarına yanlışlıkla zarar verilmesini önlerken Claude'u güvenlik ilkeleriniz hakkında bilgilendirmeye devam eder.

Claude Code için Akıllı Bir Bildirim Kancası Oluşturma

Girdi işlemeyi akıllı çıktı yönetimiyle birleştiren geliştirilmiş bildirim kancamızı oluşturalım. Bu, her dosya değişikliğinde uyarı veren ilk kancamızın gürültü sorununu çözer:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/smart_notify.py"
          }
        ]
      }
    ]
  }
}

~/.claude/smart_notify.py yolunda bildirim betiğini oluşturun:

#!/usr/bin/env python3
import json
import sys
import os
import subprocess

# Read the hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Categorize file importance
important_extensions = [".py", ".js", ".ts", ".java", ".cpp"]
config_files = ["Dockerfile", "requirements.txt", "package.json"]

is_code = any(file_path.endswith(ext) for ext in important_extensions)
is_config = any(filename in file_path for filename in config_files)

if is_code:
    # Important: notify and log
    print(f"Code file modified: {os.path.basename(file_path)}")
    subprocess.run(["say", "Code updated"], check=False)  # Mac
    sys.exit(0)  # Show message in transcript
elif is_config:
    # Very important: louder notification
    print(f"Configuration file changed: {os.path.basename(file_path)}")
    subprocess.run(["say", "Configuration updated - review changes"], check=False)
    sys.exit(0)
else:
    # Not important: silent success
    sys.exit(0)

Bu kanca, hangi dosyanın değiştirildiğini anlamak için girdiyi okur, dosya türüne göre bildirim önemine karar verir, önemli değişiklikleri dökümde günlüğe kaydetmek için stdout'u kullanır, dosya türüne göre farklı sesli uyarılar tetikler ve bunlar engelleyici değil bilgilendirici eylemler olduğundan her zaman 0 koduyla çıkar.

Girdi analizi ve çıktı kontrolünün birleşimi, bağlama göre akıllıca davranan ve hem size hem de Claude Code'a doğru düzeyde geri bildirim sağlayan bir kanca oluşturur. Geçici her dosya için can sıkıcı bildirimler almak yerine, projelerinizi gerçekten ilgilendiren değişiklikleri duyarsınız.

Lütfen bu örnekte macOS'ta bulunan say komutunun kullanıldığını unutmayın. Linux'ta notify-send, Windows'ta ise benzer bildirimler için bir PowerShell komutu kullanabilirsiniz.

Claude Code Hooks için İleri Düzey Kalıplar

Temel bildirimler ve günlüklemenin ötesinde, kancalar ekiplerin günlük olarak karşılaştığı gerçek geliştirme iş akışı sorunlarını çözebilir. Kendi projelerinize uyarlayabileceğiniz bazı fikirler burada.

Güzel olan şu ki, bu kancaları aslında elle oluşturmak zorunda değilsiniz. Aşağıdaki istem fikirlerinden birini, dokümantasyondaki Hooks başvuru bölümüyle birlikte Claude Code'a verebilir ve ilgili kodu ile yapılandırma için JSON'u ürettirebilirsiniz.

Bu kalıpların her biri, sizin özel araçlarınıza ve iş akışınıza göre özelleştirilebilir. En büyük günlük sıkıntılarınızı çözenlerle başlayın; kanca geliştirmeye alıştıkça otomasyonunuzu genişletin.

Güvenlik ve uyumluluk için ileri düzey kancalar

API anahtarı tarayıcı

• Sorun: Gizlilerin yanlışlıkla sürüm kontrolüne işlenmesi

• Tetikleyiciler: Herhangi bir dosya yazmadan önce

• Çözüm: Regex desenleri kullanarak dosya içeriğinde API anahtarları, belirteçler ve parolaları tarama

“Kanca girdi JSON'unu okuyup dosya içeriğini çıkaran ve api_key=, token: veya password= gibi yaygın gizli biçimlerini algılamak için regex desenleri kullanan bir Python betiği oluşturun.  Şüpheli her eşleşme için yerel doğrulama yapın ve asla ham gizlileri haricen göndermeyin. 

Yalnızca maskelenmiş alıntılar (örn. 4 ön ek/son ek karakterini koruyun) veya şüpheli dizgeleri analiz etmek ve bunların gerçek gizli mi yoksa değişken adları mı olduğunu belirlemek için Anthropic API'ye karmalar gönderin. 2 koduyla çıkın ve tespit edilen gizliler ve daha güvenli alternatifler hakkında Claude'a geri bildirim sağlayın.”

Lisans başlığı zorlayıcı

• Sorun: Açık kaynak projelerde yeni dosyalarda gerekli lisans başlıklarının eksik olması

• Tetikleyiciler: Kaynak kodu dosyaları yazılmadan önce

• Çözüm: Yeni .py, .js, .java dosyalarının uygun lisans metnini içerdiğini doğrulama

“Kanca girdisini ayrıştırarak dosya içeriğini alın ve ilk 10 satırın dize eşleştirme ile lisans metni içerip içermediğini kontrol edin. Daha gelişmiş doğrulama için, uygun telif bildirimleri ve lisans bilgilerinin yer aldığını doğrulamak üzere dosya başlığını Anthropic API üzerinden Claude'a gönderin. Başlıklar eksikse 2 koduyla dosya oluşturmayı engelleyin ve Claude'a eklemesi için doğru lisans şablonunu sağlayın.”

Canlı ortam dosyası koruyucu

• Sorun: Kritik sistem yapılandırma dosyalarının yanlışlıkla değiştirilmesi

• Tetikleyiciler: Hassas dizinlerdeki dosyalar düzenlenmeden önce

• Çözüm: /etc/, nginx.conf, database.yml ve diğer kritik yapılandırmalara yapılan değişiklikleri engelleme

“Kanca girdi JSON'undan dosya yolunu çıkarın ve /etc/, production.yml veya diğer kritik dosya adları gibi kalıplarla eşleşip eşleşmediğini kontrol edin. Dosya yolunun, canlı sistemleri etkileyebilecek bir yapılandırma dosyası olup olmadığını belirlemek için Claude'un API'sini kullanın. Tehlikeli yollar tespit edildiğinde 2 koduyla çıkın ve daha güvenli geliştirme uygulamaları hakkında özel yönlendirme sağlayın.”

Görüntü iyileştirici

• Sorun: Büyük görüntü dosyalarının uygulamaları ve depoları yavaşlatması

• Tetikleyiciler: Yeni görüntü dosyaları eklendikten sonra

• Çözüm: PNG/JPEG dosyalarını görsel kalite korunarak sıkıştırma

“Kanca girdisini ayrıştırarak dosya yolunu alın ve uzantı eşleştirme ile bunun bir görüntü dosyası olup olmadığını kontrol edin. Görüntünün kalitesini korurken sıkıştırmak için imageoptim gibi sıkıştırma araçlarını çalıştırın veya TinyPNG API'sini çağırın. Sıkıştırma sonuçlarını Claude'un dökümünde dosya boyutu tasarruflarını görebilmeniz için stdout'a kaydedin.”

Sürüm kontrol otomasyonu için ileri düzey kancalar

Git dalı doğrulayıcı

• Sorun: Ekip üyelerinin yanlışlıkla korumalı dallara değişiklik itmesi

• Tetikleyiciler: Herhangi bir dosya yazma veya düzenleme işleminden önce

• Çözüm: Geçerli Git dalını kontrol etme ve main/master/production üzerinde işlemleri engelleme

“Geçerli dal adını almak için basit bir bash komutu git branch --show-current kullanın ve bunu korumalı dallar listesiyle karşılaştırın. Korumalı bir dal üzerindeyse, dal koruma ilkelerini açıklayan bir hata iletisini Claude'a göndermek ve 2 koduyla çıkmak için kullanın. Karmaşık dal adlandırma kuralları için, dal adlarını analiz etmek ve koruma kalıplarıyla eşleşip eşleşmediğini belirlemek üzere Claude’un API'sini kullanın.”

Akıllı otomatik commit

• Sorun: Değişiklikleri commit etmeyi unutmak veya zayıf commit iletileri yazmak

• Tetikleyiciler: Herhangi bir dosya değişikliğinden sonra

• Çözüm: Değişiklikleri otomatik olarak aşamaya alma ve yapay zekâ ile açıklayıcı iletilerle commit etme

“Kanca girdisinden değiştirilen dosya yollarını okuyun, değişiklikleri almak için git diff çalıştırın ve özlü bir commit iletisi istemek için diff'i Claude’un API'sine gönderin. Üretilen iletiyi, değişiklikleri otomatik olarak commit etmek için git add ve git commit komutlarıyla kullanın. Commit iletilerinin geleneksel commit standartlarını takip etmesini sağlamak için API istemine dosya adları ve değişiklik türlerini dahil edin.”

Dokümantasyon oluşturucu

• Sorun: API dokümantasyonunun kod değişiklikleriyle senkron dışına çıkması

• Tetikleyiciler: Arayüz dosyaları (denetleyiciler, modeller, API'ler) değiştirildikten sonra

• Çözüm: JSDoc, Sphinx veya OpenAPI üreticileri gibi dokümantasyon araçlarını otomatik çalıştırma

“Kalıp eşleştirme kullanarak değiştirilen dosya yolunun bir API uç noktası, model veya arayüz dosyası olup olmadığını belirleyin. Dosya içeriğini Claude'un API'sine göndererek API değişikliklerini çıkarıp dokümantasyon güncellemeleri üretmesini isteyin. Uygun dokümantasyon üretim aracını (jsdoc, sphinx-build vb.) çalıştırın ve güncellenmiş dokümantasyonu otomatik olarak commit edin.

İşbirliği ve iş akışı entegrasyonu için ileri düzey kancalar

Slack entegrasyonu

• Sorun: Ekibin, paylaşılan kod tabanlarındaki önemli değişikliklerden habersiz kalması

• Tetikleyiciler: Önemli işlemler için bildirimler gönderildiğinde

• Çözüm: Dosya adları ve değişiklik özetleriyle ekip kanallarına biçimlendirilmiş iletiler gönderme

“Kanca girdisinden dosya bilgilerini çıkarın ve kaynak kodu veya yapılandırma dosyaları gibi önemli türlere filtreleyin. Dosya adları ve türlerine dayalı olarak neyin değiştiğine dair okunabilir bir özet üretmek için Claude’un API’sini kullanın. Kritik değişiklikler için ekip üyelerini etiketleyerek biçimlendirilmiş iletiyi webhook URL'leriyle Slack'e gönderin.”

Webhook dağıtıcısı

• Sorun: Manuel CI/CD hattı tetiklemeleri nedeniyle dağıtım gecikmeleri

• Tetikleyiciler: Belirli olaylar gerçekleştiğinde (yapılandırma değişiklikleri, dağıtım dosyaları değiştirildiğinde)

• Çözüm: Derlemeleri, dağıtımları veya diğer otomatik süreçleri tetiklemek için harici API'leri çağırma

“CI/CD'nin tetiklenip tetiklenmeyeceğini belirlemek için değiştirilen dosya yolunu Dockerfile, package.json veya dağıtım yapılandırmaları gibi kalıplara karşı kontrol edin. Kimlik doğrulama başlıkları ve değişikliklere dair yük verileriyle webhook URL'lerini çağırmak için Python'da requests kitaplığını kullanın. Harici sistemlerin neyin oluşturulacağı veya dağıtılacağı hakkında akıllı kararlar alabilmesi için yük verisine dosya yolları ve değişiklik metadatasını dahil edin.”

Durum sayfası güncelleyici

• Sorun: Müşterilerin bakım veya dağıtım faaliyetlerinden habersiz olması

• Tetikleyiciler: Dağıtım veya altyapı dosyaları değiştirildiğinde

• Çözüm: Hizmet durum sayfalarını bakım bildirimleriyle güncelleme

“Dosya yolu kalıplarını kullanarak Kubernetes manifestoları veya Terraform yapılandırmaları gibi altyapı dosya değişiklikleri için kanca girdisini ayrıştırın. Tespit edilen altyapı değişikliklerinin türüne göre Claude'un API'sini kullanarak bakım iletileri üretin. Uygun olay türleri ve tahmini sürelerle, REST API'lerini kullanarak StatusPage.io veya PagerDuty gibi hizmetlere durum güncellemeleri gönderin.”

Ekip durum bildirici

• Sorun: Birden fazla geliştiricinin aynı özellikler üzerinde habersizce çalışması nedeniyle yaşanan çakışmalar

• Tetikleyiciler: Yeni bir Claude Code oturumu başlatıldığında

• Çözüm: Belirli bir proje veya bileşen üzerinde çalışmaya başladığınızı ekip kanallarına bildirme

“Kanca girdisinden proje dizinini okuyun ve ne tür bir iş yapıldığını anlamak için yakın tarihli dosyaları veya git geçmişini analiz etmek üzere Claude'un API'sini kullanın. Adınızı, proje adını ve odak alanını içeren biçimlendirilmiş bir iletiyi ekip iletişim kanallarına gönderin. Tahmini çalışma süresini ekleyin ve ilgili özellikler üzerinde çalışan ekip üyelerini koordinasyona davet edin.”

Sonuç

Claude Code Hooks, öngörülemeyen yapay zekâ kodlama asistanlarını, tam ihtiyacınız olduğunda çalışan otomatik iş akışlarına dönüştürür. Bu eğitimde, hem etkileşimli /hooks komutunu hem de manuel yapılandırmayı kullanarak kancaları nasıl kuracağınızı, akıllı otomasyonu besleyen JSON girdi verilerini nasıl anlayacağınızı ve çıkış kodları ile yapılandırılmış çıktılar aracılığıyla Claude'un davranışını nasıl kontrol edeceğinizi öğrendiniz. 

Ele aldığımız pratik kalıplar, tehlikeli işlemleri engelleyen güvenlik doğrulayıcıları ve gürültüyü azaltan akıllı bildirimleri içerir. Bu örnekler, kancaların gerçek geliştirme sorunlarını nasıl çözdüğünü ve yapay zekâ asistanınız üzerinde tam kontrol sağladığını gösterir. Artık temelleri anladığınıza göre, ekibinizin özel iş akışı ihtiyaçlarına uygun otomasyonlar oluşturabilirsiniz. 

Yapay zekâ araçlarıyla çalışmayı daha fazla öğrenmek için DataCamp'in Understanding Prompt Engineering kursuna göz atın; bu kurs, doğrudan kanca geliştirmeyle çalışan istem stratejilerini kapsar. Daha geniş yapay zekâ ile kodlama becerileri için, geliştirme iş akışınızda yapay zekâ asistanlarını daha güvenilir ortaklar haline getirecek becerileri edinmek üzere Intermediate ChatGPT kursumuzu deneyin.