AI Engineering Guides
Five long-form guides on the AI engineering problems I work in daily: retrieval-augmented generation, the Model Context Protocol, LLM evaluation, AI agents, and voice AI agents. Each one covers the architecture, the failure modes I've actually hit in production, what it costs to run, and the section most guides skip - when not to build the thing at all.
These are written from shipped client systems, not from a survey of other people's blog posts. Where I cite a number, it links to the primary source. Where I don't have data, I say so.
- 5
- Long-form guides
- 50
- Answered questions
- 115
- Minutes of reading
What these guides answer
The questions that actually come up on client calls, rather than the ones that make for tidy headings.
- Is RAG still relevant now that context windows hold a million tokens?
- When is a workflow the right answer instead of an agent?
- Is MCP the same thing as tool calling, and when is it overhead?
- What's the difference between an eval and a benchmark?
- What latency does a voice agent actually need to hit, and what does a call cost?
The order I'd read them in
Each guide stands on its own, but they build in this sequence - ground a model in your own data, learn whether it actually worked, standardise how it reaches tools, then hand it the loop and finally the phone line.
Retrieval-Augmented Generation: A Practitioner's Guide to RAG Architecture
A practitioner's guide to retrieval augmented generation: architecture, chunking strategies, hybrid search, reranking, evaluation, and when to skip RAG.
- What Retrieval-Augmented Generation Actually Is
- Why Retrieval-Augmented Generation Matters in Production
- RAG vs. Fine-Tuning vs. Prompt Engineering vs. Long Context
- RAG Architecture: From Query to Grounded Answer
- RAG Examples: A Minimal Pipeline in TypeScript
LLM Evaluation: A Practitioner's Guide to Evals That Actually Catch Regressions
A practitioner's guide to LLM evaluation: golden datasets, scorers, LLM-as-judge, online vs. offline evals, and the failure modes that quietly break eval suites.
- What “Evals” Actually Means, and Why Skipping Them Means Shipping Blind
- LLM Evals vs. Benchmarks: Not the Same Thing
- LLM Evaluation Metrics: What to Actually Measure
- The Architecture of an LLM Evaluation Framework
- Building an Eval Harness in TypeScript
Model Context Protocol: A Practitioner's Guide to MCP
A practitioner's guide to the Model Context Protocol: architecture, a working TypeScript server example, production failure modes, and when to skip MCP.
- What MCP actually is, and why it exists
- Architecture: hosts, clients, and servers
- Building a minimal MCP server in TypeScript
- MCP vs. API: The N×M Integration Problem
- MCP vs. direct function calling: when NOT to use MCP
AI Agents: What They Actually Are and When to Build One
A practitioner's guide to AI agents: the plan-act-observe loop, tool calling, memory architecture, real TypeScript code, and when a simple LLM call beats one.
- What Makes Something an “Agent” (and What Doesn’t)
- Why This Matters Now
- AI Agents vs. Agentic AI: What’s the Difference
- Agent vs. Assistant vs. Chatbot vs. Workflow
- What Are the 5 Types of AI Agents?
Voice AI Agents: Architecture, Latency, and Production Lessons
A practitioner's guide to building voice AI agents: architecture, latency budgets, turn-taking, barge-in, evaluation metrics, and when a good IVR beats one.
- What a Voice AI Agent Actually Is
- Why Voice Is a Genuinely Harder Engineering Problem
- Architecture: Cascaded Pipelines vs. Speech-to-Speech
- Implementation Patterns
- Failure Modes and Mitigations