Claude Code'u kullanmaya başladığımda, onu bir sohbet gibi ele alıyordum.
Bir şey isterdim, cevap verirdi ve o kadardı.
İşe yarıyordu, ama zamanla tam potansiyelini kullanamadığımı fark etmeye başladım.
Aynı promptları tekrarlıyordum. Aynı komutları çalıştırıyordum. Ondan tam olarak nasıl yararlanacağımı net olarak bilmiyordum.
Bu yüzden durdum ve kendime bir soru sordum:
Claude Code aslında içeride nasıl çalışıyor?
Dokümantasyonu okumaya, denemeler yapmaya ve test etmeye başladım.
Ve keşfettiğim şey şu:
Sihir yapmıyor. Her biri net bir role sahip somut parçalar üzerine inşa edilmiş. Ve bunları anladığınızda, diğer her şey anlam kazanmaya başlıyor.
→ Eğer aynı talimatları sürekli tekrarlıyorsanız, onları bir Skill'e dönüştürürsünüz.
→ Uzun bir görevde konuyu kaybediyorsa, bir SubAgent'e devredersiniz.
→ Tekrarladığınız manuel adımlar varsa, onları Hooks ile otomatikleştirirsiniz.
Temelleri anlamak, neyi, ne zaman ve neden kullanacağınızı bilmenizi sağlar.
Bugün 100'den fazla Skill'im, saatlerimi alan otomatikleştirilmiş süreçlerim ve kod incelemeleri yapmak ile ilgimi çeken konuları çalışmak için agent'larım var.
Bu makaleyi, öğrendiğim her şeyi sizinle paylaşmak için yazdım.
Hadi başlayalım.
Agent Döngüsü: Claude Code'un Kalbi
Claude Code bir agent'tır.
Ona bir hedef verdiğiniz ve o hedefi gerçekleştirene kadar çalışan bir sistem.
Bir sohbetten farklıdır. Bir sohbette, "Uygulamaama kimlik doğrulama nasıl eklerim?" diye sorarsınız ve o size adımları açıklar.
Ama sizin projeye gidip, kodu değiştirmeniz ve çalışıp çalışmadığını test etmeniz gerekir.
İşi siz yaparsınız.
Claude Code ile, ona "Uygulamaama kimlik doğrulama ekle" dersiniz ve o ilgilenir.
Kodu okur, kütüphaneyi seçer, değişiklikleri yazar ve bittiğinde sizi bilgilendirir.
Bir hedefi vardır: kimlik doğrulama eklemek.
Ve bunu gerçekleştirene kadar çalışır.
Peki her adımdan sonra ne yapacağını nasıl bilir? Bir şeyin işe yarayıp yaramadığını nasıl anlar? Bu kararları koordine edecek bir şeye ihtiyacı vardır.
İşte bu döngüdür.
Kendini tekrar eden bir döngü.
Claude Code bir eylem gerçekleştirir, sonucu gözlemler, sırada ne yapacağına karar verir ve baştan başlar. Hedefe ulaşana kadar durmaz.
Bir şey başarısız olursa, geri döner, düzeltir ve devam eder.
Döngünün 3 aşaması vardır:
Bağlamı Topla → Ne yapması gerektiğini anlar. Dosyaları okur, kodu analiz eder, proje yapısını keşfeder.
Harekete Geç → Değişiklikleri uygular. Dosyaları düzenler, komutları çalıştırır, bağımlılıkları yükler.
Sonuçları Doğrula → Yaptığı şeyin çalıştığını kontrol eder. Testleri çalıştırır, hataları inceler, bir şey başarısız olursa düzeltir.
Döngü, ne istediğinize göre uyum sağlar.
Basit bir soru sadece bağlam toplamayı gerektirebilir. Bir hatayı düzeltmek, her üç aşamadan da birkaç kez geçebilir.
Claude Code, her adımın ne gerektirdiğine bir önceki adımdan öğrendiklerine dayanarak karar verir. Ve siz de bu döngünün bir parçasısınız.
İstediğiniz zaman onu yeniden yönlendirmek, bağlam eklemek veya farklı bir yaklaşım denemesini istemek için araya girebilirsiniz.
Bu, Claude Code'un kalbidir.
Bundan sonra gelen her şey, bu döngüyü daha güçlü kılmak için vardır.
Araçlar: Claude Code Dünyada Nasıl Hareket Eder
Bir LLM, tasarımı gereği, yalnızca metin işler.
Metin alır ve metin üretir. Dosya sisteminize erişimi yoktur, komut çalıştıramaz, projenizde ne olduğunu bilmez.
İzole edilmiştir.
Peki, Claude Code nasıl bir dosyayı açar veya değiştirir?
Araçları kullanır.
Araçlar, Claude Code'un gerçek dünya ile etkileşime girmek için çağırabileceği fonksiyonlardır.
Bunu mobil uygulamalar gibi düşünün. Telefon tek başına hiçbir şey yapmaz: ona belirli yetenekler kazandıran uygulamalardır: fotoğraf çekmek, mesaj göndermek, navigasyon yapmak.
Araçlar da Claude Code için aynıdır.
Bir aracı her kullandığında, sisteme ihtiyacı olan şeyle birlikte bir istek gönderir. Sistem onu çalıştırır ve sonucu döndürür.
Claude Code, sırada ne yapacağına karar vermek için bu sonucu kullanır.
1Sizin isteğiniz2 ↓3Claude Code hangi aracı kullanacağına karar verir4 ↓5┌─────────────────────────────────┐6│ Read · Edit · Write · Bash │7│ Grep · Glob · WebFetch · WebSearch │8└─────────────────────────────────┘9 ↓10Sistem aracı çalıştırır11 ↓12Sonuç Claude Code'a döner13 ↓14Bitti mi? → Hayır → başka bir araç kullan15 Evet → yanıtla
Claude Code, en yaygın işlemler için yerleşik araçlarla gelir:
Read / Edit / Write → Dosyaları okur, değiştirir ve oluşturur. En çok kullanılanlar. Claude Code her "kodunuzu anladığında" veya "bir değişiklik yaptığında" bu üçünü kullanıyordur.
Bash → Terminale tam erişim. Komut satırından yapabiliyorsanız, Claude Code da yapabilir: bağımlılıkları yüklemek, testleri çalıştırmak, commit yapmak.
Grep ve Glob → Proje içinde arama yapar. Glob, dosyaları adına veya modeline göre bulur. Grep, dosyaların içinde belirli bir içeriği arar.
WebFetch ve WebSearch → İnternet erişimi. Dokümantasyona danışmak, bir API'yi okumak, daha önce hiç görmediği bir hatayı araştırmak için kullanılır.
Giriş butonundaki hata örneğine geri dönelim.
Claude Code bunun üzerinde çalışırken, birden fazla aracı birlikte kullanır:
→ Bileşen dosyasını bulmak için Glob'u kullanır
→ Kodu okuyup neler olduğunu anlamak için Read'i kullanır
→ Hatayı düzeltmek için Edit'i kullanır
→ Testleri çalıştırıp çalıştığını doğrulamak için Bash'i kullanır
Tüm bunlar siz müdahale etmeden. Bir sohbet ile bir agent arasındaki fark budur.
Bağlam ve Bellek: Claude Code Neyi Hatırlar
Claude Code çalışır, eylemler gerçekleştirir, sonuçlar alır ve sırada ne yapacağına karar verir.
Peki ilerledikçe ne yaptığını nasıl bilir?
Her şey bağlam sayesinde.
Bağlam, Claude Code'un o anda sahip olduğu bilgidir. Her eylemi gerçekleştirdiğinde, sonuç orada birikir.
Sadece ilk prompt'unuz değil, bulduğu her şey: açtığı dosyalar, kodda keşfettikleri, gerçekleştirdiği eylemler ve bunların sonuçları.
Bu yüzden adımları zincirleyebilir, kendini düzeltebilir ve görevi tek başına bitirebilir.
Bu bağlamın 2 sorunu vardır.
1. Sınırlı kapasitesi vardır. Oturum çok uzunsa, bağlam dolar ve Claude Code daha önce ne olduğunu unutmaya başlar. Daha sonra SubAgent'lerin bunu nasıl çözdüğünü göreceksiniz.
2. Her yeni konuşma açtığınızda boşalır. Claude Code hangi projede olduğunuzu, ekibinizin nasıl çalıştığını veya daha önce hangi kararları aldığınızı bilmez. Söylemezseniz, tahmin eder veya size sorar.
Bellek ikinci sorunu çözer.
Claude Code'un bilmesi gereken her şeyi kaydettiğiniz bir işaretleme dosyası sistemidir: teknoloji yığınınız, ekip kurallarınız, projelerin nasıl yapılandırıldığı.
Claude Code, her oturumun başında bunları okur ve siz ilk satırı yazmadan önce bu bilgiyi bağlama enjekte eder.
Bellek Olmadan: Ona "kullanıcı oluşturmak için bir uç nokta ekle" dersiniz ve Claude Code size sorar: "Hangi framework'ü kullanıyorsun? Yapılandırılmış bir veritabanın var mı? Rotalar nasıl yapılandırılmış?"
Bellekle: Aynı şeyi söylersiniz ve o zaten Express ile Prisma kullandığınızı, rotaların /src/routes içinde olduğunu ve hataların merkezi bir ara yazılım ile ele alındığını bilir. Sormadan çalışmaya başlar.
Claude Code'un 2 bellek sistemi vardır:
→ CLAUDE.md - Claude Code'un bilmesi gereken her şeyi yazdığınız işaretleme dosyaları. Farklı seviyelerde bulunabilirler:
→ ~/.claude/CLAUDE.md - Tüm projeleriniz için geçerlidir. Kişisel tercihleriniz buraya gider: kodun nasıl yazılmasını istediğiniz, her zaman kullandığınız kurallar. Talimatlar spesifik olmalıdır: "2 boşluklu girinti kullan", "kodu iyi biçimlendir" ifadesinden daha açıktır.
→ /proje-adiniz/CLAUDE.md - Depoya özgüdür. Mimari, ekip kuralları ve önemli komutlar buraya gider. Yeni bir projeye başladığınızda /init komutunu çalıştırın; Claude Code onu otomatik olarak oluşturur. 200 satırın altında tutun: çok büyürse, Claude Code talimatları yok saymaya başlar. Ve depoya eklerseniz, tüm ekip aynı bağlamı paylaşır.
→ .claude/rules/ - Dosya türüne göre etkinleşen modüler kurallar. Proje büyüdüğünde ve her şeyi tek bir dosyaya koymak istemediğinizde kullanışlıdır.
Otomatik Bellek - Claude Code'un kendi kendine oluşturduğu bellektir. Siz çalışırken, kendi kendine notlar alır: algıladığı desenler, yaptığınız düzeltmeler, birlikte aldığınız kararlar.
~/.claude/projects/<proje>/memory/ içinde kaydedilir ve her oturumun başında yüklenir.
Sık sık gözden geçirin: Claude Code, siz fark etmeden kötü uygulamaları kaydetmiş olabilir.
İpucu: /memory komutunu çalıştırarak Claude Code'un hatırladığı her şeyi görebilir ve düzenleyebilirsiniz.
Hooks ve Skill'ler: Kontrolü Ele Alın
1. Hooks
Claude Code özerk bir şekilde çalışır.
Eylemler gerçekleştirir, kararlar alır, ilerler.
Ancak bu özerkliğin pek bahsedilmeyen bir tarafı vardır: Claude Code, her adımda doğru olduğunu düşündüğü şeyi yapar.
Bir şey ters giderse veya istemediğiniz bir şey yaparsa, çoktan olmuştur.
Nasıl kontrol edersiniz? Hooks ile.
Bir Hook, döngünün belirli noktalarında otomatik olarak çalışan bir komuttur. Claude Code bir aracı kullanmadan önce, onu kullandıktan sonra, oturum bittiğinde.
Her an ne olacağını siz tanımlarsınız.
Anahtar nokta, hooks'ların deterministik olmasıdır.
Claude Code'un bir şeyi "hatırlamasına" bağlı değildirler. İstisnasız, her zaman çalıştırılırlar.
Dört ana hook şunlardır:
PreToolUse - Claude Code bir aracı kullanmadan önce çalışır. Bir eylemi engelleyebilen tek hook'tur. Örnek: .env dosyalarını değiştirmeye çalışan herhangi bir komutu engellemek.
PostToolUse - Claude Code bir aracı kullandıktan sonra çalışır. Örnek: Claude Code bir dosyayı her düzenlediğinde Prettier'ı otomatik olarak çalıştırmak.
Notification - Claude Code'un dikkatinize ihtiyacı olduğunda çalışır. Örnek: Claude Code uzun bir görevi bitirdiğinde Mac'inizde bir bildirim almak.
Stop - Claude Code yanıt vermeyi bitirdiğinde çalışır. Örnek: Agent işini bitirdiğinde otomatik olarak staging'e push yapmak.
Bunlar .claude/settings.json dosyasında yapılandırılır:
1{2 "hooks": {3 "PostToolUse": [4 {5 "matcher": "Edit|Write",6 "hooks": [7 {8 "type": "command",9 "command": "npx prettier --write $file_path"10 }11 ]12 }13 ]14 }15}
Bu hook, Claude Code her dosyayı düzenlediğinde veya oluşturduğunda Prettier'ı otomatik olarak çalıştırır.
Siz sormadan. Claude Code'un bunu hatırlamasına gerek kalmadan.
Hook Olmadan: Claude Code bir dosyayı düzenler, kod biçimlendirilmemiş kalır ve siz bunu bir sonraki commit'te fark edersiniz.
Hook İle: Claude Code bir dosyayı düzenler, PostToolUse otomatik olarak tetiklenir, Prettier dosyayı biçimlendirir ve kod her zaman temiz kalır.
Hooks, agent'ın döngüsüne garantili davranış eklemenizi sağlar. Öneriler değil, modelin yok sayabileceği talimatlar değil. Her zaman çalıştırılan kurallar.
2. Skill'ler
Başka bir sorun daha vardır: tutarlılık.
Aynı görevi iki kez istersiniz ve farklı sonuçlar alırsınız. Her yeni konuşma açtığınızda, Claude Code en son nasıl yaptığınızı bilmeden başlar.
Nasıl çözersiniz? Skill'ler ile.
Bir Skill, bir görev için Claude Code'a tam süreci açıkladığınız bir işaretleme dosyasıdır: neleri inceleyeceği, hangi sırayla, hangi formatı kullanacağı, neleri yok sayacağı.
Bu görev her ortaya çıktığında, Claude Code bu talimatları izler.
Skill Olmadan: Bir API'yi belgelemesini istersiniz ve bir şeyler üretir, ancak her seferinde farklı bir formatta. Bazen örneklerle, bazen onsuz.
Skill İle: Bir API'yi belgelemesini istersiniz ve tanımladığınız tam süreci izler. Her zaman aynı adımlarla, aynı formatta, aynı kriterlerle. Her seferinde aynı.
Bir Skill oluşturmak için, bu yapıda bir klasör tanımlarsınız:
1my-skill/2├── SKILL.md # Ana talimatlar (gerekli)3├── template.md # Claude'un tamamladığı şablon4├── examples/5│ └── sample.md # Beklenen çıktı örneği6└── scripts/7 └── validate.sh # Claude'un çalıştırabileceği betik
Zorunlu olan tek dosya SKILL.md'dir. Gerisi isteğe bağlıdır ve görevin neye ihtiyacı olduğuna göre eklersiniz.
SKILL.md'nin 2 bölümü vardır:
Ön yüz (frontmatter) - Adı ve açıklaması olan bir YAML bloğu. Ad, onu manuel olarak çağırmak için kullanılan komuttur. Açıklama, Claude Code'un otomatik olarak ne zaman etkinleştirileceğine karar vermek için okuduğu şeydir.
Gövde - İşaretleme formatındaki talimatlar. İş akışı, kriterler, çıktı formatı.
1---2name: api-docs3description: API uç noktalarını belgeler. Kullanıcı bir API'yi4 belgelemeyi istediğinde veya "swagger" ya da "endpoints"ten5 bahsettiğinde kullanın6---78## Süreç91. Tüm uç noktaları belirleyin102. Her biri için: yöntem, yol, parametreler, beklenen yanıt113. Bir istek ve yanıt örneği ekleyin124. Bir özet tablosu ile kapatın
Oluşturulduktan sonra, onu iki şekilde çağırabilirsiniz.
Doğrudan sohbete /api-docs yazarak veya sadece Claude Code'a doğal dilde sorarak.
Açıklama, sorduğunuz şeye uyuyorsa, kendi kendine etkinleşir.
Arkasında net bir süreç olan ve tekrarladığınız herhangi bir görev için oluşturabilirsiniz: API dokümantasyonu, değişiklik günlükleri, toplantı özetleri, kod geçişleri.
SubAgent'ler: Sorun Büyüdüğünde Devredin
Bağlamın sınırlı kapasiteye sahip olduğunu görmüştük.
Oturum ne kadar uzun olursa, o kadar dolar. Ve dolduğunda, Claude Code daha önce ne olduğuna dair bilgileri kaybetmeye başlar.
Diyelim ki tüm projenizi güvenlik sorunları için incelemesini istiyorsunuz. Düzinelerce dosyayı okur, kodu analiz eder, ayrıntılı bir rapor oluşturur.
Tüm bunlar bağlamı hızla doldurur.
Ve bunu yaparken, ana konuşmanız bloke olur.
Bunu nasıl çözersiniz? SubAgent'ler ile.
SubAgent, kendi bağlamıyla çalışan ayrı bir Claude Code örneğidir.
Ana agent, bir görevi ona devreder, SubAgent onu bağımsız olarak yürütür ve bitirdiğinde sonuçlarla birlikte bir özet gönderir.
Ana agent'ın bağlamı tüm süreçle dolmaz, sadece sonuçla dolar.
1Ana Agent2 ↓3"projeyi güvenlik sorunları için incele"4 ↓5┌─────────────────────────────┐6│ SubAgent: security-reviewer │7│ │8│ Proje dosyalarını okur │9│ Kodu analiz eder │10│ Güvenlik açıklarını tespit eder │11│ Rapor oluşturur │12└─────────────────────────────┘13 ↓14Ana agent'a özeti döndürür15 ↓16Ana agent döngüye devam eder
Ve sadece bu da değil.
SubAgent'ler paralel olarak çalışabilir.
Kodun üç bölümünü sırayla analiz etmek yerine, Claude Code üçünü de aynı anda devredebilir.
Dakikalar süren şey saniyeler sürebilir.
1Ana Agent2 ↓3İşi bağımsız görevlere böler4 ↓5┌──────────────┐ ┌──────────────┐ ┌──────────────┐6│ SubAgent 1 │ │ SubAgent 2 │ │ SubAgent 3 │7│ │ │ │ │ │8│ Kimlik doğ. │ │ DB'yi inceler │ │ Harici │9│ kontrollerini │ │ │ │ API'leri │10│ inceler │ │ │ │ inceler │11└──────────────┘ └──────────────┘ └──────────────┘12 ↓ ↓ ↓13 Ana agent üç özeti alır14 ↓15 Döngüye devam eder
Claude Code'un otomatik olarak kullandığı 3 yerel SubAgent'i vardır:
→ Explore - Projede arama ve analiz yapma konusunda uzmanlaşmış, hızlı, salt okunur bir agent. Sonuçlar sizin bağlamınızda değil, SubAgent'in bağlamında kalır.
→ Plan - Planlama modunda etkinleşir. Claude Code size bir plan sunmadan önce, proje araştırmasını bu agent'a devreder.
→ Genel amaçlı - Hem keşif hem de değişiklik gerektiren karmaşık görevler için.
Kendi SubAgent'lerinizi de oluşturabilirsiniz.
SubAgent'ler, YAML ön yüzü olan işaretleme dosyalarında tanımlanır ve .claude/agents/ içinde kaydedilir.
1---2name: security-reviewer3description: Güvenlik açıkları için kodu inceler.4 Kullanıcı bir güvenlik incelemesi istediğinde kullanın.5tools: Read, Grep, Glob6---78Siz bir güvenlik uzmanısınız. Kodu aşağıdakiler için analiz edin:9- SQL Enjeksiyonları10- Hassas verilerin ifşası11- Kimlik doğrulama güvenlik açıkları1213Bulguları ciddiyete göre sıralanmış bir özet ile bitirin.
Ön yüzde araçları Read, Grep ve Glob ile sınırladığımıza dikkat edin.
Bu agent analiz edebilir ancak asla hiçbir şeyi değiştiremez.
Her agent'ın ne yapabileceği üzerinde ince bir kontrole ihtiyacınız olduğunda, bu araç kısıtlaması çok önemlidir.
Oluşturulduktan sonra, Claude Code onu açıklamaya göre otomatik olarak algılar ve görev uyduğunda çağırır. Veya açıkça çağırabilirsiniz: "Bu PR'ı incelemek için security-reviewer agent'ını kullan."
SubAgent'ler ne zaman kullanılmalı ve ne zaman kullanılmamalı?
Görev uzunsa ve çok fazla çıktı üretecekse, işi paralel olarak çalıştırılabilecek bağımsız parçalara bölebiliyorsanız veya sınırlı araçlara sahip özel bir agent'a ihtiyacınız varsa mantıklıdır.
Bağlamı doldurmayan kısa görevler için buna değmez. SubAgent'leri koordine etmek, ana agent görevi iki dakikada çözebiliyorsa anlamlı olmayan bir karmaşıklık ekler.
MCP: Agent'ı Dış Dünyaya Bağlamak
Araçlar, Claude Code'a makinenizde hareket etme yeteneği verir.
Ancak bir sınır vardır: olan her şey, orada olur.
GitHub'da bir PR açamaz, bir üretim veritabanını sorgulayamaz veya Jira'da bir bilet oluşturamaz. Bunu yapmak için, daha önce agent'tan ayrılmanız ve kendiniz elle yapmanız gerekiyordu.
Bunu nasıl çözersiniz? MCP ile.
MCP (Model Context Protocol), Claude Code'un harici hizmetlerle nasıl bağlanacağını tanımlayan açık bir protokoldür.
İstemci-sunucu mimarisiyle çalışır: Claude Code istemcidir ve her harici hizmetin, neler yapabileceğini gösteren kendi MCP sunucusu vardır.
Bir MCP sunucusuna bağlandığınızda, Claude Code, adları ve açıklamalarıyla birlikte mevcut araçların bir listesini alır.
Buradan itibaren, onları tıpkı yerel araçlar gibi kullanır. Tek fark, eylemin sizin makinenizde değil, harici hizmette gerçekleşmesidir.
1Claude Code2 ↓3GitHub MCP Sunucusundan bir araç kullanmaya karar verir4 ↓5┌─────────────────────────────┐6│ GitHub MCP Sunucusu │7│ │8│ PR'ı açar │9│ İnceleyiciler atar │10│ Onay döndürür │11└─────────────────────────────┘12 ↓13Claude Code sonucu alır ve devam eder
MCP Olmadan: Ona "Değişiklikleri bitirdim, PR'ı aç" dersiniz ve Claude Code yapamaz. GitHub'a gitmeniz, formu doldurmanız, inceleyiciler atamanız ve kendiniz birleştirmeniz gerekir.
MCP İle: Aynı şeyi söylersiniz ve Claude Code PR'ı açar, açıklamayı yazar, inceleyicileri atar ve hazır olduğunda size haber verir. Hepsi siz agent'tan ayrılmadan.
Bugün bağlanabileceğiniz bazı MCP sunucuları:
→ GitHub - PR'lar, incelemeler, konular
→ Postgres / Supabase - Veritabanlarını sorgulama ve değiştirme
→ Slack - Mesajlar ve kanallar
→ Jira - Biletler ve projeler
Yerel ortamınız için yerel araçlar. Dış dünya için MCP.
Hepsi Nasıl Bir Araya Geliyor
Claude Code bir agent'tır: bir hedef alan ve onu yerine getirene kadar özerk bir döngüde çalışan bir sistem.
Bu makalede gördüğünüz her parça, bu döngüyü daha güçlü kılmak için vardır. Ancak en iyi anlama yolu, onları birlikte etkileşim halinde görmektir.
Durum 1: Bir PR'ı inceleyip birleştirme
Claude Code'a şunu söylüyorsunuz: "PR #42'yi incele ve her şey yolundaysa birleştir."
→ Değiştirilen dosyaları okumak ve değişiklikleri anlamak için GitHub MCP'yi kullanır
→ Ana bağlamı doldurmamak için güvenlik analizini özel bir SubAgent'e devreder
→ Bir Hook, testleri yerel olarak çalıştırır ve her şeyin geçtiğini doğrular
→ Testler geçerse, siz arayüze dokunmadan birleştirmeyi gerçekleştirmek için GitHub MCP'yi kullanır
Bir satır yazdınız. Claude Code dört sistemi koordine etti.
Durum 2: Bir API'yi belgeleyip ekibi bilgilendirme
Claude Code'a şunu söylüyorsunuz: "Yeni uç noktaları belgele ve ekibe haber ver."
→ Tam formatı tanımlayan bir dokümantasyon Skill'ini etkinleştirir: neyin dahil edileceği, nasıl yapılandırılacağı, hangi örneklerin ekleneceği
→ Kodu okumak ve uç noktaları çıkarmak için Araçları kullanır
→ Bir Hook, kaydetmeden önce çıktıyı biçimlendirir
→ Özeti ekip kanalına göndermek için Slack MCP'yi kullanır
Bunu her yaptığınızda, sonuç aynı olacaktır. Farklılıklar olmadan, sizin hiçbir şey açıklamanıza gerek kalmadan.
Her şey döngü etrafında döner.
Her oturuma bilgili başlamak için Bellek. Harekete geçmek için Araçlar. Kontrol etmek için Hooks. Standartlaştırmak için Skill'ler. Ölçeklendirmek için SubAgent'ler. Dış dünyayla bağlantı kurmak için MCP.
Bunu anladığınızda, Claude Code'u anlarsınız.
Ve sadece Claude Code'u değil: Cursor, Copilot ve bundan sonra kullanacağınız herhangi bir agent aynı temeller üzerinde çalışır.
İsimler değişir, arayüz değişir, ancak döngü aynıdır.
Yapay zeka hızla ilerliyor.
Her hafta yeni bir şey var. Ancak temeller o kadar sık değişmiyor. Bunları netleştirmek, daha hızlı uyum sağlamanızı ve gelecek olanlardan daha fazla yararlanmanızı sağlayacak.
Claude Code'u sadece prompt yazmak için kullanmayın. Altında olup bitenlere dikkat edin. Fırsatlar orada.
Bugün başlamak için bazı başlangıç noktaları:
→ Otomatik Belleğinizi gözden geçirin ve Claude Code'un kaydettiklerini iyileştirin
→ Projeniz için bir CLAUDE.md dosyası oluşturun (henüz yoksa)
→ GitHub MCP'yi bağlayın
→ Bağlamı dolduran görevler için bir SubAgent oluşturun
→ Her değişiklikten sonra testleri çalıştıran bir Hook yapılandırın
Bu kadar, yarın görüşürüz.
Marcus
