Intisari
Kebocoran kode sumber Claude Kode mengekspos basis kode TypeScript 512.000 baris pada 31 Maret 2026. Arsitekturnya bermuara pada perulangan while yang memanggil API Claude, mengirimkan panggilan alat, dan mengumpankan kembali hasilnya. Anda dapat membangun versi Anda sendiri dengan Python, Anthropic SDK, dan sekitar 200 baris kode untuk perulangan inti. Panduan ini menguraikan setiap komponen dan menunjukkan cara membuatnya kembali.
Pendahuluan
Pada 31 Maret 2026, Anthropic mengirimkan file peta sumber berukuran 59,8 MB di dalam versi 2.1.88 dari paket npm @anthropic-ai/claude-code mereka. Peta sumber adalah artefak debugging yang mengembalikan JavaScript yang diminifikasi ke kode sumber aslinya. Karena alat bangun Anthropic (Bun's bundler) menghasilkan ini secara default, seluruh basis kode TypeScript dapat dipulihkan.
Dalam hitungan jam, pengembang telah mencerminkan kode tersebut di lusinan repositori GitHub. Komunitas dengan cepat menganalisis setiap modul, mulai dari perulangan agen master hingga fitur tersembunyi seperti “mode penyamaran” dan injeksi alat palsu.
Reaksinya terpecah. Beberapa mengkritik praktik keamanan Anthropic. Yang lain terpesona oleh arsitekturnya. Tetapi respons paling produktif datang dari pengembang yang bertanya: “Bisakah saya membangun ini sendiri?”
Jawabannya ya. Pola intinya lugas. Panduan ini membahas setiap lapisan arsitektur, menjelaskan mengapa Anthropic membuat pilihan tersebut, dan menyediakan kode kerja yang dapat Anda gunakan sebagai titik awal. Anda juga akan belajar cara menguji interaksi API agen kustom Anda dengan Apidog, yang membuat debugging percakapan API multi-giliran jauh lebih mudah daripada perintah curl mentah.
Apa yang diungkapkan kebocoran tentang arsitektur Kode Claude
Basis kode sekilas
Claude Kode, dengan nama kode internal “Tengu,” mencakup sekitar 1.900 file. Organisasi modul terbagi menjadi lapisan-lapisan yang jelas:
cli/ - UI Terminal (React + Ink)
tools/ - 40+ implementasi alat
core/ - Prompt sistem, izin, konstanta
assistant/ - Orquestrasi agen
services/ - Panggilan API, kompresi, OAuth, telemetri
CLI itu sendiri adalah aplikasi React yang dirender melalui Ink, sebuah renderer React untuk output terminal. Ia menggunakan Yoga (mesin flexbox CSS) untuk tata letak dan kode escape ANSI untuk penataan. Setiap tampilan percakapan, area input, tampilan panggilan alat, dan dialog izin adalah komponen React.
Ini terlalu rumit untuk sebagian besar proyek DIY. Anda tidak memerlukan UI terminal berbasis React untuk membangun agen pengodean yang berfungsi. Perulangan REPL sederhana berfungsi dengan baik.
Perulangan agen master
Singkirkan UI, telemetri, dan tanda fitur, dan inti Kode Claude adalah perulangan while. Anthropic secara internal menyebutnya “nO.” Inilah yang dilakukannya:
- Kirim pesan ke API Claude (prompt sistem + definisi alat)
- Terima respons yang berisi teks dan/atau blok
tool_use - Jalankan setiap alat yang diminta melalui peta pengiriman nama-ke-handler
- Tambahkan hasil alat kembali ke daftar pesan
- Jika respons berisi lebih banyak panggilan alat, kembali ke langkah 1
- Jika respons adalah teks biasa tanpa panggilan alat, kembalikan ke pengguna
Sebuah “giliran” adalah satu perjalanan pulang-pergi yang lengkap. Giliran berlanjut sampai Claude menghasilkan teks tanpa pemanggilan alat. Itulah seluruh pola agen.
Berikut adalah versi Python minimal yang menangkap intinya:
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})
Itu sekitar 30 baris. Sisa kompleksitas Kode Claude berasal dari alat itu sendiri, sistem izin, manajemen konteks, dan memori.
Membangun sistem alat
Mengapa alat khusus mengalahkan satu perintah bash
Salah satu keputusan arsitektur paling jelas dalam kebocoran: Claude Kode menggunakan alat khusus untuk operasi file alih-alih mengarahkan semuanya melalui bash.
Ada alat Read (bukan cat), alat Edit (bukan sed), alat Grep (bukan grep), dan alat Glob (bukan find). Prompt sistem secara eksplisit memberi tahu model untuk lebih memilih ini daripada ekuivalen bash.
Mengapa? Tiga alasan:
- Output terstruktur. Alat
Grepkhusus mengembalikan hasil dalam format yang konsisten yang dapat diurai oleh model. Pemipaan perintah bash menghasilkan output yang tidak dapat diprediksi yang sulit diinterpretasikan oleh model. - Keamanan.
BashTooldalam Kode Claude memblokir backtick dan sintaks subshell$()untuk mencegah injeksi. Alat khusus sepenuhnya menghindari risiko ini. - Efisiensi token. Hasil alat dapat dipotong, disampel, atau dipindahkan ke disk. Output
catyang besar membuang token jendela konteks.
Kumpulan alat penting
Dari kebocoran, Kode Claude mengekspos kurang dari 20 alat secara default, dengan lebih dari 60 di balik tanda fitur. Untuk agen DIY, Anda memerlukan lima:
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"]
}
}
]
Pengiriman penangan alat
Fungsi eksekusi alat memetakan nama alat ke fungsi penangan:
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
Manajemen konteks: masalah yang sulit
Mengapa konteks lebih penting daripada rekayasa prompt
Sumber yang bocor mengungkapkan bahwa Kode Claude menghabiskan lebih banyak upaya rekayasa pada manajemen konteks daripada pada prompt sistem itu sendiri. Kompresor konteks (secara internal disebut “wU2”) memiliki lima strategi.
Untuk pembuatan DIY, Anda memerlukan dua:
Kompresi otomatis terpicu ketika percakapan mendekati batas jendela konteks. Kode Claude terpicu pada sekitar 92% penggunaan, mencadangkan buffer 13.000 token untuk ringkasan itu sendiri.
Injeksi ulang CLAUDE.md memastikan pedoman proyek tidak menyimpang selama sesi panjang. Kode Claude menginjeksikan ulang konfigurasi proyek pada setiap giliran, bukan saat inisialisasi. Ini adalah pola paling berdampak untuk menjaga agen pengodean tetap pada jalurnya.
Membangun kompresor sederhana
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
Menginjeksikan ulang konteks proyek
Kode Claude membaca .claude/CLAUDE.md dan menginjeksikannya ke setiap giliran. Berikut cara mereplikasinya:
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
Sistem memori tiga lapis
Sumber yang bocor menunjukkan bahwa Kode Claude menggunakan arsitektur memori tiga tingkat. Ini adalah salah satu bagian sistem yang paling kurang dihargai.
Lapisan 1: MEMORY.md (selalu dimuat)
Indeks ringan yang selalu ada dalam prompt sistem. Setiap entri adalah satu baris, di bawah 150 karakter. Berfungsi sebagai daftar isi yang menunjuk ke pengetahuan yang lebih dalam. Dibatasi hingga 200 baris / 25KB.
- [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
Lapisan 2: file topik (dimuat sesuai permintaan)
File pengetahuan rinci dimuat ketika indeks menunjukkan relevansi. Ini berisi konvensi proyek, keputusan arsitektur, dan pola yang dipelajari.
Lapisan 3: transkrip sesi (dicari, tidak pernah dibaca)
Log sesi lengkap yang tidak pernah dimuat secara keseluruhan. Agen mencari mereka untuk pengidentifikasi tertentu. Ini mencegah pembengkakan konteks sambil mempertahankan kemampuan pencarian.
Membangun sistem memori minimal
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)
Tambahkan alat save_memory ke daftar alat Anda agar agen dapat mempertahankan pengetahuan antar sesi.
Menambahkan sistem izin
Kebocoran mengungkapkan lima mode izin: default (prompt interaktif), auto (persetujuan berbasis ML), bypass, yolo (menyetujui semuanya), dan deny. Setiap tindakan alat diklasifikasikan sebagai risiko RENDAH, SEDANG, atau TINGGI.
Untuk agen DIY, sistem tiga tingkat sederhana berfungsi:
# 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"
Menguji panggilan API agen Anda dengan Apidog
Membangun agen pengodean berarti melakukan ratusan panggilan API ke Claude. Debugging interaksi ini, terutama percakapan multi-giliran dengan penggunaan alat, sangat menyakitkan dengan log mentah.
Apidog membantu Anda memeriksa dan menguji permintaan API persis yang dikirim agen Anda. Berikut cara menggunakannya selama pengembangan:
Menangkap dan memutar ulang permintaan API
Siapkan Apidog sebagai proxy untuk mencegat panggilan agen Anda ke Anthropic API:
- Buka Apidog dan buat proyek baru untuk agen Anda
- Impor titik akhir API Pesan Anthropic:
POST https://api.anthropic.com/v1/messages - Siapkan isi permintaan dengan prompt sistem, array alat, dan pesan Anda
- Uji giliran individual dengan memutar ulang permintaan yang ditangkap dengan parameter yang dimodifikasi
Ini memungkinkan Anda mengisolasi giliran penggunaan alat tertentu tanpa menjalankan seluruh perulangan agen. Ketika model mengembalikan panggilan alat yang tidak terduga atau parameter yang dihalusinasi, Anda dapat memodifikasi isi permintaan di editor visual Apidog dan mengirimnya ulang untuk melihat bagaimana input yang berbeda mengubah respons.
Mendebug percakapan multi-giliran
Bagian tersulit dari debugging agen adalah mereproduksi status percakapan. Variabel lingkungan Apidog memungkinkan Anda menyimpan snapshot percakapan:
- Simpan array
messageslengkap sebagai variabel lingkungan setelah setiap giliran - Putar ulang dari titik mana pun dalam percakapan
- Bandingkan hasil alat antar eksekusi untuk menemukan di mana perilaku menyimpang
Memvalidasi skema alat
Definisi alat Anda (skema JSON yang Anda berikan ke API) menentukan apa yang dapat diminta oleh model. Skema yang salah bentuk menyebabkan kegagalan diam-diam di mana model melewati alat atau meneruskan parameter yang salah.
Impor skema alat Anda ke Apidog dan gunakan validator Skema JSON-nya untuk menangkap masalah sebelum mencapai API. Unduh Apidog untuk mulai mendebug interaksi API agen Anda.
Menyatukan semuanya: REPL lengkap
Berikut adalah agen lengkap yang disatukan sebagai REPL yang berfungsi:
#!/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()
Ini memberi Anda agen pengodean yang berfungsi dalam waktu kurang dari 300 baris Python. Ia membaca file, mengedit kode, menjalankan perintah, mencari basis kode, mengelola konteks, dan mempertahankan memori antar sesi.
Apa yang harus ditambahkan selanjutnya
Sumber yang bocor mengungkapkan beberapa fitur yang layak dibangun setelah perulangan inti Anda berfungsi:
Sub-agen untuk pekerjaan paralel
Kode Claude memunculkan sub-agen (disebut agen “cabang”) untuk tugas-tugas independen. Sub-agen mendapatkan salinan konteks induk, menjalankan tugasnya, dan mengembalikan hasilnya. Ini menghindari pencemaran percakapan utama dengan pekerjaan eksplorasi.
Polanya: munculkan agent_loop() baru dengan deskripsi tugas terfokus dan subset alat. Kembalikan hasilnya sebagai string.
Deduplikasi pembacaan file
Kode Claude melacak file mana yang dibaca dan waktu modifikasinya. Jika file tidak berubah sejak pembacaan terakhir, ia melewati pembacaan dan memberi tahu model “file tidak berubah sejak pembacaan terakhir.” Ini menghemat token pada pembacaan ulang selama sesi panjang.
Pemotongan dan pengambilan sampel output
Ketika alat mengembalikan output yang masif (misalnya, 10.000+ baris hasil grep), Kode Claude memotongnya dan memberi tahu model berapa banyak hasil yang dihilangkan. Tanpa ini, satu hasil alat yang besar dapat menghabiskan seluruh jendela konteks Anda.
Kompresi otomatis dengan injeksi ulang file
Kompresor yang bocor tidak membuang isi file. Setelah meringkas percakapan, ia menginjeksikan ulang isi file yang baru diakses (hingga 5.000 token per file). Ini berarti model menyimpan pengetahuan kerja basis kode bahkan setelah kompresi.
Apa yang kami pelajari dari kebocoran
Kebocoran Kode Claude mengkonfirmasi beberapa pola yang telah diteorikan oleh komunitas agen AI:
Perulangan intinya sederhana. Seluruh pola agen muat dalam 30 baris. Kompleksitas terletak pada alat dan manajemen konteks, bukan pada rekayasa prompt.
Alat khusus mengungguli bash. Alat yang terstruktur dan dibuat khusus memberikan model kepadatan informasi per token yang lebih baik daripada memipakan perintah bash.
Memori membutuhkan lapisan. Indeks yang selalu dimuat, file topik sesuai permintaan, dan transkrip hanya-grep menyeimbangkan penarikan kembali dengan biaya konteks.
Manajemen konteks adalah produk yang sebenarnya. Kompresi otomatis, injeksi ulang pedoman proyek, dan pemotongan output adalah yang membuat sesi pengodean yang panjang menjadi layak.
Harness adalah produknya, bukan modelnya. Model menyediakan intelijen. Harness menyediakan persepsi (pembacaan file, pencarian kode), tindakan (penulisan file, eksekusi perintah), dan memori. Membangun agen pengodean berarti membangun harness.
Jika Anda ingin menguji dan mendebug interaksi API agen kustom Anda, termasuk percakapan penggunaan alat multi-giliran, skema permintaan kompleks, dan validasi respons, coba Apidog secara gratis. Ini menangani debugging API sehingga Anda dapat fokus pada logika agen.
FAQ
Bisakah saya secara legal menggunakan pola dari kebocoran Kode Claude?
Kebocoran tersebut mengekspos pola arsitektur, bukan algoritma kepemilikan. Membangun agen pengodean yang menggunakan perulangan while dengan pengiriman alat adalah pola standar yang didokumentasikan dalam dokumen API Anthropic sendiri. Anda tidak boleh menyalin kode Anthropic secara verbatim, tetapi membuat ulang arsitektur dengan kode Anda sendiri adalah praktik standar.
Model apa yang harus saya gunakan untuk agen pengodean DIY?
Claude Sonnet 4.6 menawarkan keseimbangan kecepatan dan kemampuan yang tepat untuk tugas pengodean. Claude Opus 4.6 menghasilkan hasil yang lebih baik pada keputusan arsitektur kompleks tetapi lebih mahal dan berjalan lebih lambat. Untuk pengeditan file sederhana dan pencarian, Claude Haiku 4.5 berfungsi dan biayanya 90% lebih murah.
Berapa biaya untuk menjalankan agen pengodean Anda sendiri?
Sesi pengodean tipikal (30-50 giliran) dengan Claude Sonnet 4.6 berharga $1-5 dalam biaya API. Pendorong biaya utama adalah ukuran jendela konteks; kompresi agresif menjaga biaya tetap rendah. Sumber yang bocor dari Kode Claude menunjukkan ia memicu kompresi pada 92% penggunaan konteks untuk mengendalikan ini.
Mengapa Kode Claude menggunakan React untuk aplikasi terminal?
Ink (React untuk terminal) memungkinkan tim menggunakan kembali model komponen React dan manajemen status untuk interaksi UI kompleks seperti dialog izin, output streaming, dan tampilan panggilan alat. Untuk proyek DIY, REPL input() / print() sederhana sudah cukup.
Apa fitur terpenting yang harus dibangun setelah perulangan inti?
Sistem izin. Tanpa itu, model dapat menimpa file dan menjalankan perintah arbitrer tanpa pengawasan pengguna. Bahkan gerbang sederhana “konfirmasi sebelum tulis/eksekusi” mencegah sebagian besar kerusakan yang tidak disengaja.
Bagaimana Kode Claude menangani kesalahan dari panggilan alat?
Kesalahan alat dikembalikan sebagai konten teks dalam pesan tool_result. Model melihat kesalahan dan memutuskan apakah akan mencoba lagi, mencoba pendekatan yang berbeda, atau bertanya kepada pengguna. Tidak ada penanganan kesalahan khusus; penalaran model menangani pemulihan.
Bisakah saya menggunakan ini dengan model selain Claude?
Ya. Pola penggunaan alat berfungsi dengan model apa pun yang mendukung pemanggilan fungsi: GPT-4, Gemini, Llama, dan lainnya. Anda perlu mengadaptasi format panggilan API, tetapi perulangan agen, alat, dan sistem memori tidak tergantung pada model.
Bagaimana saya mencegah agen menjalankan perintah berbahaya?
Mulai dengan daftar blokir pola berbahaya (rm -rf /, mkfs, dll.) dan memerlukan persetujuan eksplisit untuk semua panggilan run_command. Kode Claude mengklasifikasikan setiap operasi sebagai risiko RENDAH, SEDANG, atau TINGGI dan memblokir atau meminta berdasarkan klasifikasi tersebut. Buat hal yang sama untuk alat Anda.