Long reads, every level.
Start with the Curious posts if you've never built with AI. Every post links its jargon to a term page, so you can go deeper on any word without losing your place.
Breaking into AI engineering: a roadmap from zero
The job explained through one wrong answer, then a level-by-level ladder with honest time estimates, a learning order and five things to read.
What happens when you ask an AI a question
From pressing enter to the last word: tokens, the desk the model reads from, one-token-at-a-time writing, thinking, web search, and where your words go.
RAG in plain English: letting the AI look it up
Why a model that sounds like it knows everything still needs to check, and how retrieval-augmented generation makes it read before it answers.
What is an AI agent, really?
A chatbot tells you how; an AI agent goes and does it, deciding each next step from what it just found. A plain-English tour of the loop, the tools, and why limits are part of the design.
How do you know if an AI is any good?
Why a great demo proves very little, how teams check an AI system with a fixed set of test questions called a golden set, and how much a score from 40 questions is really worth.
Thinking models, explained without the hype
What a reasoning model does with its extra time, why the same question can cost ten times more and take forty seconds longer, and a simple rule for when that is worth it.
What happens to what you type into an AI
Your words can be logged, kept, reviewed, used for training, or indexed for search, and each is a separate decision. The questions that tell you which ones apply, without needing to trust a marketing page.
A reading list by level: the papers, posts and books worth your time
Twenty-eight primary sources, grouped from first steps to staff level, with one line on why each one still matters.
The three dials: tokens, temperature and context
Two bugs show up in nearly every first LLM integration. Both trace back to the same three settings, and both are fixable in a few lines of code.
Your first RAG pipeline in pure Python
Chunk, vectorise, rank and build a cited prompt in ~150 lines of standard-library Python, test it with pytest, then swap in a real Embedding model and LLM without touching the rest.
Build your first tool-using agent (offline, in pure Python)
A minimal agent loop that speaks the real Messages API shape: tool calls linked to results by id, several calls per turn, argument validation that does not swallow your bugs, a step budget, pytest, and the same loop against Claude.
Your first eval set in an afternoon
Thirty to fifty real examples, five check types, a Wilson interval on the score, and a comparison that respects noise — in plain Python with no frameworks.
The AI engineering ladder: what each level's week looks like
Budding, Mid, Senior and Staff are not years of experience; they are the size of the problem you own and the evidence you leave behind. What a week looks like at each, what gets you promoted, and how to use this handbook's tracks to get there.
From toy RAG to a real one: embeddings, a vector store and an LLM
Take the stdlib pipeline from the first RAG post and swap in a real Embedding model, a persistent vector store and an LLM, with pinned versions, timeouts, retries, batching and tests.
Structured outputs that don't break
Getting JSON out of a model is easy; getting JSON your code can trust on every call is a system. Schemas, provider structured-output modes versus prompting, validation with targeted retries, and rendering partial JSON while it streams.
Build your first MCP server
What the Model Context Protocol actually standardises, a 30-line Python server with one tool and one resource, how to plug it into a client, and the security rules that matter before anyone else installs it.
Prompt, retrieve or fine-tune? A decision guide
Diagnose the failure first, then pick the technique. A worked claims-triage case shows where fine-tuning pays in 2026: cost, not knowledge.
Hybrid search and reranking: a field guide
Dense and sparse retrieval fail in opposite ways. How Reciprocal Rank Fusion combines them in 15 lines, where ColBERT and SPLADE fit, and what a Cross-encoder costs per 100 candidates on CPU and GPU.
LLM-as-judge without fooling yourself
A model can grade open-ended answers at scale, but only after you have measured its true-positive and true-negative rates against people and corrected the pass rate it reports.
Anatomy of a production RAG system
Every box between the user's question and a cited answer, with a latency and cost budget per stage, who owns it, and the one metric that tells you it is broken.
Choose your chunk size by measurement, not folklore
A reproducible method: build a small golden set on a public corpus, sweep chunk sizes, and read recall@k, evidence coverage and context cost off one table.
Error analysis, step by step: from 100 traces to a failure taxonomy
Read real traces, write free-form notes, group them into categories, rank by frequency × impact, and turn the top categories into evals that gate releases.
Tool design for agents: the interface is the product
Names, schemas, error messages the model can act on, pagination, idempotency keys and confirmation for side effects, with runnable examples of a bad tool, a good one and an idempotent write.
The real cost of an LLM feature: latency, tokens and the bill
Five terms make up the bill and two make up the wait. Reasoning tokens, cache writes, batch discounts and the self-host break-even, worked with stated assumptions.
Workflows before agents: pick the simplest pattern that works
Seven patterns from Anthropic’s taxonomy, from one call to a fully autonomous AI agent, with the cost and latency spread of each and the failure that justifies climbing to the next.
Shipping LLM features safely
Eval gates on repeated runs with confidence intervals, versioned configs, canaries sized by arithmetic rather than habit, and a rollback you have rehearsed.
Reading public AI incidents as postmortems
Two well-documented failures, the Air Canada chatbot ruling and the Replit agent that deleted a production database, rewritten as postmortems: timeline, detection, root cause, and the control that would have caught each one.
Self-host or API? A break-even memo with the maths shown
A decision memo for serving Open-weights vs closed models models yourself versus paying per token, with every price, throughput and headcount stated as an assumption, a cost-versus-volume curve, and a calculator you can rerun with your own numbers.
Durable agents: checkpoints, idempotent tools and approvals that wait for days
An agent run is a long-lived workflow that will be interrupted. How to checkpoint each step, make every side effect safe to replay, resume at step 7 after a crash, and park a run for a human without holding a worker, with a runnable stdlib example.
What AI-engineering interviewers test at each level
One design question, three scored answers (Mid, Senior, Staff), the rubric behind the scores, and the red flags that sink otherwise good candidates.
Talking a team out of RAG (when it is the wrong tool)
RAG is a default, not a requirement. When long context with prompt caching or text-to-SQL is the better design, what it costs and how fast it is with numbers, how per-document permissions change the answer, and the written threshold that flips the decision.
Securing agents: assume the model will be fooled
Prompt injection has no reliable filter, so agent security is architecture: break the lethal trifecta, constrain what a fooled model can do, and test it like any other regression.
Decision memo: one LLM platform for twelve teams
A worked staff-level decision record for a shared LLM gateway: context, decision, alternatives, tenancy, budgets and chargeback, model policy, eval gates, build versus buy, rollout and risks.