A 12-minute orientation to the Agent Engineering skill path — primitives for tool use, memory, skills, retrieval, and failure recovery

Build the smallest possible agent — one model, one tool, one memory slot — and see exactly what makes the loop tick

Tool use, ReAct loops, multi-agent orchestration, and guardrails for reliable agent systems

Design memory systems that give AI agents continuity across sessions

Connect Claude to your tools using the Model Context Protocol

Master the art and science of building Agent Skills — reusable instruction packages that teach AI agents your workflows

Build agents that plan, retrieve, self-correct, and route across knowledge sources

Build agents that survive tool failures, runaway loops, and cascading errors — with retry, circuit breakers, and human escalation

A 12-minute orientation to the Agent Infrastructure skill path — the substrate beneath production agents and the two protocols you have to get right

Build agents that talk to other agents — A2A, signed agent cards, secure delegation, and multi-framework bridges

Pick the right isolation primitive — E2B, Modal, or Daytona — for agents that run untrusted code

A 12-minute orientation to the Agent Frameworks skill path — what each chapter teaches, how they relate, and where to start

Navigate the API-to-agent stack across OpenAI and Anthropic — understand the layers before you build

Master both the Responses API and Chat Completions — understand when to use each and how to migrate

Master the Messages API, tool use, extended thinking, and prompt caching — build with Claude from first principles

Build multi-agent systems with guardrails, handoffs, and tracing — OpenAI's framework for autonomous AI

Build autonomous agents with Anthropic's framework — the same engine that powers Claude Code, as a library you control

Ship multi-agent systems that integrate with real tools, scale in containers, and verify their own work

Mock tools, trace decisions, build golden datasets, and run agent tests in CI/CD — testing for non-deterministic AI systems

Read, debug, and ship across LangGraph, CrewAI, and AutoGen — the three frameworks you'll meet in customer code

Boot the Anchorwell data lab, a DuckDB warehouse with dbt and Dagster already running, and see how the path's six chapters connect before you touch your own stack.

The dbt workflow where an AI agent drafts and you decide what actually ships to production.

Write the pipeline spec, drive an agent to build the DAG, and harden it with the retries and idempotency it won't add on its own.

Turn an agent's noisy first-pass checks into the few that actually stop a bad load.

Drive an agent through Dagster's run history and check results to find, verify, and fix what actually broke.

Auto-generate column docs and lineage notes with an agent, review them like any other agent draft, then write down one metric definition everyone can point to.

Triage a warehouse's query history with an agent, then prove one fix with real before and after numbers.

Six chapters that take an open-weight checkpoint from a fine-tuning decision to a served adapter with a rollback plan.

A decision tree for when fine-tuning earns its cost, and the lab you'll use to prove it on your own task.

Turning a pile of scraped examples into the few hundred curated, deduplicated, and licensed rows actually worth training on.

Sizing the adapter to the task, sizing the GPU to the adapter, and picking the checkpoint that actually generalizes.

Turning a frontier model's judgment into training signal for your open model, without crossing the line its terms of service draws.

Turning a single passing score into a before/after harness, a capability drift set, and a ship/no-ship gate anyone else could rerun.

Turning a checkpoint that passed the gate into a live adapter with a name, a canary, and a rollback plan.

Watch an agent fail against a raw mock API, then see the six-stage build that turns any internal API into one an agent can trust.

Build a working stdio server around a real API and connect it to your coding agent in under 25 minutes.

Turn a working tool surface into one an agent stops misusing, with a written spec and evals to prove it.

Resource metadata, PKCE, and token validation done the way the current MCP spec actually requires, not the way a tutorial from last year shows it.

Give every agent call a name, a scope, and a trail, so who told the agent to do that has a one-line answer.

Move the server off your laptop and onto infrastructure that scales, under the stateless deployment model the spec adopted in July 2026.

A three-layer test pyramid, from tool-handler unit tests to real agents proving they call the right tool.

Ship a breaking change to a tool surface without breaking every agent mid-task, using a registry entry and a deprecation clock.

A 12-minute orientation to the On-Device & Edge AI skill path — the three platforms where your model can run without a cloud round-trip, and how to pick yours

Ship a capable ~3B LLM inside your iOS app — guided generation, tool calling, and when to still reach for Claude

Ship on-device AI to 140M+ Android devices — AICore as a shared system service, ML Kit GenAI APIs, and Gemma 4 agentic intelligence

Run arbitrary open models on your Mac — unified memory, JANG quantization, Ollama + MLX, and the honest limits of a single-user inference node

A 12-minute orientation to the Specialized Agents skill path — four agent archetypes, when to pick each, and what makes them fail

Master the plan-execute-synthesize archetype behind ChatGPT, Gemini, Perplexity, and Claude deep research — and know when not to use it

Build AI agents that see, click, and control desktop environments

Real-time voice agents — streaming audio, turn-taking, telephony, and emotion-aware delivery

Architect always-on agents that run on cron schedules, fire on webhooks, and execute autonomously with human gates