Claude Code Refactoring Example

FILE: validators.py

def validate_fields(data: dict, required_fields: list) -> bool:
    """Check if all required fields exist in data."""
    return all(field in data for field in required_fields)

FILE: main.py

from fastapi import FastAPI, Request
from validators import validate_fields

app = FastAPI()

@app.post("/user")
async def create_user(request: Request):
    """Handle user creation with reusable validation."""
    data = await request.json()
    if not validate_fields(data, ["username", "email"]):
        return {"error": "Invalid user data"}
    return {"message": f"User {data['username']} created successfully"}

@app.post("/product")
async def create_product(request: Request):
    """Handle product creation with reusable validation."""
    data = await request.json()
    if not validate_fields(data, ["name", "price"]):
        return {"error": "Invalid product data"}
    return {"message": f"Product {data['name']} created successfully"}

System Prompts and Guardrails for Claude Code

When working with Claude Code on large or sensitive projects, controlling how it behaves is just as important as what it generates. You don’t want an AI assistant that improvises or changes tone midway through a development session. This is where system prompts and guardrails come in.

A system prompt acts as the "personality and behavior blueprint" for Claude — it defines how the model should respond, what tone to use, what rules to follow, and which limitations to observe. Guardrails, on the other hand, establish safety and consistency boundaries, ensuring Claude stays within the project’s scope, style, and compliance requirements. Together, these techniques help developers shape Claude’s behavior for predictable, high-quality results in any workflow.

Concept Development

A system prompt is the first instruction Claude receives in a session — the hidden configuration that defines its global behavior. Think of it as a preface that sets the tone and expectations before any user prompt is read. Anthropic’s Claude models always interpret prompts within the context of the system message first, giving it top priority in decision-making.

This means the system prompt can define how Claude reasons, what to prioritize, and even what style of code or explanation to prefer. For example, you might set a system prompt that instructs Claude to:

• Write PEP8-compliant Python
• Include docstrings in all functions
• Explain reasoning in concise sentences

Every instruction you give afterward will inherit this behavioral pattern automatically.

Guardrails, in contrast, are constraints you intentionally add to prevent unwanted behaviors. They can limit Claude’s scope (e.g., "only write code related to database migrations") or enforce safety rules (e.g., "never expose real credentials or unsafe commands"). Guardrails are critical in enterprise environments, but they’re also valuable for individual developers who want predictable, repeatable outputs from Claude.

Properly applied, system prompts and guardrails make Claude reliable, disciplined, and consistent across long sessions — much like a junior developer who always follows your coding standards and documentation practices.

Hands-On Example

Let’s demonstrate how system prompts and guardrails work in a real scenario. Imagine you’re building a data analysis assistant using Claude that must produce Python code following strict formatting and safety guidelines. You want every response to include clear comments, reusable functions, and error handling — without exposing sensitive system operations.

Here’s how you could define your system prompt and use it within a Claude session.

System Prompt Example

System Prompt (Developer Setup): “You are Claude Code, an AI programming assistant for data engineering and machine learning. Follow PEP8 conventions. Include docstrings in every function. Always include error handling and logging for critical operations. Never execute shell commands, modify files, or expose environment variables. Be concise, professional, and clear in all explanations.”

Once this system prompt is set, every subsequent request will automatically inherit these constraints.

Now you issue a user prompt:

User Prompt: “Write a Python function that loads a CSV file into a pandas DataFrame, handles missing values, and prints summary statistics.”

Claude, operating under the system prompt, responds in line with your guardrails:

import pandas as pd
import logging