موجز سريع
كشف تسريب شيفرة مصدر Claude Code عن قاعدة شيفرة TypeScript بحجم 512,000 سطر في 31 مارس 2026. تعتمد البنية الأساسية على حلقة تكرارية (while-loop) تستدعي واجهة برمجة تطبيقات Claude، وترسل استدعاءات الأدوات، وتعيد النتائج. يمكنك بناء نسختك الخاصة باستخدام بايثون، و SDK الخاص بـ Anthropic، وحوالي 200 سطر من التعليمات البرمجية للحلقة الأساسية. يشرح هذا الدليل كل مكون ويوضح لك كيفية إعادة إنشائها.
مقدمة
في 31 مارس 2026، أصدرت Anthropic ملف خريطة مصدر بحجم 59.8 ميجابايت ضمن الإصدار 2.1.88 من حزمة npm الخاصة بها @anthropic-ai/claude-code. خرائط المصدر هي أدوات تصحيح أخطاء تعكس ملفات JavaScript المصغرة إلى الشيفرة المصدر الأصلية. نظرًا لأن أداة البناء الخاصة بـ Anthropic (مجمّع Bun) تولّد هذه الملفات افتراضيًا، فقد كان من الممكن استرداد قاعدة شيفرة TypeScript بالكامل.
في غضون ساعات، قام المطورون بنسخ الشيفرة عبر العشرات من مستودعات GitHub. حلل المجتمع بسرعة كل وحدة، من حلقة الوكيل الرئيسية إلى الميزات المخفية مثل "وضع التخفي" وحقن الأدوات المزيفة.
كان رد الفعل منقسمًا. انتقد البعض ممارسات Anthropic الأمنية. بينما انبهر آخرون بالهندسة المعمارية. لكن الاستجابة الأكثر إنتاجية جاءت من المطورين الذين تساءلوا: "هل يمكنني بناء هذا بنفسي؟"
الجواب نعم. الأنماط الأساسية واضحة ومباشرة. يرشدك هذا الدليل عبر كل طبقة معمارية، ويوضح سبب اتخاذ Anthropic لهذه الخيارات، ويوفر شيفرة عمل يمكنك استخدامها كنقطة بداية. ستتعلم أيضًا كيفية اختبار تفاعلات واجهة برمجة التطبيقات لوكيلك المخصص باستخدام Apidog، مما يجعل تصحيح أخطاء محادثات واجهة برمجة التطبيقات متعددة الأدوار أسهل بكثير من أوامر curl الخام.
ما كشفه التسريب عن بنية Claude Code
نظرة سريعة على قاعدة الشيفرة
Claude Code، الذي يحمل الاسم الرمزي الداخلي "Tengu"، يمتد على حوالي 1900 ملف. تنظيم الوحدات ينقسم إلى طبقات واضحة:
cli/ - واجهة المستخدم الطرفية (React + Ink)
tools/ - 40+ تنفيذ أداة
core/ - موجهات النظام، الأذونات، الثوابت
assistant/ - تنسيق الوكيل
services/ - استدعاءات API، الضغط، OAuth، القياس عن بعد
واجهة سطر الأوامر (CLI) بحد ذاتها هي تطبيق React يتم عرضه عبر Ink، وهو عارض React لمخرجات الطرفية. يستخدم Yoga (محرك CSS flexbox) للتخطيط وأكواد هروب ANSI للتصميم. كل عرض محادثة، ومنطقة إدخال، وعرض استدعاء أداة، ومربع حوار إذن هو مكون React.
هذا مبالغ فيه في التصميم لمعظم مشاريع DIY (افعلها بنفسك). لست بحاجة إلى واجهة مستخدم طرفية قائمة على React لبناء وكيل برمجة عامل. حلقة REPL بسيطة تعمل بشكل جيد.
حلقة الوكيل الرئيسية
إذا أزلت واجهة المستخدم، والقياس عن بعد، ومؤشرات الميزات، فإن جوهر Claude Code هو حلقة تكرارية (while-loop). تطلق عليها Anthropic داخليًا اسم "nO". إليك ما تفعله:
- إرسال الرسائل إلى Claude API (موجه النظام + تعريفات الأدوات)
- استقبال استجابة تحتوي على نص و/أو كتل
tool_use - تنفيذ كل أداة مطلوبة عبر خريطة توزيع من الاسم إلى المعالج
- إضافة نتائج الأداة مرة أخرى إلى قائمة الرسائل
- إذا كانت الاستجابة تحتوي على المزيد من استدعاءات الأدوات، العودة إلى الخطوة 1
- إذا كانت الاستجابة نصًا عاديًا بدون استدعاءات أدوات، إرجاعها إلى المستخدم
الـ "دورة" هي رحلة ذهاب وإياب كاملة واحدة. تستمر الدورات حتى ينتج Claude نصًا بدون استدعاءات أدوات. هذا هو نمط الوكيل بالكامل.
إليك نسخة بايثون مصغرة تجسد الجوهر:
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})
هذا حوالي 30 سطرًا. تأتي بقية تعقيدات Claude Code من الأدوات نفسها، ونظام الأذونات، وإدارة السياق، والذاكرة.
بناء نظام الأدوات
لماذا تتفوق الأدوات المخصصة على أمر Bash واحد
أحد أوضح القرارات المعمارية في التسريب: يستخدم Claude Code أدوات مخصصة لعمليات الملفات بدلاً من توجيه كل شيء عبر Bash.
هناك أداة Read (وليست cat)، وأداة Edit (وليست sed)، وأداة Grep (وليست grep)، وأداة Glob (وليست find). يخبر موجه النظام النموذج صراحةً بتفضيل هذه الأدوات على مكافئات Bash.
لماذا؟ لثلاثة أسباب:
- مخرجات منظمة. أداة
Grepالمخصصة تعيد النتائج بتنسيق متسق يمكن للنموذج تحليله. بينما تنتج أوامر Bash الموجهة مخرجات غير متوقعة يواجه النموذج صعوبة في تفسيرها. - الأمان. تحظر
BashToolفي Claude Code علامات الاقتباس العكسية ورموز$()الفرعية لغلاف الأوامر (subshell) لمنع الحقن. تتجنب الأدوات المخصصة هذا الخطر تمامًا. - كفاءة الرموز المميزة. يمكن اقتطاع نتائج الأداة، أو أخذ عينات منها، أو تفريغها على القرص. مخرجات
catالكبيرة تهدر رموز نافذة السياق.
مجموعة الأدوات الأساسية
من التسريب، يعرض Claude Code أقل من 20 أداة افتراضيًا، مع أكثر من 60 أداة خلف مؤشرات الميزات. لوكيل DIY، تحتاج إلى خمسة:
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"]
}
}
]
توزيع معالج الأدوات
تقوم دالة تنفيذ الأداة بربط أسماء الأدوات بدوال المعالجة:
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
إدارة السياق: المشكلة الصعبة
لماذا يُعد السياق أهم من هندسة الموجهات
تكشف الشيفرة المصدرية المسربة أن Claude Code يبذل جهدًا هندسيًا أكبر في إدارة السياق منه في موجه النظام نفسه. ضاغط السياق (الذي يُطلق عليه داخليًا "wU2") لديه خمس استراتيجيات.
لبناء DIY، تحتاج إلى اثنين:
الضغط التلقائي يحدث عندما تقترب المحادثة من حد نافذة السياق. ينشط Claude Code عند استخدام حوالي 92%، مع الاحتفاظ بمخزن مؤقت بحجم 13,000 رمز للملخص نفسه.
إعادة حقن CLAUDE.md يضمن عدم انحراف إرشادات المشروع خلال الجلسات الطويلة. يعيد Claude Code حقن تهيئة المشروع في كل دورة، وليس عند التهيئة الأولية. هذا هو النمط الأكثر تأثيرًا للحفاظ على وكيل البرمجة على المسار الصحيح.
بناء ضاغط بسيط
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
إعادة حقن سياق المشروع
يقرأ Claude Code ملف .claude/CLAUDE.md ويحقنه في كل دورة. إليك كيفية تكرار ذلك:
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
أضف أداة save_memory إلى قائمة أدواتك حتى يتمكن الوكيل من الاحتفاظ بالمعرفة بين الجلسات.
نظام الذاكرة ثلاثي الطبقات
تُظهر الشيفرة المصدرية المسربة أن Claude Code يستخدم بنية ذاكرة ثلاثية الطبقات. هذا أحد الأجزاء الأكثر تجاهلاً في النظام.
الطبقة 1: MEMORY.md (محملة دائمًا)
فهرس خفيف الوزن يبقى في موجه النظام طوال الوقت. كل إدخال هو سطر واحد، أقل من 150 حرفًا. يعمل كجدول محتويات يشير إلى معرفة أعمق. محدد بـ 200 سطر / 25 كيلوبايت.
- [تفضيلات المستخدم](memory/user-prefs.md) - يفضل TypeScript، ويستخدم ربط مفاتيح Vim
- [اتفاقيات API](memory/api-conventions.md) - REST مع مواصفات JSON:API، snake_case
- [عملية النشر](memory/deploy.md) - تستخدم GitHub Actions، وتنشر على AWS EKS
الطبقة 2: ملفات المواضيع (تُحمل عند الطلب)
ملفات معرفة مفصلة تُحمّل عندما يشير الفهرس إلى الصلة. تحتوي هذه الملفات على اتفاقيات المشروع، والقرارات المعمارية، والأنماط المستفادة.
الطبقة 3: سجلات الجلسات (يتم البحث فيها، لا تُقرأ أبدًا)
سجلات الجلسات الكاملة التي لا تُحمّل بالكامل أبدًا. يقوم الوكيل بالبحث فيها عن معرفات محددة (greps for them). يمنع هذا تضخم السياق مع الحفاظ على قابلية البحث.
بناء نظام ذاكرة بسيط
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)
أضف أداة save_memory إلى قائمة أدواتك حتى يتمكن الوكيل من الاحتفاظ بالمعرفة بين الجلسات.
إضافة نظام أذونات
يكشف التسريب عن خمسة أوضاع للأذونات: default (مطالبات تفاعلية)، auto (موافقة قائمة على التعلم الآلي)، bypass (تجاوز)، yolo (الموافقة على كل شيء)، وdeny (الرفض). يتم تصنيف كل إجراء أداة على أنه خطر منخفض، متوسط، أو مرتفع.
لوكيل DIY، يعمل نظام بسيط ثلاثي المستويات:
# 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"
اختبار استدعاءات API لوكيلك باستخدام Apidog
بناء وكيل برمجة يعني إجراء مئات استدعاءات API إلى Claude. تصحيح أخطاء هذه التفاعلات، خاصة المحادثات متعددة الأدوار مع استخدام الأدوات، أمر مؤلم باستخدام السجلات الخام.
يساعدك Apidog في فحص واختبار طلبات API الدقيقة التي يرسلها وكيلك. إليك كيفية استخدامه أثناء التطوير:
التقاط وإعادة تشغيل طلبات API
قم بإعداد Apidog كوكيل لاعتراض استدعاءات وكيلك إلى Anthropic API:
- افتح Apidog وأنشئ مشروعًا جديدًا لوكيلك
- استورد نقطة نهاية Anthropic Messages API:
POST https://api.anthropic.com/v1/messages - قم بإعداد نص الطلب مع موجه النظام الخاص بك، ومصفوفة الأدوات، والرسائل
- اختبر الدورات الفردية عن طريق إعادة تشغيل الطلبات الملتقطة بمعاملات معدلة
يتيح لك هذا عزل دورات استخدام أداة محددة دون تشغيل حلقة الوكيل الكاملة. عندما يعيد النموذج استدعاء أداة غير متوقع أو معلمة خاطئة (hallucinated parameter)، يمكنك تعديل نص الطلب في المحرر المرئي لـ Apidog وإعادة إرساله لمعرفة كيف تغير المدخلات المختلفة الاستجابة.
تصحيح أخطاء المحادثات متعددة الأدوار
الجزء الأصعب في تصحيح أخطاء الوكيل هو إعادة إنتاج حالة المحادثة. تتيح لك متغيرات البيئة في Apidog حفظ لقطات المحادثة:
- احفظ مصفوفة
messagesالكاملة كمتغير بيئة بعد كل دورة - أعد التشغيل من أي نقطة في المحادثة
- قارن نتائج الأدوات بين عمليات التشغيل للعثور على نقاط اختلاف السلوك
التحقق من صحة مخططات الأدوات
تحدد تعريفات أدواتك (مخططات JSON التي تمررها إلى API) ما يمكن للنموذج طلبه. تتسبب المخططات الخاطئة في فشل صامت حيث يتخطى النموذج أداة أو يمرر معاملات خاطئة.
استورد مخططات أدواتك إلى Apidog واستخدم مدقق JSON Schema الخاص به لاكتشاف المشكلات قبل وصولها إلى API. قم بتنزيل Apidog لبدء تصحيح أخطاء تفاعلات API لوكيلك.
تجميع الكل: REPL الكامل
إليك الوكيل الكامل المجمع كـ REPL عامل:
#!/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()
يوفر لك هذا وكيل برمجة عامل بأقل من 300 سطر من بايثون. يقرأ الملفات، ويعدل الشيفرة، وينفذ الأوامر، ويبحث في قواعد الشيفرة، ويدير السياق، ويحتفظ بالذاكرة بين الجلسات.
ماذا تضيف لاحقًا
تكشف الشيفرة المصدرية المسربة عن العديد من الميزات التي تستحق البناء بمجرد أن تعمل حلقتك الأساسية:
الوكلاء الفرعيون للعمل المتوازي
يستدعي Claude Code وكلاء فرعيين (يُطلق عليهم وكلاء "متفرعين") للمهام المستقلة. يحصل الوكيل الفرعي على نسخة من سياق الأصل، وينفذ مهمته، ويعيد نتيجة. يتجنب هذا تلويث المحادثة الرئيسية بالعمل الاستكشافي.
النمط: استدعاء agent_loop() جديد بوصف مهمة مركز ومجموعة فرعية من الأدوات. إرجاع النتيجة كسلسلة نصية.
إلغاء تكرار قراءة الملفات
يتتبع Claude Code الملفات التي تم قراءتها وأوقات تعديلها. إذا لم يتغير ملف منذ آخر قراءة، فإنه يتخطى القراءة ويخبر النموذج "الملف لم يتغير منذ آخر قراءة." يوفر هذا الرموز المميزة عند إعادة القراءة خلال الجلسات الطويلة.
اقتطاع وأخذ عينات من المخرجات
عندما تعيد أداة مخرجات ضخمة (أكثر من 10,000 سطر من نتائج grep، على سبيل المثال)، يقتطعها Claude Code ويخبر النموذج بعدد النتائج التي تم حذفها. بدون هذا، يمكن لنتيجة أداة واحدة كبيرة أن تستهلك نافذة السياق بأكملها.
الضغط التلقائي مع إعادة حقن الملفات
ضاغط التسريب لا يتجاهل محتويات الملفات. بعد تلخيص المحادثة، يعيد حقن محتويات الملفات التي تم الوصول إليها مؤخرًا (حتى 5,000 رمز لكل ملف).
هذا يعني أن النموذج يحتفظ بمعرفة عملية بقاعدة الشيفرة حتى بعد الضغط.
ما تعلمناه من التسريب
أكد تسريب شيفرة Claude Code العديد من الأنماط التي افترضها مجتمع وكلاء الذكاء الاصطناعي:
- الحلقة الأساسية بسيطة. يتسع نمط الوكيل بأكمله في 30 سطرًا. تكمن التعقيدات في الأدوات وإدارة السياق، وليس في هندسة الموجهات.
- الأدوات المخصصة تتفوق على Bash. الأدوات المنظمة والمبنية لغرض محدد تمنح النموذج كثافة معلومات أفضل لكل رمز مميز مقارنة بتوجيه أوامر Bash.
- الذاكرة تحتاج إلى طبقات. فهرس محمل دائمًا، وملفات مواضيع عند الطلب، وسجلات يتم البحث فيها فقط (grep-only transcripts) توازن بين الاستدعاء وتكاليف السياق.
- إدارة السياق هي المنتج الحقيقي. الضغط التلقائي، وإعادة حقن إرشادات المشروع، واقتطاع المخرجات هي ما يجعل جلسات البرمجة الطويلة ممكنة.
- السرج (Harness) هو المنتج، وليس النموذج. يوفر النموذج الذكاء. ويوفر السرج الإدراك (قراءة الملفات، البحث في الشيفرة)، والعمل (كتابة الملفات، تنفيذ الأوامر)، والذاكرة. بناء وكيل برمجة هو بناء السرج.
إذا كنت ترغب في اختبار وتصحيح أخطاء تفاعلات واجهة برمجة تطبيقات وكيلك المخصص، بما في ذلك المحادثات متعددة الأدوار باستخدام الأدوات، ومخططات الطلبات المعقدة، والتحقق من صحة الاستجابات، جرب Apidog مجانًا. فهو يتعامل مع تصحيح أخطاء API حتى تتمكن من التركيز على منطق الوكيل.
الأسئلة الشائعة
هل يمكنني استخدام أنماط من تسريب شيفرة Claude Code بشكل قانوني؟
كشف التسريب عن أنماط معمارية، وليس خوارزميات خاصة. بناء وكيل برمجة يستخدم حلقة تكرارية (while-loop) مع توزيع الأدوات هو نمط قياسي موثق في وثائق API الخاصة بـ Anthropic. لا يجب عليك نسخ شيفرة Anthropic حرفيًا، ولكن إعادة إنشاء البنية باستخدام شيفرتك الخاصة هي ممارسة قياسية.
ما النموذج الذي يجب أن أستخدمه لوكيل برمجة DIY؟
يقدم Claude Sonnet 4.6 التوازن الصحيح بين السرعة والقدرة لمهام البرمجة. ينتج Claude Opus 4.6 نتائج أفضل في قرارات البنية المعقدة ولكنه يكلف أكثر ويعمل ببطء أكبر. للتعديلات البسيطة على الملفات وعمليات البحث، يعمل Claude Haiku 4.5 ويكلف 90% أقل.
كم تكلفة تشغيل وكيل البرمجة الخاص بك؟
تكلف جلسة برمجة نموذجية (30-50 دورة) مع Claude Sonnet 4.6 ما بين 1-5 دولارات كرسوم API. المحرك الرئيسي للتكلفة هو حجم نافذة السياق؛ الضغط القوي يحافظ على التكاليف منخفضة. تُظهر الشيفرة المصدرية المسربة لـ Claude Code أنها تُنشط الضغط عند استخدام 92% من السياق للتحكم في ذلك.
لماذا يستخدم Claude Code React لتطبيق طرفي؟
يتيح Ink (React للطرفيات) للفريق إعادة استخدام نموذج مكونات React وإدارة حالتها لتفاعلات واجهة المستخدم المعقدة مثل مربعات حوار الأذونات، ومخرجات البث، وعروض استدعاء الأدوات. لمشروع DIY، يكفي input() / print() REPL بسيط.
ما هي أهم ميزة يجب بناؤها بعد الحلقة الأساسية؟
نظام الأذونات. بدونه، يمكن للنموذج الكتابة فوق الملفات وتشغيل أوامر عشوائية دون رقابة المستخدم. حتى بوابة بسيطة "تأكيد قبل الكتابة/التنفيذ" تمنع معظم الأضرار العرضية.
كيف يتعامل Claude Code مع الأخطاء من استدعاءات الأدوات؟
تُعاد أخطاء الأدوات كمحتوى نصي في رسالة tool_result. يرى النموذج الخطأ ويقرر ما إذا كان سيعيد المحاولة، أو يجرب نهجًا مختلفًا، أو يسأل المستخدم. لا يوجد معالجة أخطاء خاصة؛ يستجيب النموذج بالمنطق الخاص به لاستعادة النظام.
هل يمكنني استخدام هذا مع نماذج أخرى غير Claude؟
نعم. يعمل نمط استخدام الأدوات مع أي نموذج يدعم استدعاء الوظائف: GPT-4، Gemini، Llama، وغيرها. ستحتاج إلى تكييف تنسيق استدعاء API، لكن حلقة الوكيل، والأدوات، ونظام الذاكرة مستقلة عن النموذج.
كيف أمنع الوكيل من تشغيل أوامر خطيرة؟
ابدأ بقائمة حظر للأنماط الخطيرة (rm -rf /، mkfs، إلخ) واطلب موافقة صريحة لجميع استدعاءات run_command. يصنف Claude Code كل عملية على أنها خطر منخفض، متوسط، أو مرتفع ويحظر أو يطالب بالموافقة بناءً على التصنيف. قم ببناء نفس الشيء لأدواتك.