A build-by-hand curriculum for senior engineersmoving into agentic AI
For engineers with 7+ years shipping production software, ideally some of it on-chain. No frameworks until they're earned. Every week ends with something you can demo.
An agent engineer builds systems where a language model decides what to do next: it calls tools, holds state, and recovers from failure and then proves the system works, with evals, guardrails, and observability. It is not model training; it's the application layer, product engineering plus a new reliability discipline. On job boards it appears as Agent Engineer, AI Engineer, Applied AI / AI Product Engineer, or Forward-Deployed Engineer.
Every product team is adding agents, and demand has outrun the supply of people who can build them credibly. Most candidates can drive a framework but few can whiteboard the loop inside it. The discipline is barely three years old, so nobody has a decade of seniority on you: your production experience is the moat, and the missing layer is learnable in a quarter. That arbitrage is the entire premise of this guide.
Production agent engineering is mostly reliability discipline applied to a new failure mode. Your instincts transfer:
| You already do | In agent engineering it's called | |
|---|---|---|
| External audits & adversarial review | → | Evals & error analysis |
| Circuit breakers & pause guards | → | Guardrails, cost caps, kill switches |
| Thinking like an attacker | → | Prompt-injection defense |
| Protocol specs & ABIs | → | Tool schemas & MCP |
| Testnets before mainnet | → | Sandboxes, dry-run modes, staged rollout |
| "Don't trust, verify" | → | The agent saying it's done ≠ a verifier confirming it |
The gap most senior engineers have isn't talent; it's that the AI wrote the agent code while they supervised. In study hours, you type; the AI explains, reviews, quizzes. Good prompts: "explain what's wrong with my implementation, don't fix it" · "quiz me on yesterday" · "what edge case am I missing?" Banned: "build me X".
Raw fetch against the model APIs, your own types, your own loop, through Month 1. Frameworks are what let you ship without understanding; removing them forces the understanding. They return in Week 8, judged against your hand-built versions.
Last 5 minutes of every session: one paragraph: what you built, what surprised you. The log feeds four blog posts; the posts are the public proof that separates "used AI" from "understands agents" on your next application.
| MON–FRI | 1 hr/day hands-on building, AI-as-tutor. Keyboard time only. | 5.0 h |
| WEEKEND | One contiguous block for the week's project milestone. | 2–3 h |
| PASSIVE | Videos and reading: commute, lunch, gym. Building is never passive time. | 2–3 h |
| FRI ×15M | Week review: did the demoable artifact land? Update the log. | 0.25 h |
Less time available? Stretch to four months. Don't compress the by-hand builds; they're the entire point.
DoGet an API key (Anthropic or OpenAI; the curriculum uses Anthropic's docs, everything transfers). Pick your language: TypeScript or Python, whichever you ship production code in. Set up a fresh repo per project; everything you build here is public portfolio.
CheckIf you can't yet explain what a token is, what a context window is, or why the same prompt gives different outputs: good, that's Week 1. If you've never used an AI coding assistant seriously, spend Week 0 doing real work with one; the curriculum assumes that fluency.
PythonThe AI ecosystem is Python-first: most of the courses, eval tools, and example code in these thirteen weeks assume it. Build in whichever language you ship production code in, but if that's TypeScript, expect to read Python from Week 1 and write some by Month 2; the syntax is a weekend for a senior engineer, so the real check is tooling (uv or pip+venv, a notebook, pydantic). Doing the Week 5–6 eval harness in Python is the natural place to make it stick, and it's still the language most AI job listings ask for.
Everything raw: no SDK, no framework. Model-level literacy included, so tokenization, context windows, and sampling questions never rattle you in an interview.
ReadAnthropic Messages API + streaming docs · Anthropic Academy's free Building with the Claude API as the reference track for Weeks 1–2.
WatchKarpathy: Intro to Large Language Models (1 h), Deep Dive into LLMs like ChatGPT (3.5 h; one pass, vocabulary not math) · 3Blue1Brown's neural-network chapters on transformers & attention.
BuildA CLI chat loop with raw fetch: messages array, system prompt, streaming, token counting, cost-per-call accounting. Every line yours, no SDK.
ReadAnthropic's Building Effective Agents, the most important read of the curriculum (workflows vs agents, and when not to build an agent), plus Writing effective tools for agents and the tool-use docs.
BuildAdd tool use by hand: JSON-schema tool definitions in a domain you can already reason about (chain balances, DEX rates, your product's API; familiarity keeps the focus on the loop, not the tools). Parse tool-use blocks, execute, return results, loop until the model stops asking. Handle hallucinated tool names, malformed arguments, and tool errors yourself.
ReadThe modelcontextprotocol.io spec; it's short. SDK source when stuck; reading source counts.
CourseAnthropic Academy Introduction to MCP (free; Advanced Topics as reference) · DeepLearning.AI MCP with Anthropic for a second angle.
BuildA minimal MCP server from the spec: no generator, no template. Expose 2–3 tools over stdio for something real from your own world (a protocol you know, an API you own). Connect it to an MCP client and watch your own server get called. Public repo.
ReadAnthropic'scontext-engineering post · embeddings docs · one solid piece on chunking, hybrid retrieval, and reranking; that's the job-description vocabulary.
BuildExtend the Week-2 agent: summarization when history grows, a scratchpad the agent reads/writes, then minimal RAG: raw embeddings API, cosine similarity by hand, top-k into context. Add a vector store (pgvector is fine) only after the by-hand version works, so you can say exactly what the DB adds.
Post 1"An agent is a while loop": what building the loop raw taught you.
What separates hireable agent engineers from demo-builders. Evals get two full weeks; they're the #1 screening topic in interviews.
ReadHamel Husain's evals FAQ, the field's reference document · Anthropic's Demystifying evals for AI agents. Optional flagship spend: Hamel & Shreya's AI Evals for Engineers & PMs on Maven, the one paid course in this space worth real money, if a cohort lines up.
CourseDeepLearning.AI Evaluating AI Agents (free, short).
BuildRun your agent on ~30 varied inputs, save every trace, and open-code them by hand: read each one, note what went wrong, cluster the failures into a taxonomy. "Look at your data" is the core of the craft.
Build20–50 task cases drawn from your Week-5 failures (grow the suite toward 100+ by the capstone) with expected outcomes; programmatic checks where possible; LLM-as-judge with a written rubric where not, calibrated against your Week-5 labels; pass/fail report wired into CI. Break the agent deliberately; watch the harness catch it.
Post 2"How I know my agent actually worked": error analysis → taxonomy → harness.
ReadOpenAI's A practical guide to building agents (guardrails) ·Simon Willison on prompt injection and the lethal trifecta, then keep following that blog. Skim the OWASP Top 10 for Agentic Applications and write a one-page threat model for your own agent; publishing it is portfolio material almost no candidate has.
BuildRetries with backoff, timeouts, per-run cost caps, cost-per-task and latency tracking, structured decision logging, dry-run mode, kill switch, tracing (Langfuse is a good open-source default). Then attack your own agent: prompt injection through tool results and retrieved docs. Write down what got through and what the mitigations cost.
Read12-Factor Agents (HumanLayer) · a real agent framework's source. Passive this month: Chip Huyen's AI Engineering as the term's textbook, including finetuning-as-literacy: know when SFT/DPO is and isn't the answer; you don't need to train models.
CourseLangChain Academy Intro to LangGraph (free) · Hugging Face Agents Course as skim-reference.
BuildRebuild your Week-2 agent twice: once in LangGraph, once with the Claude Agent SDK (or OpenAI's Agents SDK). Log the comparison: what each does that your raw loop doesn't, what yours does that they don't, when you'd choose each.
Toy demos don't survive interviews. Your capstone is an agent that operates somewhere real, with evals, guardrails, and observability, built with everything from Weeks 1–8.
Kept is a marketplace for hiring AI agents for verifiable work: criteria signed by both sides, payment secured at signing, delivery fingerprinted, disputes settled per criterion. That makes it a near-perfect capstone arena: your agent takes on a real job, does real work, and gets verified and paid against agreed results, not just believed. Design the eval suite first, choose your orchestration shape deliberately (probably a workflow with one agentic step; be ready to defend it), then ship with tracing, cost caps, and a kill switch.
MCP server: shipping soon The Kept MCP server (jobs, criteria, dispute status, agent participation) is being built in public as part of this curriculum's own capstone. Until it's linked here, run the alternative below; the skills are identical.
Alternative capstone: rebuild one AI component of a product you own or work on, production-grade, or build an agent against any real external system with verifiable outcomes (a testnet protocol, a public API with ground truth). The bar is the same: real stakes, evals in CI, deployed behind a flag, a 3-minute demo video.
BuildThe spec before the build: the agent's job, tools, state, failure modes, guardrails, and the eval suite first. Read Anthropic's multi-agent research post; watch Andrew Ng's Agentic AI this month for the four-pattern vocabulary (reflection, tool use, planning, multi-agent).
BuildThe loop, tools, context handling, structured outputs. Add a multi-agent element only if the problem justifies it; a separate verifier/judge agent is the natural one.
BuildObservability, cost caps, kill switch, eval harness in CI (100+ cases by now), deploy behind a flag, record a 3-minute demo. Measure it against a non-agentic baseline and report task-completion rate and cost per completed task; "where the agent was NOT better" is interview gold. This is your interview centerpiece: a production agentic system you can explain to any depth, with numbers.
DoUpdate your CV, LinkedIn, portfolio: capstone first, then MCP server, eval harness. Build your target-company list.
Post 4The flagship: your honest before/after: what you thought agent engineering was, and what it turned out to be. (Post 3, the MCP write-up, floats between Weeks 8–10.)
DoLife happens; the buffer absorbs it. If it's not needed: two mock interviews, and, if you're crypto-native, the differentiator week: wire your agent to execute a real testnet stablecoin action with spend caps and an approval step. "Agents that move money safely" is a niche almost nobody else can claim.
The 2026 equivalent of the university essay: a public build log with working code attached. Hiring managers actually read these.
Target archetypes, best-fit first: AI Product / Applied AI Engineer at product companies adding agents: your full-stack seniority is the moat · Forward-Deployed Engineer at AI labs and agent startups: senior, customer-facing, ships fast · Agent Engineer at agent-infra startups · and if you're crypto-native, the wedge: AI roles at crypto-adjacent companies (agentic payments, stablecoin infra adding AI), where you may be the single most qualified applicant.
Interview prep is mostly done by construction: live-code an agent loop from a blank file in under 30 minutes (you'll have done it many times); agentic system design (tools, context, evals, guardrails, cost, failure modes): your Weeks 5–7 material is the rubric; LLM-literacy questions are Week 1. And never bluff: "here's what I've built, here's the depth I have, here's how fast I closed the last gap, publicly" is the strongest answer available to anyone.