Starting the AI path · quick study guide
Your first map of the AI path
New to AI and not sure where to begin? Four starter PDFs, read in order. Start with the map: where AI work is heading, and what changes as AI goes from suggesting code to running whole workflows. Then learn the tools you'll use on day one, what an agent really is, and how to build one properly. Each stop below condenses one PDF into key takeaways, a glossary and self-check questions, and links to the full PDF.
The route: four stops, in this order
-
1Read first The map · 57 pages
Start Here: The Autonomy Line
The big picture. It follows AI from a coding assistant that suggests a line to agents running whole workflows, across five stations. It gives you the vocabulary, and shows where every skill in stops 2–4 fits.
How to read: all of it (~111 min), or pp. 2–10 and the station summaries if you're short on time.AssistDelegateIntegrateAutomateOrchestrate -
2Use the tools · 28 pages
AI Coding Assistants
You, working with AI. Four assistants (Claude Code, Gemini CLI, Gemini Code Assist and Cursor), and the habits that make any of them productive: context, plan, review, undo.
How to read: cover to cover, with an assistant open. Try each chapter as you go.AssistDelegateIntegrateAutomateOrchestrate -
3Understand agents · 20 pages
Agents Starter
What an agent is and isn't, why agents became possible now, when not to use one, and the seven building blocks. It is the orientation chapter for stop 4.
How to read: cover to cover. It's short, and everything after it assumes it.AssistDelegateIntegrateAutomateOrchestrate -
4Build them properly · 189 pages
AI Agent Engineering
The whole agents course as an interview study guide: 28 modules, from tokens and prompts to RAG, guardrails, evals, tracing, cost and deployment.
How to read: look at the visual guide first (11 diagrams, an eval rubric, 30 flash cards). Then use the PDF as a reference, one track at a time, and come back to both before interviews.AssistDelegateIntegrateAutomateOrchestrate
The station chips show which part of the Autonomy Line each PDF prepares you for. No prior AI experience is assumed. Some programming helps from stop 2, and is expected by stop 4.
01
Start Here: The Autonomy Line
The map · read first · nine stops, ~111 minutes · written for leaders, and just as useful when you are starting out
AI coding tools and business agents are not two projects. They are one line with five stations, along which autonomy (how much the AI does before a person looks) and reach (how much of the business it touches) rise together. One fictional composite, Alderline Health (14,000 people, 1,600 engineers), runs through every station.
Why this comes first. It is written for the leaders who fund AI work, and that is exactly why it helps a newcomer. It shows what the organisation you will join is trying to do, what each step of AI adoption asks of people, and the words everyone uses. Read each station as a description of the work, and notice which one excites you. Stops 2–4 teach the skills behind them.
Autonomy is granted in proportion to the controls and the evidence you have, never in proportion to the excitement.
The five stations
| Station | In one line | People act as | Earn the next step with |
|---|---|---|---|
| 1 · Assist | AI suggests. People do the work. | Authors | An approved tool, a one-page use policy, SSO and telemetry, and a baseline |
| 2 · Delegate | People hand over whole tasks and review the result. | Directors, reviewers | A context file, task briefs, tests as the contract, and no prod credentials |
| 3 · Integrate | AI joins the pipeline on a shared platform. | System designers | A paved road, one gateway for every model call, and evals |
| 4 · Automate | Agents run bounded business workflows. | Supervisors | A written autonomy boundary and the trust ladder |
| 5 · Orchestrate | Many agents coordinate across functions. | Governors | An agent registry, identity, one control plane, MCP + A2A |
Four tracks run under the whole line: Platform, Guardrails, People, Value. The train can only go as far as the shortest track.
Key takeaways
The approach pp. 5–10
- Start in engineering, where the work checks itself: code compiles, and tests pass or fail.
- An agent has five parts: model, context, tools, loop and guardrails. Everyone can rent the same model.
- Engineering habits have business twins. The context file becomes written policies, CI becomes evals, PR review becomes human approval, and revert becomes a kill switch.
Assist & Delegate pp. 11–19
- The safety test is whether the engineer can judge if the answer is right.
- Don't count lines of code or acceptance rates, because they measure typing. Budget for the J-curve dip.
- The job becomes specify, delegate, verify, review. The most important line in a brief is stop and ask.
- Review is the new bottleneck, and DORA calls its cost the “verification tax.”
- “An instruction is not a control.” If an agent must never do something, make it impossible.
Integrate & Automate pp. 20–34
- Speeding up one step only moves the queue. Put AI at every step, from plan to operate.
- Build the paved road. If governance acts as a slow gate, people bypass it.
- Use the least autonomy that works: rules first, then a workflow with AI steps, then an agent.
- Climb the trust ladder: Shadow → Assist → Approve each → Sample. Promotion is decided on data and demotion is automatic.
- “If a team cannot show you evaluation results, they do not have an agent. They have a demo.”
Orchestrate & running the railway pp. 35–52
- Reliability multiplies: 95% per step over ten steps comes to about 60%. Keep chains short.
- Manage agents like employees: registry, identity, owner, evals, budget, exit.
- Seven controls carry most of the weight, from least privilege to a kill switch with a fallback.
- Treat everything an agent reads as untrusted, because of prompt injection.
- Measure activity, flow and outcome, and count all five costs, including review.
What the evidence says
90%
of tech professionals use AI at work, and 30% trust its output little or not at all
DORA, 2025
19% slower
measured for experienced developers who believed they were 20% faster
METR, 2025 (2026 update: speedups, wide error bars)
80 / 37 / 6
% who say AI helps them / orgs seeing any profit effect / orgs seeing a large one
McKinsey, Aug 2026
40%+
of agentic AI projects predicted to be cancelled by the end of 2027
Gartner, Jun 2025
7%
of companies run a fully autonomous agent in production, and 38% need a person to approve every decision
Bain, Jun 2026
~1 in 5
firms report using AI at all when surveyed by random sample
US Census Bureau BTOS, May 2026
The Alderline figures (Java 8 → 21 across 40 services in ten weeks, $0.40 per case) illustrate the pattern and are not benchmarks. The PDF attributes every statistic in the sentence that uses it and lists sources on pp. 56–57.
Glossary
- Context file
- A plain-text file in the repo, often AGENTS.md, telling agents how the codebase works and what not to touch.
- Evaluation (eval)
- A scored test set for AI behaviour, “the unit test of agents.”
- Gateway
- One front door for every model call: identity, policy, logging, redaction, spend limits and routing.
- Guardrail
- A limit the system enforces, as opposed to one requested in a prompt.
- Human in / on the loop
- “In” means a person approves each action. “On” means a person monitors, samples and can stop the agent.
- Paved road
- The easy, safe, default shared platform for building with AI.
- Shadow mode
- The agent runs on real work, but its output is only compared with what people did.
- Trust ladder
- Shadow → Assist → Approve each → Sample, the rungs by which autonomy is earned.
- Verification tax
- The extra effort of checking that generated code is correct, secure and fits the architecture (DORA 2026).
- Prompt injection
- Instructions hidden in content an agent reads, planted by someone who wants to hijack it.
Self-check
What two dimensions define the line?
Autonomy (how much the AI does before a person looks) and reach (how much of the business it touches).
Name the four tracks and the rule about them.
Platform, Guardrails, People and Value. The train can only go as far as the shortest track.
Which line in a task brief matters most, and why?
“Stop and ask” if a test's expected value must change, because that means behaviour changed and a person must decide.
What is the new bottleneck at Station 2?
Review. DORA calls its cost the verification tax.
Name the four rungs of the trust ladder.
Shadow, Assist, Approve each and Sample. Promotion is decided on data and demotion is automatic.
Why do long multi-agent chains disappoint?
Reliability multiplies: ten steps at 95% each finish cleanly only about 60% of the time.
02
Coding with four robots, one terminal
A Beginner's Study Guide · 18 chapters over three days · for developers new to AI coding tools
A plain-English tour of four assistants: Claude Code, Gemini CLI, Gemini Code Assist and Cursor. The claim is that results come from a few habits, not from the tool: give context, plan before acting, review every change, and keep a human in the loop. Commands will change, and these habits won't.
On the line: Stations 1–2. Assist and Delegate, from your own chair. These are the everyday habits every later station assumes you already have.
“You don't pick the best tool. You pick the right tool for what you're doing right now.”
Meet the cast
| Tool | Role | Where it lives | Best for |
|---|---|---|---|
| Gemini Code Assist | Workshop helper | IDE plugin (VS Code, IntelliJ) | Google Cloud teams, inline suggestions |
| Cursor | Full-time co-worker | Full IDE (VS Code fork) | AI-first editing, from autocomplete to whole features |
| Gemini CLI | Terminal generalist | Terminal | Free to start, fast, scripting |
| Claude Code | Terminal specialist | Terminal | Careful planning, messy multi-file work |
Most developers pair one IDE-based tool with one terminal-based tool.
Key takeaways
Day one: the everyday jobs ch. 01–06
- Cursor's four modes sit on an autonomy slider: Tab, Inline Edit (Cmd/Ctrl+K), Composer (Cmd/Ctrl+I, multi-file) and Agent Mode.
- Being specific in the prompt is “the cheapest upgrade you'll ever buy.”
- You can ask for understanding at three levels: explain a file, walk through a function, or trace a concept across files.
- Diagnose first. Ask for the cause before the fix, then the smallest fix, and read it before approving.
- Treat AI-written tests as coming from “a smart but distracted junior developer”: they are a starting point.
Day two: the terminal and control ch. 07–12
- Start with
claudeorgeminiin the project folder.@filepoints at a file and!runs a shell command. - A project memory file fixes most bad decisions:
CLAUDE.md,GEMINI.mdor.cursor/rules/. - Plan Mode means “don't change anything yet, just tell me what you'd do.” Skip it only for tiny changes.
- Run Agent Mode or Auto Mode on a feature branch, never on main.
- Spend 30 seconds on every diff. Look for surprise files, unknown imports, deleted code, and logic hidden inside renames.
- Commit first. Gemini CLI can also roll back with
/restorecheckpoints.
Day three: going further ch. 13–18
- Subagents work in their own context and report back. Use them when the main thread gets cluttered.
- MCP connects the assistant to GitHub, Jira, Slack and databases, turning a helper into a teammate who can see your work.
- “Subagents are who does the work. Skills are how the work should be done.”
- CLAUDE.md is always loaded. A skill loads only when its
descriptionmatches the task. - Spec → Plan → Build: treat the AI like a contractor that needs blueprints.
- Capstone: Explore → Plan → Code → Test → Commit. Most failures come from skipping planning, review or context.
Glossary
- CLAUDE.md / GEMINI.md
- A root file the AI reads every session: your stack, conventions and rules.
- Plan Mode
- The AI writes a plan, you approve or edit it, and then it executes.
- Agent Mode
- The AI does multi-step work on its own, calling tools and editing files to reach a goal.
- Auto Mode
- Claude Code's middle ground: safe actions run automatically and risky ones pause.
- Composer
- Cursor's multi-file editor. You approve its coordinated diff file by file.
- Subagent
- A mini-AI with its own context window that handles one job and reports back.
- SKILL.md
- A reusable instruction bundle. Its YAML frontmatter
descriptionis the trigger. - MCP
- Model Context Protocol, the plumbing that connects AI tools to external systems.
- Checkpoint
- Gemini CLI's snapshot of the project before a change.
- Context window
- How much the AI can “see” at once.
Self-check
Which tools are IDE-based and which are terminal-based?
IDE-based: Gemini Code Assist and Cursor. Terminal-based: Claude Code and Gemini CLI.
Why “diagnose first” when debugging?
You learn what went wrong, and you catch a wrong diagnosis before it rewrites your code.
The AI keeps making bad decisions. What is the usual fix?
More context, starting with a project memory file such as CLAUDE.md or GEMINI.md.
When is it fine to skip Plan Mode?
For tiny, low-risk changes, such as renaming a variable.
Which safety habit goes with Agent or Auto Mode?
Work on a feature branch rather than main, and commit before any big session.
How does CLAUDE.md differ from a SKILL.md?
CLAUDE.md is always loaded. A skill loads only when its description matches the task.
03
Agents Starter: the map for the course
The orientation chapter · for developers who have trained models or shipped prediction APIs
An agent is an LLM plus tools plus a loop, with the LLM deciding what happens next. It does not replace your rules, ML models or APIs. It adds a reasoning layer on top of them. Use one only when judgment adds value, and treat it as production-ready only once guardrails, observability and deployment are covered. A UCC-filing lien-risk agent for “Acme Corporation” runs through the whole chapter.
On the line: Stations 3–4. This is the thing that runs inside the pipeline and then runs a bounded workflow on its own: an LLM, tools and a loop.
The litmus test: replace the LLM with hard-coded responses. If the program still works the same, it isn't an agent.
Three levels of agent-ness
| Level | What it is | Who decides what happens next |
|---|---|---|
| 1 · LLM call | One prompt, one response | Your code |
| 2 · LLM workflow | Several calls in a fixed sequence | Your code, before runtime |
| 3 · Agent | Tools + a loop + decisions based on what was found | Claude, at runtime |
Key takeaways
Why now pp. 1–4
- There are seven eras, from rule-based to frontier. Each adds a capability and removes none.
- Generative AI produces content but cannot act. Agents close that gap.
- Agents became possible through five convergences: tool-use APIs, structured output, large context, fast inference and a ~240× cost drop. The model getting smarter was not the cause.
The business case pp. 4–7
- The same ML model can ship as a script, a FastAPI wrapper or an agent. In the agent it becomes one tool among three.
- Layers 1 (infrastructure) and 2 (capabilities) stay the same. The agent adds Layer 3: reasoning.
- An agent is slower and costs more per request, but v1 is quicker to build and new question types cost almost nothing to add.
- Not for batch jobs over 1M records, responses under 100 ms, deterministic compliance, CRUD, or output nobody reads.
How it actually works pp. 8–14
- Tool use is a JSON handshake. Claude returns
tool_use, your code runs the tool and sends the result back. - Every call is stateless, so you resend the full history each time.
- “The while loop is the entire agent,” about 10–15 lines. Only the trigger changes: laptop, API, CI, cron or Slack.
- There are seven building blocks: Brain, Tools, Memory, Plan, Guardrails, Eyes, Home. Most tutorials cover only the first two.
- The lifecycle is Design → Build → Protect → Observe → Deploy, and most tutorials stop at Build.
Protocols, ethics, frameworks pp. 15–20
- MCP is vertical (agent→tools) and A2A is horizontal (agent→agent). They complement each other.
- There are five principles: HITL by design, transparency, bias awareness, scope limitation and fail-safe defaults.
- Fail open: share what you found and escalate to a human rather than blocking the user.
- Learn on the raw SDK, ship on the Agent SDK, and use A2A only across trust boundaries.
- For long-horizon coding agents, context bloat is the silent killer. Never auto-merge without an evaluator.
Numbers worth knowing
240×
cheaper per token, from GPT-3 (2022) to Claude 3 Haiku (2024)
as stated in the guide
78% → 94%
match rate after an agent replaced 200+ name-variation rules
credit-risk team example
45 min → 15 s
a manual lien check across 3 state databases vs the agent
UCC example
~$0.01–0.05
agent cost per query, vs an analyst's 30 minutes at $50–100/hr
decision-rule example
Glossary
- AI agent
- A program that uses an LLM as its decision-making brain, connects it to tools and loops until the task is done.
- Chatbot
- A program that uses an LLM for conversation: one turn, then done.
- MCP
- Anthropic's open protocol (Nov 2024) for connecting an LLM to tools, resources and prompts.
- A2A
- Agent2Agent, Google's open spec (Apr 2025, now under the Linux Foundation) for agents to discover and delegate to each other.
- Agent Card
- JSON at
/.well-known/agent.jsondescribing an agent's identity, skills and auth. It is a discovery contract. - AGNTCY / ANP
- AGNTCY is an “Internet of Agents” stack built on A2A. ANP is a decentralized, DID-based research spec.
- Fail open
- When uncertain, share what you know and defer to a human instead of blocking the user.
- Hallucination
- Output that sounds confident but is factually wrong.
Self-check
What single question separates an agent from an LLM-augmented program?
Who decides what happens next: your code, or Claude?
What three things must all be true for Level 3?
Tools, a loop, and decisions based on what Claude found. Remove any one and you drop to Level 1 or 2.
Name the five convergences that made agents possible.
Tool-use APIs, structured output, large context windows, fast inference and a ~240× cost reduction.
What happens to the existing ML model in the agent approach?
It becomes one tool among several (search_filings, predict_delinquency, get_filing_details). Layer 2 is unchanged.
Name the five lifecycle stages. Where do most tutorials stop?
Design, Build, Protect, Observe, Deploy. Most tutorials stop at Build.
What does “fail open” mean, and why is it preferred?
The agent shares what it found and escalates to a human instead of blocking. This is usually safer and more useful.
04
AI Agent Engineering: the interview study guide
A print snapshot of the course · 28 modules across 7 tracks · “sized for the night before a phone screen”
Every module follows the same template: an analogy, how it works, pseudocode or a decision framework, misconceptions and a takeaway. The thesis is that an agent is your existing stack with a reasoning layer on top, and that it is mechanical, not magical. The course moves from design through build, protect and observe to deploy.
On the line: Stations 3–5. This is the engineering behind what the map demands: the evals, guardrails, tracing, identity and cost controls that earn an agent its autonomy.
“Trust
stop_reason, never natural language.”Companion · visual study guide
See it before you read it
The 189 pages are easier after the pictures. The visual guide draws the ideas this course keeps returning to: the three levels of LLM programs, the seven building blocks, prefill vs decode, the context budget, the universal agent loop in pseudocode, the RAG pipeline, ReAct, the eight patterns ranked by cost, the guardrail stack, and the evaluation rubric: four metrics, how to write 1–5 levels, judge and A/B thresholds, and regression gates. It ends with 30 interview flash cards.
Module map
| Track | Modules | The one idea to keep |
|---|---|---|
| 0 · Foundation | M00 Overview & lifecycle · M00B Hello World | The five-step loop is the whole agent: send → check stop_reason → run the tool → append both sides → loop. Learn on the raw API, ship on the SDK, design with a spec. |
| 1 · Foundations | M01 LLM mental model · M02 Tokens · M03 Prompts · M03B Context engineering · M04 Structured output | Prefill sets TTFT and decode sets TPS, which is why prompt caching is the biggest cost lever. Put static context first and dynamic last. A cleaner window beats a bigger one. |
| 2 · Tool use | M05 Function calling · M06 Multi-tool · M07 MCP | The tool description “is the steering wheel.” Errors are messages to Claude, not exceptions. Use 4–6 tools per request. MCP turns N×M integrations into N+M. |
| 3 · Memory & context | M08 Conversation · M09 RAG · M10 Advanced RAG · M11 Multi-layer memory | The messages array is the only memory. Add hybrid search (BM25 + vector via RRF) first, and build an eval set before optimizing. Memory has three tiers: working, episodic and procedural. |
| 4 · Architectures | M12 ReAct · M13 Planning · M14 Multi-agent · M15 Code interpreter · M15B Build lab | A single ReAct agent handles 80% of tasks. Plan for goals over ~4 steps. Default to hub-and-spoke with typed handoffs. “LLM thinks, interpreter computes.” |
| 5 · Guardrails | M16 Input · M17 Output · M18 Evaluation | Cheap layers run first and fail closed. Allow, redact-with-disclosure or block, but never rewrite silently. A curated 50 beats a random 1,000, and regressions hard-gate the deploy. |
| 6 · Observability | M19 Tracing · M20 Monitoring | Use OTel-shaped spans with a trace_id, and tag every trace with prompt_version. Dashboards watch latency, cost, success and drift. Deploy canary first, then A/B. |
| 7 · Production | M21 API design · M22 Cost · M22B Deploy · M24 What's next | Stream over SSE. Past 60 s, return 202 + job_id. Output tokens cost 5× input. Route Haiku → Sonnet → Opus by difficulty. “If a human isn't waiting on it, batch it.” |
Patterns to be able to draw
The eight agent patterns M12
- In rising complexity: Single-turn · ReAct · Plan-Execute · Router · Fan-out · Pipeline · Supervisor · Auto+HITL.
- The pattern you pick can swing the bill 10–50×.
- There are five stop rails: natural completion, max iterations, token budget, error threshold and wall-clock timeout. Only the first one means success.
Structured output, reliably M04–M05
- Define a tool, force it with
tool_choice, and read the typed input. - Validate in three layers: tool use, then
json.loads(), then Pydantic/Zod. - Feed the error back. Retry at most 3 times with 2s/4s/8s backoff, and keep a path to a human.
Sandboxed code execution M15
- A sandbox needs four walls: resource caps, no network, a read-only filesystem and container isolation.
- Every run returns stdout, stderr, exit_code and time.
- Feed the traceback back and cap the fix loop at 3 attempts.
Resilience M06, M17
- Wrap every tool and return
is_error: true. - Retry transient failures with backoff.
- Circuit breaker: Closed → Open after 3–5 failures → Half-Open, which sends one probe.
Numbers worth knowing
~60% → 85%+
naive RAG accuracy vs hybrid, re-ranking, query transformation and compression
M10
~90% → 99%+
schema-valid output rate once a tool is forced
M04
~90% / 50%
saved on repeated prefixes by prompt caching / Batch API discount
M22
85 → 9,685
tokens the user typed vs tokens the model actually received
M03B
Glossary
- stop_reason
- The field the loop checks:
tool_usemeans keep going andend_turnmeans return the text. - Prefill / decode
- Prefill reads the whole prompt in parallel and sets TTFT. Decode generates one token at a time and sets TPS.
- Context rot
- Quality loss well below the token limit, caused by a poor signal-to-noise ratio.
- Lost in the middle
- Weaker recall of content in the middle of a long context. Put critical content at the start or end.
- RAG
- Retrieve relevant chunks, paste them into the prompt, and answer and cite only from them.
- Hybrid search / RRF
- BM25 and vector retrievers merged by Reciprocal Rank Fusion, using rank position only.
- HyDE
- Write a hypothetical answer and embed that to retrieve against.
- Cross-encoder
- A re-ranker that reads (query, doc) pairs together for a precise second pass.
- Working / episodic / procedural
- The three memory tiers: task clipboard, searchable session summaries and trigger-matched recipes.
- Hub-and-spoke
- One coordinator, isolated worker contexts and structured aggregation.
- Canary deploy
- Send a small slice of traffic to the change first, before A/B testing.
Self-check
What three things make a program an agent?
Tools, a loop, and Claude deciding the tool, the arguments, the order and when to stop.
Which phase of inference sets time-to-first-token, and what cuts its cost?
Prefill, which scales with prompt length. Prompt caching cuts it.
What default temperature does the course recommend for agents?
0, for reproducibility, debuggability and auditability. Raise it only when variety is the product.
In what order should the context be assembled?
Static first, dynamic last: system → tools → reference doc → history → retrieved → current user message.
How should a tool failure be reported?
As a structured message to Claude (isError, errorCategory, isRetryable, context), not as an exception in your code.
Which advanced-RAG layer do you add first?
Hybrid search (BM25 + vector via RRF), after building a 50–100 pair eval set.
Name the five stop rails. Which one means success?
Natural completion, max iterations, token budget, error threshold and wall-clock timeout. Only natural completion is success.
When should you use the Batch API?
When no human is waiting. It is 50% off and stacks with prompt caching.
Recap: six ideas all four agree on
You have now seen each of these four times, once in each PDF. If you remember nothing else, remember these.
| Idea | 1 · The map | 2 · Coding assistants | 3–4 · Agents |
|---|---|---|---|
| Context is the lever | Your advantage is your context, tools and guardrails, not the model. | “The AI only knows what's in front of it.” CLAUDE.md / GEMINI.md. | Context engineering: add, compress, retrieve, offload. |
| The loop makes the agent | Five parts: model, context, tools, loop, guardrails. The loop makes it an agent. | Agent Mode: multi-step, tool-calling work. | Agent = Tools + Loop + Claude decides. “The while loop is the entire agent.” |
| Plan before acting | Task brief: goal, scope, verify, stop and ask. | Plan Mode, spec-driven development. | Planning on top of ReAct, and a spec as the canonical source. |
| A person stays accountable | “You own what you ship, whoever typed it.” | Read every diff; hands-free only on a branch. | HITL by design, approval gates, fail-safe defaults. |
| Controls, not instructions | “An instruction is not a control.” | Commit first, checkpoints, /restore. | Guardrails in middleware, not the prompt; sandboxes. |
| MCP inside, A2A outside | Agents reach tools through MCP and each other through A2A. | MCP connects the tool to GitHub, Jira, Slack… | MCP = agent→tool, A2A = agent→agent. Complementary. |
Where to go next
Reading gets you the vocabulary. Building is what puts you on the path. Each step has a hands-on course on this site.
After stop 2: get fluent with the tools
- Code With AI (Java) or the Python edition: one real repo, twelve deliberate bugs, and every fix verified.
- Aim to use one assistant daily on real work, with a context file, Plan Mode and a diff review every time.
After stops 3–4: build an agent
- Building AI Agents with Claude is the full course these two PDFs come from: design, build, protect, observe, deploy.
- Then MCP and Claude Code Mastery to go deeper.
- Milestone: write the 15-line agent loop yourself, then add one guardrail and one eval.
Then: go back to the map, hands-on
- The Autonomy Line online is stop 1 with its interactive tools working, including a six-question assessment.
- The practitioner course takes one workflow up the ladder, with nothing to install.
- This is how you talk about agents with the people who fund them, which is a skill interviews test.
Every course on the site is listed on the catalogue, grouped into tracks from Start Here to Operate.