For DevOps, SRE, and platform engineers

From DevOps to AI engineer: the transition path

What already transfers

This is the moat. Most of what makes an agent system safe to run in production maps directly onto disciplines you practice every day. You're not learning these from scratch — you're translating them.

What is actually new

A handful of things really are unfamiliar, and naming them precisely is how you learn fast. None require a research background — they're skills, not a degree.

Probabilistic systems

The same input can take a different path. You stop chasing a single deterministic code path and start verifying outcomes across runs. This is the deepest mindset shift, and the rest follows from it.

Prompts as spec

The prompt is where you encode intent, constraints, and behavior — closer to writing a precise spec than writing code. It's the contract the model works against.

The agentic loop

The core pattern: the model decides, calls a tool, reads the result, and decides again until a stop condition. Your code becomes the harness around that loop rather than the decision-maker inside it.

Model selection and economics

Choosing among model families and sizes, and understanding their cost and latency tradeoffs, is a real engineering decision — the new version of picking the right instance type.

Retrieval and RAG

Grounding a model in your own data with retrieval is the most common production pattern. The plumbing — indexing, chunking, querying — will feel familiar; the relevance tuning is the new part.

A realistic transition path

Because the audience is already senior, this is weeks of deliberate building, not a multi-year detour. The shape that works:

1. Fundamentals

Tokens, context windows, model families, and prompting-as-spec. Enough to reason about what the model is actually doing and what it costs.

2. Build an agent

The loop, tools, and MCP. Get something that takes actions working end-to-end — the demo is the easy part, but you need it before the hard parts make sense.

3. Make it production-grade

Evals, cost-modeling, and safety. This is where your ops background pays off most: it's the gap between a notebook demo and something you'd put in front of customers.

4. Deploy

Ship it across Anthropic, AWS, and Cloudflare — understanding where each fits and the tradeoffs between calling the API directly, going through a managed platform, or running at the edge.

5. Assemble a portfolio

A small set of working, observable, safe systems you can point to. In hiring, evidence that you've actually shipped beats any credential.

Those five steps are the DevOps-shaped version. The full nine-stage sequence, with a row for what an SRE background lets you compress and where it stops helping, is the AI engineer roadmap.

As-built: model routing and guardrails in production on this site

The "capacity and cost management" row in the table above is not abstract for us — it is a routing table we ship. src/lib/llm.ts modelFor() picks a model per role: the cheap hint role runs on Claude Haiku 4.5, tutor and grader roles run on Claude Sonnet 5, and the eval role (offline eval/judge work) runs on Claude Opus 5. src/lib/cost.ts prices those tiers at $1/$5, $3/$15, and $5/$25 per million input/output tokens, so every coach turn logs a real dollar figure rather than a guess. This is the same instinct as picking an instance type for a workload, just one layer up.

We hit two incidents in the operational plane worth naming plainly, because they are the kind of thing you only learn by running the thing in production. One AI Gateway guardrail category has to run in FLAG mode, not BLOCK: block mode 424'd a legitimate question inside our own prompt-injection security lesson, because the guardrail could not tell a real attack from a lesson teaching one. The other thirteen categories still block, prompt side and response side — the mode is a per-category setting, not a switch on the gateway. And a silent "(no reply)" bug turned out to be reasoning tokens counting against max_tokens — Claude Sonnet served via Bedrock enables extended thinking by default, so the fix was sending reasoning: { effort: 'none' } in src/lib/llm.ts's buildChatBody on every Anthropic slug.

Both incidents are the DevOps-to-AI translation from earlier on this page made concrete: incident response and rate limiting didn't disappear, they just moved into the model-call path. See Claude's tool-use docs and Cloudflare AI Gateway for the primitives we build on, and the model-router pattern for the routing decision in more depth.