AI Engineering Reading List: Agents, Context & Evals

What you will learn

• Building effective agents
• Context engineering
• Tools, instructions and guardrails
• Model, tools and the orchestration loop
• Planning, memory and tool use
• Evals, RAG, caching and feedback
• Testing AI products with evals
• Building a GPT from scratch

How it works

Anthropic, OpenAI, Google, Lilian Weng, Eugene Yan, Hamel Husain and Andrej Karpathy, each with why it is worth your time and the one thing to take away.

Decide: Do you need an agent, and what should it see?

1. Building Effective Agents (Anthropic): Start here. Most tasks do not need an agent: a fixed workflow of model calls is cheaper, faster and easier to debug. This post shows where the line is, and the few patterns (chaining, routing, parallel calls, orchestrator and workers, evaluator and optimizer) that hold up in production.
2. Effective Context Engineering for AI Agents (Anthropic): The context window is the agent’s working memory, and it has a budget. Why adding more context often makes answers worse, and how to choose what goes in: instructions, tools, examples, retrieved data and notes the agent keeps for itself.

Build: What are the parts, and how do they fit together?

1. A Practical Guide to Building Agents (OpenAI): A short playbook you can work through in one sitting: picking a model, designing tools, writing instructions, one agent versus several, guardrails, and when to hand control back to a person.
2. Agents (Google · whitepaper on Kaggle): Breaks an agent into three layers: the model that reasons, the tools it can call, and the orchestration loop that decides what happens next. Worked examples connect each layer to real code.
3. LLM Powered Autonomous Agents (Lilian Weng): The 2023 post that gave many engineers their first map of an agent: planning, memory and tool use. It is older than the rest of the list, but it is still the clearest overview of the moving parts and the research behind them.

Ship: How do you make it reliable for real users?

1. Patterns for Building LLM-based Systems & Products (Eugene Yan): Patterns from someone who has shipped them: evals, retrieval (RAG), fine-tuning, caching, guardrails, defensive UX and collecting user feedback. Long, and worth the time.
2. Your AI Product Needs Evals (Hamel Husain): If you read one thing about testing AI systems, read this. Why AI products stall without evals, and how to build them in layers: simple assertions first, then human and model review, then A/B tests.

Understand: What is the model actually doing?

1. Neural Networks: Zero to Hero (Andrej Karpathy): For when you want to see under the hood. You start from a tiny engine that computes gradients and build your way up to a GPT, one step at a time, in code you write yourself.

More courses

• Jobs, linked to lessons — Browse jobs where every requirement links to the chapter that teaches it. See how ready you are, how long the gap takes to close, and which listings look stale.
• Match a job post to courses — Paste a job post. Each skill is matched to a track here and put in learning order, foundations first.
• React from open source with patterns — Patterns extracted from Material UI, Radix, React Aria, React Hook Form, Redux Toolkit, TanStack, and Next.js — not slides about hooks.
• Database in depth — How a query becomes work. Indexes, isolation, locks, and the plans that explain why a page is slow — not an ORM tour.
• System Design — Core concepts first (SQL vs NoSQL, CAP, indexing, replication, sharding), then designs grouped by what carries them: the database, Redis, Kafka, or many services.
• Microservices — Microservice patterns one diagram at a time: how to split a monolith, how services talk, and how data stays consistent without distributed transactions.
• Kafka — A beginner-to-senior path through event logs, reliable delivery, production operations, and disaster recovery.
• Frontend system design — How a UI is sliced when it is a product, not a page: ownership of state, cache, routes, and what happens when the network lies.
• TypeScript in depth — The type system as a design tool. Inference, narrowing, generics, and the errors that mean the model is wrong — not a catalog of utility types.
• CSS in depth — See the box, then the page. Visual chapters from the box model through Flexbox surprises, Grid, selectors, and units, then backgrounds, shapes, and visual effects, each with a playground.
• Accessibility — Foundations first (WCAG in plain words, semantic HTML, lists, alt text), then hands-on HTML labs, a full pass of WAI-ARIA 1.3, and a final fix-the-page challenge.
• Docker — What an image is, why layers cache, and how containers find each other on a network.
• Redis — Fifteen Redis patterns, one picture each: cache, session, lock, counter, rate limiter, queue, and when Redis is the wrong tool.