Teach Your AI Agent to Write Python Logs Like a Pro

Last week on the Caparra blog, we made the case for why logging is the DevOps superpower that gives you X-ray vision into your systems. If you missed it, check out X-ray Vision: Logging in Python.

This post is a follow-up, focused on a new challenge: what if you and your team are experimenting with using AI Agents to write your Python code? And what if that code is missing the kind of logging you now realize is essential? Some of the Agent’s output might be functional, even clever… but when something breaks, you're flying blind.

Just like we train junior developers to build habits that lead to better software, we need to guide our AI Agents to log their code in smart, structured, and consistent ways.

The best part: if you train your AI Agent to use good logging standards in its code, and you receive logs that identify problems with that code, you can close the “Feedback Loop” with your agent, providing specific instructions on how to fix errors or bugs quickly.

Let’s walk through why that matters, and how to do it.

Even AI Agents gain x-ray superpowers when they use Python logging wisely.

Why Logging Matters in AI-Written Code

When your AI agent writes code, it doesn’t know the production context. It doesn’t know what parts of your infrastructure are fragile. It doesn’t know how you debug issues at 2am when PagerDuty goes off.

Without logging, that agent is flying blind. And so are you.

Good logging helps with:

• Error detection: Find problems earlier by logging unexpected behavior, timeouts, or missing data.

• Debugging: When something goes wrong, logs let you retrace the steps.

• Performance monitoring: See how long tasks take, and spot bottlenecks.

• Operational confidence: When your AI agent updates infra, you want receipts.

This applies to almost every kind of DevOps task an AI Agent might handle: from provisioning cloud resources to rotating secrets to patching dependencies.

But most AI-generated Python code looks like this:

import requests

def fetch_data(url):
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    return None

It works. But if something goes wrong, you’ll have no idea why.

A Better Way: Logging with Python’s logging Module

Python comes with a built-in logging module that’s flexible, powerful, and easy to use once you understand the basics.

Here’s a logging-aware version of that same function from above:

import logging
import requests

logger = logging.getLogger(__name__)

def fetch_data(url):
    logger.info(f"Fetching data from {url}")
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        logger.debug(f"Response: {response.text[:100]}")  # Only log a snippet
        return response.json()
    except requests.exceptions.RequestException as e:
        logger.error(f"Failed to fetch data from {url}: {e}")
        return None

This is not overkill. It’s basic hygiene.

Instructions for AI Agents Writing Python Code

Note that you could probably copy and paste most of the below directly into the prompt engineering of your code-writing AI Agent.

Logging Configuration

Python's default behavior sends logs to standard error, which is usually fine for most command-line or containerized scripts. But if you want your logs to go anywhere else—like a monitoring dashboard, a remote log collector, or a file—you need to explicitly configure the destination using a logging handler. For most use cases, especially in cloud-native or ephemeral environments, it's best to stick with standard output. Avoid writing logs directly to local files unless your application explicitly requires it.

Import the logging module and configure a module-level logger:

import logging
logger = logging.getLogger(__name__)

If the script is a CLI or entry point, use basicConfig:

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    handlers=[logging.StreamHandler()]  # Ensures logs go to stdout/stderr, not a file
)

Logging Use

• Use logger.info() at the start of each function to confirm execution.

• Use logger.debug() to log intermediate variables and flow.

• Use logger.warning() when falling back to default logic or encountering unexpected but non-critical conditions.

• Use logger.error() inside except blocks to capture and log exceptions clearly.

Context

• Always log meaningful context: URLs, file names, input parameters, or config settings.

• Never log secrets, credentials, or full payloads.

• For large values (e.g., API responses), log only a trimmed version (first 100–200 characters).

Performance and Behavior

• Time expensive or long-running operations and log their durations.

• Avoid logging in tight loops to reduce noise and prevent performance issues.

• Be mindful of log volume; keep logs informative but concise.

Versioning and Metadata

• On startup, log the script or Agent version explicitly.

• Also log key configuration paths, environment details, or runtime context.

This format ensures your AI Agent has structured, clear, and production-grade logging practices that enhance observability, debuggability, and operational readiness.

Wrapping Up: Brilliance in the Basics

When your AI Agent writes Python without logging, you’re accepting silent failure. That’s not how you build reliable systems. Logging is one of those humble practices that makes everything else better. It turns "it just failed" into "ah, here’s what happened."

And the best part? It’s easy to teach. With a few examples and some structure, your Agent will start producing code you can actually trust. And when errors or bugs emerge, you can quickly give your Agent feedback to fix problems before they’re shipped to production.

Want to see how Caparra helps software teams ship faster and debug smarter? Open a free Caparra account to explore our DevOps tools, get best-practice tips like this, and test out our AI-powered Agent for yourself.