Agentic Engineering Handbook

The definitive OpenAI, Anthropic, Google, MCP, Harness, Evals, and Production Agent Systems learning roadmap.

If this repository helps you, consider giving it a ⭐

Why This Repository?

The AI industry has entered the Agentic Era. Building production-grade AI systems now requires mastering agents, tool use, MCP, memory, long-running workflows, coding agents, agent harnesses, evals, and safety — but the knowledge is scattered across OpenAI blogs, Anthropic engineering posts, SDK docs, cookbooks, and research papers.

This repository consolidates 215 curated resources into one structured learning roadmap.

The goal: Become a world-class Agentic Engineer.

How To Use This Handbook

Pick the path that matches your starting point:

• New to agents: follow the Learning Roadmap through the core Phases 0–6, then continue to Phase 7 for advanced coursework. Treat each Read First, Then Read, and Build Exercise as a checklist.
• Already building LLM apps: start at Phase 2 or Phase 3, then fill gaps in agent loop, tool calling, evals, and production engineering.
• Trying to build projects: use the phase-level Build Exercise prompts, then branch into Applied Practice Tracks for coding agents, security, code review, or SRE.
• Looking for references: jump to the Full Reading Table. Read P0 first, use P1 for implementation detail, and keep P2 as optional background.

AI Engineering Skills Map

Start with Andrew Ng's The AI Engineering Skills Map (P0) for a broader view of the skills behind this roadmap. It identifies four areas; the connections below are this handbook's interpretation.

For each project, define the user problem and success criteria, choose an appropriate scope, then use implementation and evaluation to test those decisions.

Learning Roadmap

Phase 0 — Agent Loop From Scratch

If you treat Claude Code as a coding CLI, many capabilities can feel like magic: it reads files, runs commands, edits code, delegates work, and stays oriented during complex tasks.

From an engineering perspective, the core is much simpler:

model + tools + one loop.

Understanding that loop makes the rest of the system easier to reason about:

• When the agent should plan first, and when it should act immediately
• Why an explicit todo list reduces drift in longer tasks
• Why subagents improve exploration while protecting the main context
• How skills, MCP, and hooks each add capability around the same core loop

These pages are based on the upstream English Markdown tutorials from shareAI-lab/mini-claude-code, with added Study Notes and inline source code for this handbook.

Supporting files are included in the same folder: requirements.txt, .env.example, v0_bash_agent_mini.py, and skills/.

Next reference: minion.py is a compact, single-file coding agent worth reading after this lab. It shows how an OpenAI-compatible agent loop grows to include tool calls, sessions, resume, approvals, memory, and context compaction.

Phase 1 — Agent Foundations

Build shared vocabulary for workflow vs agent, tool loop, handoff, guardrails.

Key Mental Models

Why agents matter: AI as leverage

What if your impact could grow without every new result requiring another hour of your work? In his Cornell lecture, Hyung Won Chung uses leverage—getting more output from a given input—to explain the opportunity. Drawing on Naval Ravikant's framework, he groups leverage into human labor, capital, and code/media:

AI agents combine human labor and code leverage: they can perform delegated work while running as software that can be replicated. Chung connects this to individuals and small teams doing more, lower barriers to learning, and AI helping synthesize knowledge for scientific progress. The engineering opportunity is to turn that potential into reliable work through tools, state, verification, and recovery.

Start with your own bottleneck: Which recurring task could you delegate, reuse across projects, or make available to more people? Use that task as a candidate for the agent you build in this roadmap.

Source: Hyung Won Chung (OpenAI) — Cornell AI history lecture.

Should I build an agent? (4-question checklist from Barry Zhang's talk - Anthropic)

Think like the agent. Most failures come from designing with a human perspective. Put yourself inside the agent's context window: you only see ~10K–20K tokens (system prompt + tool descriptions + recent observations). Ask: does the agent have enough information to act correctly at each step?

→ Source: How We Build Effective Agents

Read First

Then Read