Claude AI Tutorial #19: Claude for Code Generation — Best Practices

import anthropic

client = anthropic.Anthropic()

system_prompt = """You are a Python developer working on a FastAPI project.

<project_context>
- Framework: FastAPI 0.115+
- Database: PostgreSQL with SQLAlchemy 2.0+ (async)
- Auth: JWT tokens via python-jose
- Validation: Pydantic v2
- Testing: pytest with pytest-asyncio
- Style: Black formatting, type hints required, Google-style docstrings
</project_context>

<existing_patterns>
- All routes return Pydantic response models
- All database operations use async sessions
- Errors use HTTPException with detail messages
- Auth dependency: `current_user = Depends(get_current_user)`
</existing_patterns>"""

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    system=system_prompt,
    messages=[
        {
            "role": "user",
            "content": "Write a CRUD endpoint for a 'projects' resource with name, description, and owner_id fields.",
        }
    ],
)

print(response.content[0].text)

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

const client = new Anthropic();

const systemPrompt = `You are a TypeScript developer working on a Next.js 15 project.

<project_context>
- Framework: Next.js 15 with App Router
- Database: Prisma with PostgreSQL
- Auth: NextAuth.js v5
- Validation: Zod
- Styling: Tailwind CSS
- Testing: Vitest + React Testing Library
</project_context>

<existing_patterns>
- Server actions for mutations
- Server components by default, client components only when needed
- Zod schemas for all form validation
- Error boundaries for error handling
</existing_patterns>`;

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 4096,
  system: systemPrompt,
  messages: [
    {
      role: "user",
      content:
        "Write a server action for creating a new project with name, description, and team members.",
    },
  ],
});

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    system="You are a backend developer. Write production-ready Python code.",
    messages=[{
        "role": "user",
        "content": """Write a payment processing function with these requirements:

<requirements>
- Accept amount (Decimal), currency (str), and payment_method_id (str)
- Validate amount > 0 and currency is ISO 4217
- Call Stripe API to create a PaymentIntent
- Handle StripeError, network errors, and invalid input
- Return a PaymentResult dataclass with status, transaction_id, and error_message
- Log all operations with structlog
- Include type hints and docstring
</requirements>"""
    }],
)

existing_model = """
# models/user.py
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import DeclarativeBase

class Base(DeclarativeBase):
    pass

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    email = Column(String, unique=True, nullable=False)
    name = Column(String, nullable=False)
"""

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": f"""<existing_code>
{existing_model}
</existing_code>

Add a Project model that:
- Has fields: name, description, created_at
- Has a foreign key to User (owner)
- Has a many-to-many relationship with User (members)
- Follows the same patterns as the User model above"""
    }],
)

system = """You write Python code following these conventions:
- Python 3.12+ features (type hints, match statements, f-strings)
- PEP 8 style, formatted with Black
- All functions have type hints for parameters and return values
- Use dataclasses or Pydantic models for data structures
- Prefer pathlib over os.path
- Use contextlib for resource management
- Write Google-style docstrings"""

const system = `You write TypeScript code following these conventions:
- TypeScript 5.5+ strict mode
- Prefer interfaces over types for object shapes
- Use readonly where possible
- Prefer const assertions
- Use Zod for runtime validation
- Prefer async/await over raw Promises
- Use ESM imports, not CommonJS require`;

system = """You write Go code following these conventions:
- Go 1.23+ features
- Standard library first, external packages only when necessary
- Error handling: return errors, wrap with fmt.Errorf and %w
- Use context.Context for cancellation and timeouts
- Table-driven tests
- Interfaces accepted, structs returned"""

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    messages=[{
        "role": "user",
        "content": """Write a URL shortener service in Python with:
1. A function to shorten a URL (generate a 6-character code)
2. A function to resolve a short code back to the original URL
3. Storage in a dict (in-memory for now)
4. Validation that the URL is valid

Then write comprehensive tests using pytest:
- Happy path tests
- Edge cases (empty URL, invalid URL, non-existent code)
- Test that shortened URLs are unique"""
    }],
)

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16384,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000,
    },
    messages=[{
        "role": "user",
        "content": """Implement a rate limiter with these requirements:
- Token bucket algorithm
- Configurable rate (tokens per second) and burst size
- Thread-safe for concurrent access
- Support for per-user rate limiting
- Sliding window for accurate rate tracking
- Return remaining tokens and reset time in the response"""
    }],
)

# The thinking block shows Claude's reasoning
for block in response.content:
    if block.type == "thinking":
        print(f"Thinking: {block.thinking[:200]}...")
    elif block.type == "text":
        print(f"Code:\n{block.text}")

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    system="Generate code with clear file path headers. Use ```language:path/to/file.ext format.",
    messages=[{
        "role": "user",
        "content": """Create a complete REST API for a todo app:

Files needed:
1. models/todo.py — SQLAlchemy model
2. schemas/todo.py — Pydantic request/response schemas
3. routes/todo.py — FastAPI route handlers (CRUD)
4. tests/test_todo.py — pytest tests for all endpoints

Requirements:
- Fields: id, title, description, completed, created_at, updated_at
- Endpoints: GET /todos, GET /todos/{id}, POST /todos, PUT /todos/{id}, DELETE /todos/{id}
- Filtering: GET /todos?completed=true
- Pagination: GET /todos?page=1&size=10"""
    }],
)

code_to_refactor = """
def process_order(order_data):
    # validate
    if not order_data.get('items'):
        return {'error': 'No items'}
    if not order_data.get('customer_id'):
        return {'error': 'No customer'}
    total = 0
    for item in order_data['items']:
        if item['quantity'] < 1:
            return {'error': 'Invalid quantity'}
        total += item['price'] * item['quantity']
    # apply discount
    if order_data.get('coupon'):
        if order_data['coupon'] == 'SAVE10':
            total *= 0.9
        elif order_data['coupon'] == 'SAVE20':
            total *= 0.8
    # save
    order = db.orders.insert({'customer_id': order_data['customer_id'], 'items': order_data['items'], 'total': total})
    return {'order_id': order.id, 'total': total}
"""

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": f"""Refactor this function:

```python
{code_to_refactor}

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": """I am getting this error:

<error>
TypeError: Cannot read properties of undefined (reading 'map')
  at UserList (components/UserList.tsx:15:28)
  at renderWithHooks (react-dom.development.js:14985:18)
</error>

<code>
// components/UserList.tsx
import { useEffect, useState } from 'react';

export function UserList() {
  const [users, setUsers] = useState();

  useEffect(() => {
    fetch('/api/users')
      .then(res => res.json())
      .then(data => setUsers(data));
  }, []);

  return (
    <ul>
      {users.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}
</code>

<expected>
The component should render a list of users fetched from the API.
</expected>

Find the bug and show the fixed code."""
    }],
)

tools = [
    {
        "name": "run_typecheck",
        "description": "Run TypeScript type checker on the given code",
        "input_schema": {
            "type": "object",
            "properties": {
                "code": {"type": "string", "description": "TypeScript code to check"},
            },
            "required": ["code"],
        },
    },
    {
        "name": "run_linter",
        "description": "Run ESLint on the given code",
        "input_schema": {
            "type": "object",
            "properties": {
                "code": {"type": "string", "description": "Code to lint"},
            },
            "required": ["code"],
        },
    },
]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "Write a TypeScript function to parse CSV files. After writing, run the type checker and linter to verify."
    }],
)