How to Build Your First AI Coding Agent (Step by Step)

pip install anthropic

export ANTHROPIC_API_KEY="sk-ant-..."

# agent.py

import sys

def read_file(filepath: str) -> str:
    """Read a file and return its contents."""
    with open(filepath, "r") as f:
        return f.read()

def write_file(filepath: str, content: str) -> None:
    """Write content to a file."""
    with open(filepath, "w") as f:
        f.write(content)

import anthropic

client = anthropic.Anthropic()  # Uses ANTHROPIC_API_KEY from environment

def fix_code(code: str, errors: str) -> str:
    """Send code to Claude and get the fixed version."""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": f"""Fix the following Python code.

Here are the linting errors:
{errors}

Here is the code:
```python
{code}

The key is the prompt: tell Claude exactly what to fix and ask for ONLY the code back. No explanations, no markdown — just code you can write directly to a file.

**Tip:** AI models sometimes ignore the "no markdown" instruction and wrap the code in triple backticks. Add a cleanup function:

```python
def clean_response(text: str) -> str:
    """Remove markdown code fences if the model adds them."""
    text = text.strip()
    if text.startswith("```python"):
        text = text[len("```python"):].strip()
    if text.startswith("```"):
        text = text[3:].strip()
    if text.endswith("```"):
        text = text[:-3].strip()
    return text

import subprocess

def run_linter(filepath: str) -> tuple[bool, str]:
    """Run the linter and return (passed, error_output)."""
    result = subprocess.run(
        ["python", "-m", "py_compile", filepath],
        capture_output=True,
        text=True
    )

    if result.returncode == 0:
        return True, ""
    else:
        return False, result.stderr

def agent_fix(filepath: str, max_attempts: int = 3) -> bool:
    """
    The agent loop:
    1. Read the file
    2. Run the linter
    3. If errors found — send to Claude for fixing
    4. Write the fix
    5. Run the linter again
    6. If still broken — try again (up to max_attempts)
    """
    print(f"Agent starting on: {filepath}")

    for attempt in range(1, max_attempts + 1):
        print(f"\n--- Attempt {attempt}/{max_attempts} ---")

        # Read the current code
        code = read_file(filepath)

        # Run the linter
        passed, errors = run_linter(filepath)

        if passed:
            print(f"✓ Code passes linting!")
            return True

        print(f"✗ Linting errors found:\n{errors}")
        print("Sending to Claude for fixing...")

        # Send to Claude
        fixed_code = fix_code(code, errors)

        # Write the fix
        write_file(filepath, fixed_code)
        print("Fix applied.")

    # Check one final time after last attempt
    passed, errors = run_linter(filepath)
    if passed:
        print("✓ Fixed after final attempt!")
        return True

    print(f"✗ Could not fix after {max_attempts} attempts.")
    return False

def git_commit(filepath: str, message: str) -> None:
    """Stage the file and create a git commit."""
    subprocess.run(["git", "add", filepath], check=True)
    subprocess.run(["git", "commit", "-m", message], check=True)
    print(f"Committed: {message}")

#!/usr/bin/env python3
"""
A simple AI coding agent that fixes linting errors.

Usage:
    python agent.py path/to/file.py
"""

import subprocess
import sys
import anthropic

client = anthropic.Anthropic()


def read_file(filepath: str) -> str:
    with open(filepath, "r") as f:
        return f.read()


def write_file(filepath: str, content: str) -> None:
    with open(filepath, "w") as f:
        f.write(content)


def run_linter(filepath: str) -> tuple[bool, str]:
    result = subprocess.run(
        ["python", "-m", "py_compile", filepath],
        capture_output=True,
        text=True,
    )
    return (result.returncode == 0, result.stderr)


def fix_code(code: str, errors: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": f"""Fix the following Python code.

Here are the linting errors:
{errors}

Here is the code:
```python
{code}

## How to Use It

Create a broken Python file to test:

```python
# broken.py
def hello(
    print("hello world")

def add(a, b)
    return a + b

class MyClass
    def __init__(self):
        self.value = 0

python agent.py broken.py

def plan_fix(code: str, errors: str) -> str:
    """Ask Claude to plan the fix before writing code."""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"""Analyze these errors and describe what needs to be fixed.
Be brief — just list the changes needed.

Errors:
{errors}

Code:
```python
{code}
```""",
            }
        ],
    )
    return response.content[0].text

plan = plan_fix(code, errors)
print(f"Plan: {plan}")
fixed_code = fix_code(code, errors + "\n\nPlan:\n" + plan)

def run_tests() -> tuple[bool, str]:
    result = subprocess.run(
        ["python", "-m", "pytest", "--tb=short", "-q"],
        capture_output=True,
        text=True,
    )
    return (result.returncode == 0, result.stdout + result.stderr)

def find_related_files(filepath: str) -> list[str]:
    """Find files that import the given file."""
    result = subprocess.run(
        ["grep", "-rl", f"import {filepath.replace('.py', '')}", "."],
        capture_output=True,
        text=True,
    )
    return result.stdout.strip().split("\n") if result.stdout else []

Read → Fix → Verify → Retry