Agentic Coding with Claude: How to Write, Edit, and Execute Code Independently

import fs from "fs/promises";
import path from "path";

const ROOT_DIR = process.cwd(); // or a specific project directory

function resolveSafePath(filePath: string): string {
  const resolved = path.resolve(ROOT_DIR, filePath);
  if (!resolved.startsWith(ROOT_DIR)) {
    throw new Error(`Path traversal attempt blocked: ${filePath}`);
  }
  return resolved;
}

async function readFileTool(input: { path: string }) {
  const safePath = resolveSafePath(input.path);
  const content = await fs.readFile(safePath, "utf-8");
  // Truncate to protect context
  if (content.length > 10000) {
    return content.slice(0, 10000) + "\n\n[File truncated at 10,000 chars]";
  }
  return content;
}

async function writeFileTool(input: { path: string; content: string }) {
  const safePath = resolveSafePath(input.path);
  await fs.mkdir(path.dirname(safePath), { recursive: true });
  await fs.writeFile(safePath, input.content, "utf-8");
  return { success: true, path: safePath };
}

async function editFileTool(input: {
  path: string;
  oldString: string;
  newString: string;
}) {
  const safePath = resolveSafePath(input.path);
  let content = await fs.readFile(safePath, "utf-8");
  if (!content.includes(input.oldString)) {
    throw new Error(
      `String not found in file. The file content may have changed. Read the file again before retrying.`
    );
  }
  content = content.replace(input.oldString, input.newString);
  await fs.writeFile(safePath, content, "utf-8");
  return { success: true };
}

import { execFile } from "child_process";
import { promisify } from "util";

const execFileAsync = promisify(execFile);

const ALLOWED_COMMANDS = new Set(["npm", "node", "npx", "tsc", "jest", "vitest", "python3", "python", "go", "cargo"]);

async function runCommandTool(input: { command: string; args: string[]; cwd?: string }) {
  const { command, args, cwd } = input;

  if (!ALLOWED_COMMANDS.has(command)) {
    throw new Error(
      `Command '${command}' is not allowed. Allowed commands: ${[...ALLOWED_COMMANDS].join(", ")}`
    );
  }

  const workingDir = cwd
    ? resolveSafePath(cwd)
    : ROOT_DIR;

  try {
    const { stdout, stderr } = await execFileAsync(command, args, {
      cwd: workingDir,
      timeout: 30_000, // 30 second timeout
      maxBuffer: 1024 * 1024, // 1MB output cap
    });

    return {
      exitCode: 0,
      stdout: stdout.slice(0, 5000), // Truncate large outputs
      stderr: stderr.slice(0, 2000),
    };
  } catch (error: unknown) {
    const execError = error as { code?: number; stdout?: string; stderr?: string; message?: string };
    return {
      exitCode: execError.code ?? 1,
      stdout: (execError.stdout ?? "").slice(0, 5000),
      stderr: (execError.stderr ?? execError.message ?? "Unknown error").slice(0, 2000),
    };
  }
}

You are a coding agent with access to the filesystem and a command runner. Your job is to read, understand, and modify code to solve the task given.

Working rules:
1. Always read a file before modifying it. Never write code based on assumptions about file content.
2. After making a change, run the relevant test or compilation command to verify it worked.
3. If a command fails, read the error carefully and fix the root cause. Do not retry the same command without changing something.
4. Make the smallest change that fixes the problem. Don't refactor surrounding code unless asked.
5. If you're unsure which file to edit, use list_directory and search_in_files to locate the right place before changing anything.
6. Report what you did and what the test output showed after completing the task.

You operate inside the project root. All file paths should be relative to that root.

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const tools: Anthropic.Tool[] = [
  {
    name: "list_directory",
    description: "List files and directories at the given path. Use to explore the project structure.",
    input_schema: {
      type: "object",
      properties: { directory: { type: "string" } },
      required: ["directory"],
    },
  },
  {
    name: "read_file",
    description: "Read a file's content. Always do this before editing a file.",
    input_schema: {
      type: "object",
      properties: { path: { type: "string" } },
      required: ["path"],
    },
  },
  {
    name: "edit_file",
    description: "Replace a specific string in a file with new content. Read the file first. Use exact strings that exist in the file.",
    input_schema: {
      type: "object",
      properties: {
        path: { type: "string" },
        oldString: { type: "string", description: "Exact string to replace. Must exist verbatim in the file." },
        newString: { type: "string", description: "String to replace it with." },
      },
      required: ["path", "oldString", "newString"],
    },
  },
  {
    name: "run_command",
    description: "Run a shell command and return stdout and stderr. Use to run tests or compile code.",
    input_schema: {
      type: "object",
      properties: {
        command: { type: "string", description: "Command name (e.g., npm, npx, tsc)." },
        args: { type: "array", items: { type: "string" }, description: "Arguments to pass." },
        cwd: { type: "string", description: "Working directory. Optional." },
      },
      required: ["command", "args"],
    },
  },
];

async function executeAgentTool(name: string, input: Record<string, unknown>) {
  switch (name) {
    case "list_directory":
      return await listDirectoryTool(input as { directory: string });
    case "read_file":
      return await readFileTool(input as { path: string });
    case "edit_file":
      return await editFileTool(input as { path: string; oldString: string; newString: string });
    case "run_command":
      return await runCommandTool(input as { command: string; args: string[]; cwd?: string });
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
}

async function fixFailingTest(testPattern: string) {
  const messages: Anthropic.MessageParam[] = [
    {
      role: "user",
      content: `Run the tests matching "${testPattern}" to see the failure, then fix the underlying bug in the source code. Verify the fix by running the tests again.`,
    },
  ];

  const MAX_ITERATIONS = 20;
  let i = 0;

  while (i++ < MAX_ITERATIONS) {
    const response = await client.messages.create({
      model: "claude-opus-5-20260101",
      max_tokens: 8192,
      system: `You are a coding agent...`, // full system prompt from above
      tools,
      messages,
    });

    messages.push({ role: "assistant", content: response.content });

    if (response.stop_reason === "end_turn") {
      return response.content.find((b) => b.type === "text")?.text ?? "";
    }

    const results: Anthropic.ToolResultBlockParam[] = [];
    for (const block of response.content) {
      if (block.type === "tool_use") {
        let result: unknown;
        let isError = false;
        try {
          result = await executeAgentTool(block.name, block.input as Record<string, unknown>);
        } catch (err) {
          result = { error: err instanceof Error ? err.message : "Unknown error" };
          isError = true;
        }
        results.push({
          type: "tool_result",
          tool_use_id: block.id,
          is_error: isError,
          content: JSON.stringify(result),
        });
      }
    }

    messages.push({ role: "user", content: results });
  }

  throw new Error("Agent did not complete within iteration limit");
}