Skip to content

Agentic Engineering — Operate AI Like a Tech Lead

An AI coding agent can now write, test, and ship real code. The open question is no longer whether it can, but whether the engineer driving it can do so well. This site covers that craft: how to give an agent the right context, specify work it can execute, verify output you did not write, and coordinate several agents at once without losing control. It does not explain what a large language model is; it covers how experienced engineers operate one.

Who it is for: engineers who already ship code and want to operate agents at a senior level — individual contributors and the engineering leaders bringing agents to their teams — rather than beginners or researchers. What you bring: a terminal, an AI coding agent, and a real codebase. Time: the core path takes about a weekend of focused work; the full curriculum takes a couple of weeks of practice.

The course is written by a former senior director at Meta and Snapchat who has helped engineering teams become AI-native; the About page covers why it exists and what you will take away.

What you will be able to do

After the core ramp, you should be able to start an agent cold in a repository, give it a useful project instruction file, turn a vague request into a checkable spec, and verify the result with tests, evals, and a gate. Proof comes from the artifact trail you leave behind: a sharper CLAUDE.md, a spec, a red test driven green, and a guardrail that catches the bug when it comes back.

How you'll learn

Every lesson is a loop you can run alone, with no instructor and no live class:

  1. Concept — a short read in plain English.
  2. Guided Lab — a concrete action you run in your terminal.
  3. Keep the artifact — the reusable thing the lesson leaves in your toolbox.
  4. Self-check — "you did it right if…". Built Practice Repo slices have known answers; pending slices are marked in the repo map.
  5. Recall — commit to an answer before you move on.

Each exercise can be run on the Practice Repo or on your own codebase. The Practice Repo is the guided path: built slices give you ground truth, tests, answer keys, and coached skills where they exist. Your own codebase is where you apply the same operator move to real work.

The path

The lessons are ordered to read top to bottom, from "I use autocomplete" to "I run a team of agents." The left nav follows that order, and the Next button walks it.

  1. Foundations — the operator's model. The Agent Loop: what an agent actually does, where it predictably fails, and how to read its moves.
  2. The core craft — drive an agent well. The three skills every task reuses: Context Engineering → Specification → Verification & Guardrails.
  3. Extending and scaling — multiply yourself. Shape the agent's harness, then run more than one: Shaping the Agent Harness → Orchestration.
  4. Integration and judgment — make it pay off. Fit agents into real work and understand the limits: Compound Engineering → Judgment & Economics.
  5. Capstone. Drive a Real Change end-to-end on your own repo, against a rubric.

If you are short on time, Modules 0–3 are a complete ramp-up on their own: the operator's model plus the three core skills. The remaining modules cover how to scale agents and where the practice compounds.

Start here

Start with The Agent Loop, then follow the core ramp through Context Engineering, Specification, and Verification. That path is the public walkthrough of the course's central loop: context → spec → verification → durable artifact. The Practice Repo page shows which module slices are built and what feedback each one gives you.

What makes this different

Most AI content focuses on the next tool to adopt. This site covers a part that is usually left out: when not to use one. The verification and judgment modules — trusting output you did not write, and honest cost math — are the skill this course is built around. That is the focus of The Pragmatic AI Engineer, applied to your own work.