Agent Engineer: a lesson-by-lesson course for software engineers who want to build AI agents

What Agent Engineer actually is, and the reader it assumes

This is a course, not a library. The repository is a set of 19 lesson directories, numbered 01 through 19, each with its own README, plus a top-level README that acts as the syllabus. There is no package to install, no CLI, and no runtime. The README states the audience plainly: software engineers who want to understand what AI agents are, how they work, and how to build them, with no prior AI/ML experience required beyond curiosity and some Python knowledge. The prerequisites list is short and concrete: basic Python (functions, classes, HTTP requests), a Google Cloud account with a free trial link, and familiarity with REST APIs and JSON. If you have shipped a backend service and have never touched a model API, you are the intended reader. If you are already running agents in production, the 101 material will be revision and the 301 material is where the value sits.

The three-part split is the organising idea. Part 1, lessons 01 to 10, is described as platform-agnostic and focused on building a mental model. Part 2, lessons 11 to 14, moves to Google Cloud AI, Vertex AI, and the Agent Development Kit. Part 3, lessons 15 to 19, covers narrower topics: AGENTS.md, MCP internals, agent skills, orchestrators, and where to go next.

How the course is structured: concepts in the repo, code behind links

The mechanism is editorial rather than technical. Each lesson directory holds a README that explains a concept, and the README states that the course links out to official docs, codelabs, and tutorials for hands-on practice rather than duplicating API docs or code samples that go stale. That is a real design decision with a real cost: the repository itself contains prose, and the runnable material lives on Google's documentation sites.

The lesson list shows how the parts connect. Lesson 03 covers function calling and tool design. Lesson 04 covers ReAct, reflection, and planning. Lesson 05 covers sessions, context windows, and long-term memory. Lesson 08 covers agentic RAG, described as going beyond basic retrieval to agents that search, evaluate, and refine. Lesson 09 is about evals, metrics, and observability, and lesson 10 covers guardrails, security, alignment, and responsible AI. Part 2 then applies those ideas: lesson 12 introduces the Google Cloud AI stack, lesson 13 is the hands-on first agent with ADK, and lesson 14 covers MCP and A2A as the protocols agents use to talk to tools and to each other.

The stated philosophy is worth reading before you judge the format. The README lists four principles: analogies first, fundamentals over frameworks, link rather than duplicate, and being honest about trade-offs. The third principle is the one that shapes the whole repository. A course that explains ReAct in its own words and sends you elsewhere for the implementation stays accurate for longer, but it cannot be read on a plane.

Reading order, jumping around, and what the README says about each

The README gives two usage modes. Read in order if you are new to agents, because each lesson builds on the previous one. Jump around if you already know the basics, because each lesson is described as self-contained enough to read on its own.

Those two claims pull against each other, and the README does not resolve the tension. A lesson on multi-agent systems assumes you understand tool calling and memory; a lesson on orchestrators assumes you have a view on control flow. The practical read is that the 101 track rewards sequence and the 301 track rewards selection. If you already write tool-calling code, starting at lesson 11 or 12 and working forward is defensible. If you cannot explain what a context window does to a planning loop, start at 01.

The repository has no releases, and the last push was on 2026-07-16. That is a recent edit, and the project is not archived, but a course repository has a different failure mode from a library: the prose does not break, the outbound links do. Lessons that point at Vertex AI docs, ADK docs, and codelabs are only as current as those destinations.

Installing Agent Engineer and reading your first lesson

There is nothing to install. The README gives no package, no CLI, and no setup command, because the project ships prose. The way to get it is to clone the repository and open the lesson READMEs, or to read the same files on the hosting site.

The only setup step the README describes is for the hands-on part, and it is account-level rather than code-level: a Google Cloud account, with a free trial link in the prerequisites. The build lessons then point at the Vertex AI and ADK documentation for the actual commands.

git clone https://github.com/addyosmani/agent-engineer.git
cd agent-engineer
ls

After cloning you should see the lesson directories 01 through 19 alongside CONTRIBUTING.md, LICENSE, and README.md. Open the top-level README first; it is the syllabus and the table of contents in one file.

