• Author: Amin Boulouma, Software Engineer
• Github source code: https://github.com/aminblm/ai_systems_design_from_scratch
• Engineering Blog: https://github.com/aminblm/ai_systems_design_from_scratch/blog/

The IaC Strategy: Infrastructure as Code

In an AI system, the most common “bug” isn’t in your Python code—it’s in the environment. You run the agent on your laptop, it works; you run it on a server, it crashes because of a missing dependency or a mismatched library version. This is the “Works on My Machine” syndrome. The solution is Infrastructure as Code (IaC), treating your environment setup with the same rigor as your application logic.

Glossary for the Young Engineer

• IaC (Infrastructure as Code): Writing a “recipe” (code) that builds your computer environment automatically, so it’s always the same.
• Environment: The “room” where your code lives—including the operating system, libraries, and settings.
• Reproducibility: Being able to run the same code over and over again and getting the exact same result every time.
• Version Control: Saving history of your code changes, like a time machine for your project.

The Problem Space: Configuration Drift

Configuration drift happens when you manually tweak settings on a server. Over time, that server becomes a “snowflake”—unique, impossible to replicate, and prone to breaking. In AI kernels, where you rely on specific pip packages and system binaries, this leads to untraceable runtime errors.

Why we choose IaC over manual configuration: We prioritize immutability. With IaC, we never “update” a server; we replace it with a new one built from our code. This makes the entire infrastructure a predictable, testable artifact.

Implementation

Simple Example: The Configuration Manifest

Instead of a README, use a simple script to verify the environment.

# env_check.py
import sys

def verify_env():
    required_packages = ["numpy", "requests"]
    for pkg in required_packages:
        try:
            __import__(pkg)
        except ImportError:
            print(f"FAIL: {pkg} not found")

Complex Example: Production-Grade IaC Wrapper

This implementation acts as an “Environment Manager” that ensures the kernel is ready before execution.

import subprocess
import json

class EnvironmentManager:
    def __init__(self, manifest_path: str):
        self.manifest = manifest_path

    def bootstrap(self):
        """Automates the installation of required system state."""
        with open(self.manifest, 'r') as f:
            config = json.load(f)
            
        for dep in config.get("dependencies", []):
            print(f"Ensuring {dep} is installed...")
            subprocess.run(["pip", "install", dep], check=True)
            
    def validate(self):
        """Post-bootstrap validation gate."""
        # Check system constraints (e.g., CUDA, Memory)
        return True

Quick Reference: Environment Management

Approach	Reliability	Speed	Use Case
Manual	Very Low	Slow	Prototypes/Local testing
Scripted (IaC)	Moderate	Fast	Small AI Kernels
Declarative (Terraform/Docker)	High	Very Fast	Enterprise/Production AI

Developer Checklist

• Declarative: Is your environment defined in a file, not a set of manual instructions?
• Versioned: Is your IaC recipe stored in the same Git repo as your source code?
• Ephemeral: Can your entire kernel run on a brand-new computer just by running the bootstrap?
• Validation Gate: Does the system fail fast if the environment isn’t met?

Final Takeaways

1. Infrastructure is not a “setup” step; it is a feature. If your agent’s infrastructure isn’t part of your codebase, it isn’t “done.”
2. Standardize the environment. Use declarative tools to ensure that what works on your laptop works in the cloud.
3. Automate or perish. Manual configuration is the enemy of system reliability.