Özet
Claude Code kaynak kodu sızıntısı, 31 Mart 2026 tarihinde 512.000 satırlık bir TypeScript kod tabanını ortaya çıkardı. Mimari, Claude API'sini çağıran, araç çağrılarını gönderen ve sonuçları geri besleyen bir while döngüsüne indirgeniyor. Kendi sürümünüzü Python, Anthropic SDK ve temel döngü için yaklaşık 200 satır kod kullanarak oluşturabilirsiniz. Bu kılavuz, her bir bileşeni ayrıntılarıyla anlatıyor ve bunları nasıl yeniden oluşturacağınızı gösteriyor.
Giriş
31 Mart 2026'da Anthropic, @anthropic-ai/claude-code npm paketinin 2.1.88 sürümünün içine 59.8 MB'lık bir kaynak haritası dosyası gönderdi. Kaynak haritaları, küçültülmüş JavaScript'i orijinal kaynağına döndüren hata ayıklama yapıtlarıdır. Anthropic'in derleme aracı (Bun'ın paketleyicisi) bunları varsayılan olarak ürettiği için, TypeScript kod tabanının tamamı kurtarılabilirdi.
Saatler içinde geliştiriciler, kodu onlarca GitHub deposuna yansıttı. Topluluk, ana aracı döngüsünden "gizli mod" ve sahte araç enjeksiyonu gibi gizli özelliklere kadar her modülü hızla inceledi.
Tepkiler ikiye ayrıldı. Bazıları Anthropic'in güvenlik uygulamalarını eleştirdi. Diğerleri ise mimariye hayran kaldı. Ancak en verimli yanıt, "Bunu kendim yapabilir miyim?" diye soran geliştiricilerden geldi.
Cevap evet. Temel desenler basittir. Bu kılavuz, her bir mimari katmanı ele alacak, Anthropic'in neden bu seçimleri yaptığını açıklayacak ve başlangıç noktası olarak kullanabileceğiniz çalışan kod sağlayacaktır. Ayrıca, çok turlu API konuşmalarında hata ayıklamayı ham curl komutlarından çok daha kolay hale getiren Apidog ile özel aracınızın API etkileşimlerini nasıl test edeceğinizi de öğreneceksiniz.
Sızıntı, Claude Code'un mimarisi hakkında neyi ortaya çıkardı?
Kod tabanına bir bakış
Dahili olarak "Tengu" kod adlı Claude Code, yaklaşık 1.900 dosyadan oluşuyor. Modül organizasyonu net katmanlara ayrılıyor:
cli/ - Terminal UI (React + Ink)
tools/ - 40+ tool implementations
core/ - System prompts, permissions, constants
assistant/ - Agent orchestration
services/ - API calls, compaction, OAuth, telemetry
CLI'nin kendisi, terminal çıktısı için bir React renderer olan Ink aracılığıyla oluşturulmuş bir React uygulamasıdır. Yerleşim için Yoga'yı (bir CSS flexbox motoru) ve stil için ANSI kaçış kodlarını kullanır. Her konuşma görünümü, giriş alanı, araç çağrısı gösterimi ve izin iletişim kutusu bir React bileşenidir.
Bu, çoğu kendin yap projesi için aşırı mühendislik ürünüdür. Çalışan bir kodlama aracısı oluşturmak için React tabanlı bir terminal kullanıcı arayüzüne ihtiyacınız yok. Basit bir REPL döngüsü gayet iyi çalışır.
Ana aracı döngüsü
Kullanıcı arayüzünü, telemetriyi ve özellik bayraklarını çıkarırsak, Claude Code'un çekirdeği bir while döngüsüdür. Anthropic dahili olarak buna "nO" der. İşte yaptığı şeyler:
- Claude API'ye mesaj gönder (sistem istemi + araç tanımları)
- Metin ve/veya
tool_useblokları içeren bir yanıt al - Her istenen aracı, ad-işleyici dağıtım haritası aracılığıyla yürüt
- Araç sonuçlarını mesaj listesine geri ekle
- Yanıt daha fazla araç çağrısı içeriyorsa, 1. adıma geri dön
- Yanıt, araç çağrısı içermeyen düz metinse, kullanıcıya döndür
Bir "tur", bir tam gidiş-dönüş seferidir. Turlar, Claude araç çağrısı olmayan metin üretinceye kadar devam eder. Tüm aracı deseni budur.
İşte çekirdeği yakalayan minimal bir Python sürümü:
import anthropic
client = anthropic.Anthropic()
MODEL = "claude-sonnet-4-6"
def agent_loop(system_prompt: str, tools: list, messages: list) -> str:
"""The core agent loop - keep calling until no more tool use."""
while True:
response = client.messages.create(
model=MODEL,
max_tokens=16384,
system=system_prompt,
tools=tools,
messages=messages,
)
# Add assistant response to conversation
messages.append({"role": "assistant", "content": response.content})
# If the model stopped without requesting tools, we're done
if response.stop_reason != "tool_use":
# Extract the final text
return "".join(
block.text for block in response.content
if hasattr(block, "text")
)
# Execute each tool call and collect results
tool_results = []
for block in response.content:
if block.type == "tool_use":
result = execute_tool(block.name, block.input)
tool_results.append({
"type": "tool_result",
"tool_use_id": block.id,
"content": result,
})
# Feed results back as a user message
messages.append({"role": "user", "content": tool_results})
Bu yaklaşık 30 satır. Claude Code'un geri kalan karmaşıklığı, araçların kendisinden, izin sisteminden, bağlam yönetiminden ve bellekten geliyor.
Araç sistemini oluşturma
Neden özel araçlar tek bir bash komutundan daha iyidir?
Sızıntıdaki en net mimari kararlardan biri: Claude Code, dosya işlemleri için her şeyi bash üzerinden yönlendirmek yerine özel araçlar kullanıyor.
Bir Read aracı (cat değil), bir Edit aracı (sed değil), bir Grep aracı (grep değil) ve bir Glob aracı (find değil) bulunmaktadır. Sistem istemi, modele bunları bash eşdeğerlerine tercih etmesini açıkça söyler.
Neden? Üç nedeni var:
- Yapılandırılmış çıktı. Özel bir
Greparacı, modelin ayrıştırabileceği tutarlı bir biçimde sonuçlar döndürür. Bash komutlarını yönlendirmek, modelin yorumlamakta zorlandığı öngörülemeyen çıktılar üretir. - Güvenlik. Claude Code'daki
BashTool, enjeksiyonu önlemek için ters tırnakları ve$()alt kabuk sözdizimini engeller. Özel araçlar bu riski tamamen ortadan kaldırır. - Token verimliliği. Araç sonuçları kesilebilir, örneklenmiş olabilir veya diske boşaltılabilir. Büyük
catçıktıları bağlam penceresi tokenlarını israf eder.
Temel araç seti
Sızıntıya göre, Claude Code varsayılan olarak 20'den az aracı kullanıma sunuyor, 60'tan fazlası ise özellik bayraklarının arkasında. Kendin yap bir aracı için beş tanesine ihtiyacınız var:
TOOLS = [
{
"name": "read_file",
"description": "Read a file from the filesystem. Returns contents with line numbers.",
"input_schema": {
"type": "object",
"properties": {
"file_path": {
"type": "string",
"description": "Absolute path to the file"
},
"offset": {
"type": "integer",
"description": "Line number to start reading from (0-indexed)"
},
"limit": {
"type": "integer",
"description": "Max lines to read. Defaults to 2000."
}
},
"required": ["file_path"]
}
},
{
"name": "write_file",
"description": "Write content to a file. Creates the file if it doesn't exist.",
"input_schema": {
"type": "object",
"properties": {
"file_path": {"type": "string", "description": "Absolute path"},
"content": {"type": "string", "description": "File content to write"}
},
"required": ["file_path", "content"]
}
},
{
"name": "edit_file",
"description": "Replace a specific string in a file. The old_string must be unique.",
"input_schema": {
"type": "object",
"properties": {
"file_path": {"type": "string", "description": "Absolute path"},
"old_string": {"type": "string", "description": "Text to find"},
"new_string": {"type": "string", "description": "Replacement text"}
},
"required": ["file_path", "old_string", "new_string"]
}
},
{
"name": "run_command",
"description": "Execute a shell command and return stdout/stderr.",
"input_schema": {
"type": "object",
"properties": {
"command": {"type": "string", "description": "Shell command to run"},
"timeout": {"type": "integer", "description": "Timeout in seconds. Default 120."}
},
"required": ["command"]
}
},
{
"name": "search_code",
"description": "Search for a regex pattern across files in a directory.",
"input_schema": {
"type": "object",
"properties": {
"pattern": {"type": "string", "description": "Regex pattern"},
"path": {"type": "string", "description": "Directory to search"},
"file_glob": {"type": "string", "description": "File pattern filter, e.g. '*.py'"}
},
"required": ["pattern"]
}
}
]
Araç işleyici dağıtımı
Araç yürütme işlevi, araç adlarını işleyici işlevlere eşler:
import subprocess
import os
import re
def execute_tool(name: str, params: dict) -> str:
"""Dispatch tool calls to their handlers."""
handlers = {
"read_file": handle_read_file,
"write_file": handle_write_file,
"edit_file": handle_edit_file,
"run_command": handle_run_command,
"search_code": handle_search_code,
}
handler = handlers.get(name)
if not handler:
return f"Error: Unknown tool '{name}'"
try:
return handler(params)
except Exception as e:
return f"Error: {str(e)}"
def handle_read_file(params: dict) -> str:
path = params["file_path"]
offset = params.get("offset", 0)
limit = params.get("limit", 2000)
with open(path, "r") as f:
lines = f.readlines()
selected = lines[offset:offset + limit]
numbered = [f"{i + offset + 1}\t{line}" for i, line in enumerate(selected)]
return "".join(numbered)
def handle_write_file(params: dict) -> str:
path = params["file_path"]
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, "w") as f:
f.write(params["content"])
return f"Successfully wrote to {path}"
def handle_edit_file(params: dict) -> str:
path = params["file_path"]
with open(path, "r") as f:
content = f.read()
old = params["old_string"]
if content.count(old) == 0:
return f"Error: '{old[:50]}...' not found in {path}"
if content.count(old) > 1:
return f"Error: '{old[:50]}...' matches {content.count(old)} locations. Be more specific."
new_content = content.replace(old, params["new_string"], 1)
with open(path, "w") as f:
f.write(new_content)
return f"Successfully edited {path}"
def handle_run_command(params: dict) -> str:
cmd = params["command"]
timeout = params.get("timeout", 120)
# Basic safety: block dangerous patterns
blocked = ["rm -rf /", "mkfs", "> /dev/"]
for pattern in blocked:
if pattern in cmd:
return f"Error: Blocked dangerous command pattern: {pattern}"
result = subprocess.run(
cmd, shell=True, capture_output=True, text=True,
timeout=timeout, cwd=os.getcwd()
)
output = ""
if result.stdout:
output += result.stdout
if result.stderr:
output += f"\nSTDERR:\n{result.stderr}"
if not output.strip():
output = f"Command completed with exit code {result.returncode}"
# Truncate large outputs to save context tokens
if len(output) > 30000:
output = output[:15000] + "\n\n... [truncated] ...\n\n" + output[-15000:]
return output
def handle_search_code(params: dict) -> str:
pattern = params["pattern"]
path = params.get("path", os.getcwd())
file_glob = params.get("file_glob", "")
cmd = ["grep", "-rn", "--include", file_glob, pattern, path] if file_glob else \
["grep", "-rn", pattern, path]
result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
if not result.stdout.strip():
return f"No matches found for pattern: {pattern}"
lines = result.stdout.strip().split("\n")
if len(lines) > 50:
return "\n".join(lines[:50]) + f"\n\n... ({len(lines) - 50} more matches)"
return result.stdout
Bağlam yönetimi: zor sorun
Neden bağlam, istem mühendisliğinden daha önemlidir?
Sızdırılan kaynak, Claude Code'un sistem isteminin kendisinden çok bağlam yönetimine daha fazla mühendislik çabası harcadığını ortaya koyuyor. Bağlam sıkıştırıcısı (dahili olarak "wU2" olarak adlandırılır) beş stratejiye sahiptir.
Kendin yap bir yapı için iki tanesine ihtiyacınız var:
Otomatik sıkıştırma, konuşma bağlam penceresi sınırına yaklaştığında tetiklenir. Claude Code yaklaşık %92 kullanımda tetiklenir ve özetin kendisi için 13.000 tokenlık bir tampon ayırır.
CLAUDE.md yeniden enjeksiyonu, uzun oturumlar sırasında proje yönergelerinin kaymamasını sağlar. Claude Code, proje yapılandırmasını başlatma sırasında değil, her turda yeniden enjekte eder. Bu, bir kodlama aracısının yolda kalması için en etkili tek desendir.
Basit bir sıkıştırıcı oluşturma
def maybe_compact(messages: list, system_prompt: str, max_tokens: int = 180000) -> list:
"""Compact conversation when it gets too long."""
# Rough estimate: 4 chars per token
total_chars = sum(
len(str(m.get("content", ""))) for m in messages
)
estimated_tokens = total_chars // 4
if estimated_tokens < max_tokens * 0.85:
return messages # Not yet at the limit
# Ask the model to summarize the conversation so far
summary_response = client.messages.create(
model=MODEL,
max_tokens=4096,
system="Summarize this conversation. Keep all file paths, decisions made, errors encountered, and current task state. Be specific about what was changed and why.",
messages=messages,
)
summary_text = summary_response.content[0].text
# Replace conversation with summary + recent messages
compacted = [
{"role": "user", "content": f"[Conversation summary]\n{summary_text}"},
{"role": "assistant", "content": "I have the context from our previous conversation. What should I work on next?"},
]
# Keep the last 4 messages for immediate context
compacted.extend(messages[-4:])
return compacted
Proje bağlamını yeniden enjekte etme
Claude Code, .claude/CLAUDE.md dosyasını okur ve her turda enjekte eder. İşte bunu nasıl çoğaltacağınız:
def build_system_prompt(project_dir: str) -> str:
"""Build system prompt with project context re-injection."""
base_prompt = """You are a coding assistant that helps with software engineering tasks.
You have access to tools for reading, writing, editing files, running commands, and searching code.
Always read files before modifying them. Prefer edit_file over write_file for existing files.
Keep responses concise. Focus on the code, not explanations."""
# Look for project guidelines
claude_md_path = os.path.join(project_dir, ".claude", "CLAUDE.md")
if os.path.exists(claude_md_path):
with open(claude_md_path, "r") as f:
project_context = f.read()
base_prompt += f"\n\n# Project guidelines\n{project_context}"
# Also check for a root CLAUDE.md
root_md = os.path.join(project_dir, "CLAUDE.md")
if os.path.exists(root_md):
with open(root_md, "r") as f:
root_context = f.read()
base_prompt += f"\n\n# Repository guidelines\n{root_context}"
return base_prompt
Üç katmanlı bellek sistemi
Sızdırılan kaynak, Claude Code'un üç katmanlı bir bellek mimarisi kullandığını gösteriyor. Bu, sistemin en az takdir edilen kısımlarından biridir.
Katman 1: MEMORY.md (her zaman yüklü)
Sistem isteminde her zaman kalan hafif bir dizin. Her giriş tek bir satır, 150 karakterden az. Daha derin bilgilere işaret eden bir içindekiler tablosu görevi görür. 200 satır / 25KB ile sınırlıdır.
- [User preferences](memory/user-prefs.md) - prefers TypeScript, uses Vim keybindings
- [API conventions](memory/api-conventions.md) - REST with JSON:API spec, snake_case
- [Deploy process](memory/deploy.md) - uses GitHub Actions, deploys to AWS EKS
Katman 2: Konu dosyaları (talep üzerine yüklenir)
Dizin alaka düzeyini önerdiğinde yüklenen ayrıntılı bilgi dosyaları. Bunlar, proje kurallarını, mimari kararları ve öğrenilmiş desenleri içerir.
Katman 3: Oturum transkriptleri (aranır, asla okunmaz)
Asla toptan yüklenmeyen tam oturum günlükleri. Aracı, belirli tanımlayıcılar için bunları grep ile arar. Bu, aranabilirliği korurken bağlam şişmesini önler.
Minimal bir bellek sistemi oluşturma
import json
MEMORY_DIR = ".agent/memory"
def load_memory_index() -> str:
"""Load the memory index for system prompt injection."""
index_path = os.path.join(MEMORY_DIR, "MEMORY.md")
if os.path.exists(index_path):
with open(index_path, "r") as f:
return f.read()
return ""
def save_memory(key: str, content: str, description: str):
"""Save a memory entry and update the index."""
os.makedirs(MEMORY_DIR, exist_ok=True)
# Write the memory file
filename = f"{key.replace(' ', '-').lower()}.md"
filepath = os.path.join(MEMORY_DIR, filename)
with open(filepath, "w") as f:
f.write(f"---\nname: {key}\ndescription: {description}\n---\n\n{content}")
# Update the index
index_path = os.path.join(MEMORY_DIR, "MEMORY.md")
index_lines = []
if os.path.exists(index_path):
with open(index_path, "r") as f:
index_lines = f.readlines()
# Add or update entry
new_entry = f"- [{key}]({filename}) - {description}\n"
updated = False
for i, line in enumerate(index_lines):
if filename in line:
index_lines[i] = new_entry
updated = True
break
if not updated:
index_lines.append(new_entry)
with open(index_path, "w") as f:
f.writelines(index_lines)
Aracının oturumlar arasında bilgiyi kalıcı hale getirebilmesi için araç listenize bir save_memory aracı ekleyin.
Bir izin sistemi ekleme
Sızıntı, beş izin modunu ortaya koyuyor: default (etkileşimli istemler), auto (ML tabanlı onay), bypass, yolo (her şeyi onayla) ve deny. Her araç eylemi DÜŞÜK, ORTA veya YÜKSEK risk olarak sınıflandırılır.
Kendin yap bir aracı için basit bir üç katmanlı sistem işe yarar:
# Risk levels for operations
RISK_LEVELS = {
"read_file": "low",
"search_code": "low",
"edit_file": "medium",
"write_file": "medium",
"run_command": "high",
}
def check_permission(tool_name: str, params: dict, auto_approve_low: bool = True) -> bool:
"""Check if the user approves this tool call."""
risk = RISK_LEVELS.get(tool_name, "high")
if risk == "low" and auto_approve_low:
return True
# Show the user what's about to happen
print(f"\n--- Permission check ({risk.upper()} risk) ---")
print(f"Tool: {tool_name}")
for key, value in params.items():
display = str(value)[:200]
print(f" {key}: {display}")
response = input("Allow? [y/n/always]: ").strip().lower()
if response == "always":
RISK_LEVELS[tool_name] = "low" # Auto-approve this tool going forward
return True
return response == "y"
Aracınızın API çağrılarını Apidog ile test etme
Bir kodlama aracısı oluşturmak, Claude'a yüzlerce API çağrısı yapmak anlamına gelir. Bu etkileşimlerde, özellikle araç kullanımıyla çok turlu konuşmalarda hata ayıklamak, ham günlüklerle zordur.
Apidog, aracınızın gönderdiği tam API isteklerini incelemenize ve test etmenize yardımcı olur. Geliştirme sırasında nasıl kullanacağınız aşağıda açıklanmıştır:
API isteklerini yakalama ve yeniden oynatma
Aracınızın Anthropic API'ye yaptığı çağrıları yakalamak için Apidog'u proxy olarak ayarlayın:
- Apidog'u açın ve aracınız için yeni bir proje oluşturun
- Anthropic Mesajlar API uç noktasını içe aktarın:
POST https://api.anthropic.com/v1/messages - İstek gövdesini sistem isteminiz, araç diziniz ve mesajlarınızla ayarlayın
- Yakalanan istekleri değiştirilmiş parametrelerle yeniden oynatarak tek tek turları test edin
Bu, tam aracı döngüsünü çalıştırmadan belirli araç kullanım turlarını izole etmenizi sağlar. Model beklenmedik bir araç çağrısı veya sanrılı bir parametre döndürdüğünde, Apidog'un görsel düzenleyicisinde istek gövdesini değiştirebilir ve farklı girdilerin yanıtı nasıl değiştirdiğini görmek için yeniden gönderebilirsiniz.
Çok turlu konuşmalarda hata ayıklama
Aracı hata ayıklamanın en zor kısmı, bir konuşma durumunu yeniden üretmektir. Apidog'un ortam değişkenleri, konuşma anlık görüntülerini kaydetmenize olanak tanır:
- Her turdan sonra tam
messagesdizisini bir ortam değişkeni olarak kaydedin - Konuşmanın herhangi bir noktasından yeniden oynatın
- Davranışın nerede farklılaştığını bulmak için çalıştırmalar arasındaki araç sonuçlarını karşılaştırın
Araç şemalarını doğrulama
Araç tanımlarınız (API'ye ilettiğiniz JSON şemaları), modelin ne talep edebileceğini belirler. Hatalı şemalar, modelin bir aracı atlamasına veya yanlış parametreler geçirmesine neden olan sessiz arızalara yol açar.
Araç şemalarınızı Apidog'a aktarın ve API'ye ulaşmadan önce sorunları yakalamak için JSON Şema doğrulayıcısını kullanın. Aracınızın API etkileşimlerinde hata ayıklamaya başlamak için Apidog'u indirin.
Hepsini bir araya getirme: eksiksiz REPL
İşte çalışan bir REPL olarak bir araya getirilmiş tam aracı:
#!/usr/bin/env python3
"""A minimal Claude Code-style coding agent."""
import anthropic
import os
import sys
client = anthropic.Anthropic()
MODEL = "claude-sonnet-4-6"
PROJECT_DIR = os.getcwd()
def main():
system_prompt = build_system_prompt(PROJECT_DIR)
memory = load_memory_index()
if memory:
system_prompt += f"\n\n# Memory\n{memory}"
messages = []
print("Coding agent ready. Type 'quit' to exit.\n")
while True:
user_input = input("> ").strip()
if user_input.lower() in ("quit", "exit"):
break
if not user_input:
continue
messages.append({"role": "user", "content": user_input})
# Compact if needed
messages = maybe_compact(messages, system_prompt)
# Re-inject project context (Claude Code does this every turn)
current_system = build_system_prompt(PROJECT_DIR)
memory = load_memory_index()
if memory:
current_system += f"\n\n# Memory\n{memory}"
# Run the agent loop
result = agent_loop(current_system, TOOLS, messages)
print(f"\n{result}\n")
if __name__ == "__main__":
main()
Bu size 300 satırdan az Python koduyla çalışan bir kodlama aracısı sağlar. Dosyaları okur, kodu düzenler, komutları çalıştırır, kod tabanlarını arar, bağlamı yönetir ve oturumlar arasında belleği kalıcı hale getirir.
Sıradaki eklenecekler
Sızdırılan kaynak, temel döngünüz çalışmaya başladığında oluşturulmaya değer birkaç özellik ortaya koyuyor:
Paralel çalışma için alt aracılar
Claude Code, bağımsız görevler için alt aracılar (''çatallanmış'' aracılar olarak adlandırılır) oluşturur. Alt aracı, ana bağlamın bir kopyasını alır, görevini yürütür ve bir sonuç döndürür. Bu, ana konuşmayı keşif amaçlı çalışmalarla kirletmekten kaçınır.
Desen: Odaklanmış bir görev açıklaması ve araçların bir alt kümesiyle yeni bir agent_loop() başlatın. Sonucu bir dize olarak döndürün.
Dosya okuma tekilleştirme
Claude Code, hangi dosyaların okunduğunu ve değişiklik zamanlarını takip eder. Bir dosya son okumadan bu yana değişmediyse, okumayı atlar ve modele "dosya son okumadan bu yana değişmedi" der. Bu, uzun oturumlar sırasında yeniden okumalarda token tasarrufu sağlar.
Çıktı kırpma ve örnekleme
Bir araç devasa bir çıktı döndürdüğünde (örneğin, 10.000'den fazla satır grep sonucu), Claude Code çıktıyı kırpar ve modele kaç sonucun atlandığını söyler. Bu olmadan, tek bir büyük araç sonucu tüm bağlam pencerenizi tüketebilir.
Dosya yeniden enjeksiyonu ile otomatik sıkıştırma
Sızdırılan sıkıştırıcı, dosya içeriklerini atmaz. Konuşmayı özetledikten sonra, yakın zamanda erişilen dosyaların içeriğini (dosya başına 5.000 tokene kadar) yeniden enjekte eder. Bu, modelin sıkıştırmadan sonra bile kod tabanı hakkında çalışan bilgiye sahip olduğu anlamına gelir.
Sızıntıdan öğrendiklerimiz
Claude Code sızıntısı, yapay zeka aracı topluluğunun teorize ettiği çeşitli desenleri doğruladı:
- Temel döngü basit. Tüm aracı deseni 30 satıra sığar. Karmaşıklık, istem mühendisliğinde değil, araçlarda ve bağlam yönetiminde yatar.
- Özel araçlar bash'ten daha iyi performans gösterir. Yapılandırılmış, amaca yönelik araçlar, bash komutlarını yönlendirmekten daha iyi token başına bilgi yoğunluğu sağlar.
- Belleğin katmanlara ihtiyacı var. Her zaman yüklü bir dizin, isteğe bağlı konu dosyaları ve yalnızca grep ile aranan transkriptler, bağlam maliyetlerine karşı geri çağırmayı dengeler.
- Bağlam yönetimi gerçek üründür. Otomatik sıkıştırma, proje yönergesi yeniden enjeksiyonu ve çıktı kırpma, uzun kodlama oturumlarını uygulanabilir kılan şeylerdir.
- Ürün model değil, koşum takımıdır. Model zeka sağlar. Koşum takımı algı (dosya okuma, kod arama), eylem (dosya yazma, komut yürütme) ve bellek sağlar. Bir kodlama aracısı inşa etmek, koşum takımını inşa etmektir.
Çok turlu araç kullanım konuşmaları, karmaşık istek şemaları ve yanıt doğrulama dahil olmak üzere özel aracınızın API etkileşimlerini test etmek ve hata ayıklamak isterseniz, Apidog'u ücretsiz deneyin. API hata ayıklamasını o halleder, böylece aracı mantığına odaklanabilirsiniz.
Sıkça Sorulan Sorular
Claude Code sızıntısındaki desenleri yasal olarak kullanabilir miyim?
Sızıntı, tescilli algoritmaları değil, mimari desenleri ortaya çıkardı. Araç dağıtımına sahip bir while döngüsü kullanan bir kodlama aracısı oluşturmak, Anthropic'in kendi API belgelerinde belgelenmiş standart bir desendir. Anthropic'in kodunu kelimesi kelimesine kopyalamamalısınız, ancak mimariyi kendi kodunuzla yeniden oluşturmak standart bir uygulamadır.
Kendin yap bir kodlama aracısı için hangi modeli kullanmalıyım?
Claude Sonnet 4.6, kodlama görevleri için doğru hız ve yetenek dengesini sunar. Claude Opus 4.6, karmaşık mimari kararlarında daha iyi sonuçlar verir ancak daha maliyetli ve daha yavaştır. Basit dosya düzenlemeleri ve aramaları için Claude Haiku 4.5 iş görür ve %90 daha az maliyetlidir.
Kendi kodlama aracınızı çalıştırmak ne kadara mal olur?
Claude Sonnet 4.6 ile tipik bir kodlama oturumu (30-50 tur), API ücretleri olarak 1-5 dolara mal olur. Ana maliyet sürücüsü bağlam penceresi boyutudur; agresif sıkıştırma maliyetleri düşük tutar. Claude Code'un sızdırılan kaynağı, bunu kontrol etmek için %92 bağlam kullanımıyla sıkıştırmayı tetiklediğini gösteriyor.
Claude Code neden terminal uygulaması için React kullanıyor?
Ink (terminaller için React), ekibin izin iletişim kutuları, akışlı çıktı ve araç çağrısı gösterimleri gibi karmaşık kullanıcı arayüzü etkileşimleri için React'in bileşen modelini ve durum yönetimini yeniden kullanmasına olanak tanır. Kendin yap bir proje için basit bir input() / print() REPL yeterlidir.
Temel döngüden sonra inşa edilecek en önemli özellik nedir?
İzin sistemi. Bu olmadan, model dosyaların üzerine yazabilir ve kullanıcı denetimi olmadan rastgele komutlar çalıştırabilir. Basit bir "yazma/yürütme öncesi onayla" kapısı bile çoğu kazara zararı önler.
Claude Code, araç çağrılarından kaynaklanan hataları nasıl ele alıyor?
Araç hataları, tool_result mesajında metin içeriği olarak döndürülür. Model hatayı görür ve yeniden denemeye, farklı bir yaklaşım denemeye veya kullanıcıya sormaya karar verir. Özel bir hata işleme yoktur; modelin muhakemesi kurtarmayı yönetir.
Bunu Claude dışındaki modellerle kullanabilir miyim?
Evet. Araç kullanım deseni, işlev çağrısını destekleyen herhangi bir modelle çalışır: GPT-4, Gemini, Llama ve diğerleri. API çağrı formatını uyarlamanız gerekecek, ancak aracı döngüsü, araçlar ve bellek sistemi modelden bağımsızdır.
Aracının tehlikeli komutları çalıştırmasını nasıl engellerim?
Tehlikeli desenlerin (rm -rf /, mkfs vb.) bir engelleme listesiyle başlayın ve tüm run_command çağrıları için açık onay isteyin. Claude Code, her işlemi DÜŞÜK, ORTA veya YÜKSEK risk olarak sınıflandırır ve bu sınıflandırmaya göre engeller veya ister. Kendi araçlarınız için de aynısını oluşturun.