cat README.md
cat 13-building-your-first-agent/README.md

The second command is the one to run if you want to judge the course quickly. Lesson 13 is described as building a working agent with ADK step by step. Read it and follow its outbound links; the README for the course states that setup instructions and code samples live in the official Google Cloud docs and codelabs rather than in this repository. If those links resolve and the ADK documentation matches what lesson 13 describes, the course is usable today. If they do not, you have found the boundary of what this repository maintains.

Where Agent Engineer is the wrong tool

The link-don't-duplicate principle has a sharp edge. If you want a repository you can clone and run end to end, this is not it. There are no exercises with expected outputs, no test fixtures, no sample agent checked in, and no offline path. Every hands-on step depends on a network connection and on documentation that the course does not control. A reader who learns by typing code will spend most of their time on Google's sites, not in this repository.

The vendor concentration is the second limit. Part 1 is platform-agnostic, but Part 2 is explicitly built on Google Cloud AI, Vertex AI, and ADK. If your stack is elsewhere, lessons 12 through 14 are a tour of someone else's toolchain. The concepts still transfer; the commands do not.

The third limit is currency. The README says the course links out to maintained resources rather than duplicating samples that go stale. That keeps the prose honest but makes link rot the failure mode. A lesson on MCP or A2A describes protocols that move faster than a course repository is edited, and the last push was on 2026-07-16. Nothing in the repository verifies that its outbound links still work.

Agent Engineer against a build-it-yourself path through the ADK docs

The obvious alternative is to skip the course and read the Agent Development Kit documentation and the Vertex AI documentation directly. Those are the resources this course links to for code, so the difference is not access to information but the order and framing of it.

Going straight to the ADK docs gets you to a working agent faster. You follow the quickstart, you get a running example, and you learn the API surface by using it. What you do not get is the reasoning about when an agent is the right shape for a problem at all, which is what lesson 01 covers, or the material on evals, guardrails, and multi-agent coordination that sits in lessons 07 through 10. Those lessons are the part of the course that a quickstart cannot replace, because a quickstart assumes you have already decided to build an agent.

The reverse trade is also real. The course will not teach you the ADK API. It teaches the mental model and then hands you off. If your goal is a deployed agent by Friday, the docs alone are the shorter path. If your goal is to be able to argue about whether a planning loop or a reflection step belongs in a given system, the 101 track is the part worth the time.

Maintenance, upgrade cost, and the Apache-2.0 licence

The repository is licensed under Apache-2.0, with the LICENSE file at the top level and the README pointing to it. For a course, the practical implication is that you can reuse and adapt the written lessons, including in internal training material, subject to the terms of that licence. This is not legal advice; read LICENSE and CONTRIBUTING.md if you plan to redistribute or build on the text.

Upgrade cost is unusual here because there is no dependency graph. You never run a package manager, so nothing breaks on a version bump. The maintenance surface is the outbound links and the accuracy of the prose against the current Vertex AI and ADK behaviour. The README states the intent behind that design: pointing to official docs keeps the content focused and ensures readers see up-to-date information. The cost is that the course cannot warn you when a linked page changes underneath it.

Contributions are accepted. The README says PRs and issues are welcome and points to CONTRIBUTING.md for guidelines. The last push was on 2026-07-16, and the project is not archived, so the repository is being edited, but the README does not document a review cadence for the outbound links.

Editorial conclusion

Adopt Agent Engineer if you are a working software engineer who wants the mental model before the framework, and you are willing to follow its links into Google Cloud codelabs for anything hands-on. Skip it if you want a runnable sample repository, offline exercises, or a vendor-neutral build track, because the course deliberately links out rather than shipping code, and Part 2 assumes a Google Cloud account. Before committing, open lesson 13 and the CONTRIBUTING.md file and check that the linked ADK and Vertex AI pages still resolve; the README states that links are used instead of duplicated code samples precisely because samples go stale.

Frequently asked questions

Official sources

1. addyosmani/agent-engineer on GitHub
2. Issues
3. License: Apache-2.0
4. README