Build your own Claude Code — 300-line local coding agent

Build it in five steps

1. STEP 01

   Declare the tools

   Four is enough for most coding tasks — read files, edit files, run shell commands, run tests. Each is a Python function plus a JSON schema the LLM can call. More tools are a distraction until the core loop works.

   TOOLS = [
       {"type": "function", "function": {
           "name": "read_file",
           "description": "Return the full text of a file, optionally a line range.",
           "parameters": {"type": "object",
               "properties": {"path": {"type": "string"}, "start": {"type": "integer"},
                              "end": {"type": "integer"}},
               "required": ["path"]}}},
       {"type": "function", "function": {
           "name": "apply_patch",
           "description": "Apply a unified-diff patch to the repo.",
           "parameters": {"type": "object",
               "properties": {"patch": {"type": "string"}},
               "required": ["patch"]}}},
       {"type": "function", "function": {
           "name": "run_shell",
           "description": "Run a shell command in the repo root. Returns stdout + stderr.",
           "parameters": {"type": "object",
               "properties": {"cmd": {"type": "string"}},
               "required": ["cmd"]}}},
       {"type": "function", "function": {
           "name": "run_tests",
           "description": "Run the project's test command. Returns pass/fail summary + output.",
           "parameters": {"type": "object",
               "properties": {"scope": {"type": "string"}}}}},
   ]

2. STEP 02

   Implement the tool handlers

   Map each function name to a Python function that does the thing. The run_shell handler is the one that needs care — sandbox it, cap the walltime, and whitelist commands if you're running in a shared environment.

   import subprocess, pathlib
   
   def read_file(path: str, start: int = None, end: int = None) -> str:
       lines = pathlib.Path(path).read_text().splitlines(keepends=True)
       if start is None: return "".join(lines)
       return "".join(lines[start-1:end])
   
   def apply_patch(patch: str) -> str:
       r = subprocess.run(["git", "apply", "-"], input=patch.encode(),
                          capture_output=True)
       if r.returncode: raise RuntimeError(r.stderr.decode())
       return "applied"
   
   def run_shell(cmd: str, timeout: int = 30) -> str:
       r = subprocess.run(cmd, shell=True, capture_output=True, timeout=timeout)
       return r.stdout.decode() + r.stderr.decode()
   
   def run_tests(scope: str = "") -> str:
       cmd = f"pnpm test {scope}" if scope else "pnpm test"
       return run_shell(cmd, timeout=120)
   
   HANDLERS = {"read_file": read_file, "apply_patch": apply_patch,
               "run_shell": run_shell, "run_tests": run_tests}

3. STEP 03

   Write the ReAct loop

   Ask the model, execute any tool calls it returns, feed the results back, repeat until the model stops calling tools. That's the whole loop — everything else is quality-of-life on top.

   from openai import OpenAI
   import json
   
   client = OpenAI(base_url="https://api.aigateway.sh/v1", api_key="sk-aig-...")
   SYSTEM = open("agent-system-prompt.md").read()  # your preferences + conventions
   
   def step(messages: list[dict], model: str = "moonshot/kimi-k2.6") -> list[dict]:
       r = client.chat.completions.create(
           model=model, messages=messages, tools=TOOLS, tool_choice="auto",
           extra_headers={"x-aig-tag": "coder.loop"},
       )
       msg = r.choices[0].message
       messages.append({"role": "assistant", "content": msg.content or "",
                        "tool_calls": msg.tool_calls or []})
       if not msg.tool_calls:
           return messages
       for tc in msg.tool_calls:
           args = json.loads(tc.function.arguments or "{}")
           try:
               out = str(HANDLERS[tc.function.name](**args))[:8000]
           except Exception as e:
               out = f"ERROR: {e}"
           messages.append({"role": "tool", "tool_call_id": tc.id, "content": out})
       return messages
   
   def run(goal: str, model: str = "moonshot/kimi-k2.6"):
       messages = [{"role": "system", "content": SYSTEM},
                   {"role": "user",   "content": goal}]
       for i in range(40):  # hard step cap
           messages = step(messages, model)
           if messages[-1]["role"] == "assistant" and not messages[-1].get("tool_calls"):
               break
       return messages[-1]["content"]

4. STEP 04

   Plug in a human gate for risky tools

   Auto-approving edits and shell commands is fine in a sandbox; in a real repo, gate the two write-side tools behind a one-key confirmation. That one line is the difference between 'a clever demo' and 'something you'd let run on Friday afternoon.'

   RISKY = {"apply_patch", "run_shell"}
   
   def human_ok(tool_name: str, args: dict) -> bool:
       if tool_name not in RISKY:
           return True
       print(f"\n{tool_name}({args})")
       return input("[y/N] > ").strip().lower() == "y"
   
   # Wrap HANDLERS call sites with human_ok() — 4 extra lines.

5. STEP 05

   Point at any model

   The whole loop is model-agnostic. Start on free Kimi K2.6 for dev, upgrade to Opus 4.7 or GPT-5.4 for production, A/B all three with the eval example in this library. One string change.

   if __name__ == "__main__":
       import sys
       goal  = sys.argv[1]
       model = sys.argv[2] if len(sys.argv) > 2 else "moonshot/kimi-k2.6"
       print(run(goal, model))
   
   # $ python agent.py "fix the pagination bug in users API"
   # $ python agent.py "add a CSV exporter for /v1/usage" anthropic/claude-opus-4.7

FAQ

More examples