The software baseline

By the end of Part 0 you’ll write one small script: call a model API, retry when it fails, log what the call cost. Sounds trivial.

That script touches seven skills at once: Python for the body, HTTP for the call, JSON to parse the reply, asyncio if you batch calls, Git to commit it, Docker to ship it, and Postgres to store the cost. This book assumes you already have all seven. This chapter is the bar, not the lesson.

What an AI engineer is (and isn’t) drew the role boundary: you work above the model API line. So the baseline is a working software engineer’s toolkit, nothing more. No machine-learning math, no distributed-systems theory, no algorithms depth. Those are the wrong prerequisites for this book, and the sibling handbooks own them where you do want them.

flowchart LR
  S["One ordinary script"]
  S --- A["Python"]
  S --- B["HTTP"]
  S --- C["JSON"]
  S --- D["async"]
  S --- E["Git"]
  S --- F["Docker"]
  S --- G["Postgres"]

Treat the seven as an audit, not a syllabus. For each row below, ask one question: could you do that right now, today, without looking it up? If yes, move on. If a row makes you hesitate, open its link, spend a couple of hours, and come back. Don’t try to learn all seven at once.

The seven skills

A note on versions while you check your setup. The book uses Python 3.10+ syntax, so confirm python --version reads 3.12 or newer before you start; 3.8 will throw syntax errors. The linked Python and asyncio docs track 3.14.6 as of June 2026, and the Postgres tutorial tracks 18.4.

The one idiom worth recognizing now

The async self-check says you can gather coroutines. Here’s the exact shape, the one you’ll hit in Part 2 for parallel model calls and Part 7 for parallel tool calls.

# illustrative: the fan-out idiom, not a runnable demo
import asyncio

async def call_model(prompt: str) -> str:
    await asyncio.sleep(0)            # stands in for a real async SDK call
    return f"response to: {prompt}"

async def main() -> None:
    prompts = ["summarize A", "summarize B", "summarize C"]
    results = await asyncio.gather(*[call_model(p) for p in prompts])
    print(results)

asyncio.run(main())

Read gather(*[f(item) for item in items]) as one move: fire every call at once, wait for all of them, collect the results in order. If that line reads cleanly, you’re ready. If it looks foreign, spend an hour on the asyncio link before Part 2.

The payoff isn’t cosmetic. Evaluating 50 prompts in a sequential for loop at three seconds each costs you 150 seconds. The same 50 calls through gather finish in roughly the time of the slowest single call, often under ten seconds. That’s a 15x difference on the first eval script you write, which is why async sits on this list and not in an appendix.

What stays off the list

This is the floor, not the ceiling. Three topics show up at scale later, and each lives in a sibling handbook:

• HTTP at scale (load balancing, connection pooling, HTTP/2 multiplexing) is covered in the HLD handbook. You need the request/response model; you don’t need the scaling theory yet.
• Databases at scale (replication, partitioning, sharding) is also HLD territory. The bar here is only “can you use Postgres at all.”
• Algorithms and data structures aren’t on the list at all. If you want that depth, the DSA handbook is where it lives. AI engineering doesn’t gate on it.

Container orchestration sits in the same bucket: local Docker and Docker Compose are the bar, and Kubernetes or ECS gets one sentence and a cross-link when you reach deployment.

Everything after this chapter assumes the seven are in place and stops explaining them.

References