EasyEnv
Engineering/Courses/Catalog/Claude from Zero to Mastery
Claude from Zero to Mastery
Beginner

Claude from Zero to Mastery

You do not need to know anything about AI. We start with what Claude actually is and go step by step to designing systems that work correctly in practice too. That is exactly what the Claude Certified Architect exam measures.

47 lessons8.4h hands-on11 languages
Start learning freeClaude from Zero to Mastery course

47 lessons, in order

  1. 1

    What is Claude, really?

    Before this: nothing. Start right here.

    How is an ordinary program different?So what is Claude?Why is it sometimes confidently wrong?Where does the architect come in?
    10 min
  2. 2

    How programs talk to Claude

    Before this: Lesson 1. No programming needed.

    What does API mean?The simplest requestThe point everything hangs on: there is no memoryWhat does a response look like?Why does this matter to an architect?
    10 min
  3. 3

    Tokens and the context window: the model's short-term memory

    Before this: Lesson 2.

    Tokens: how the model measures textThe context window: the model's deskWhy more is not always betterWhen the desk is full: summarising, and its dangerMax_tokens is not the context window
    10 min
  4. 4

    Prompts: how to ask the model for work

    Before this: Lesson 1 and Lesson 2.

    Why isn't "write well" enough?Four things a good prompt hasGive the reason behind the rule tooWhere does a prompt stop?
    10 min
  5. 5

    Tools: how a model with no hands gets things done

    Before this: Lesson 2.

    The problemHow it worksDefining a toolThe model's request and your result, side by side
    10 min
  6. 6

    What an agent is, and why a loop comes into it

    Before this: Lesson 5.

    The problem: once is not enoughWhat is a loop?So what is an agent?Why does the loop matter so much?
    10 min
  7. 7

    A map of the Claude family: models, API, Claude Code, SDK and MCP

    Before this: Lesson 6.

    Models: which brain?Four layers on top of the modelWhy was MCP needed?Where do skills, hooks and subagents fit on the map?How do you choose?
    10 min
  8. 8

    Introduction: why agents break in practice

    Before this: Lesson 5 and Lesson 6. You need to know what a tool is and why an agent has a loop.

    The story: a great demo, a bad first weekWhy a demo misleadsWhere each failure gets fixedHow the lessons connectIts weight in the exam
    10 min
  9. 9

    The agentic loop

    Before this: Lesson 5 and Lesson 6. There you saw the idea of the loop. Here we open it up step by step. No programming needed.

    The story: an agent that sometimes stops halfwayThe right way: a field built for exactly thisThe loop, step by stepWhy the other ways are wrong
    10 min
  10. 10

    The coordinator and subagent pattern

    Before this: Lesson 9. You met the word subagent in Lesson 7.

    The story: a report that looked completeThe idea: coordinator and subagentThe team's shape: a starWhat the coordinator doesWhy not the other ways
    10 min
  11. 11

    Building a subagent and giving it context

    Before this: Lesson 10 and Lesson 7 (what the Agent SDK is).

    The story: "the customer we mentioned"What a subagent seesDefining a subagentA good prompt for a subagentGive the coordinator a goal, not a procedureParallel work: several calls in one response
    15 min
  12. 12

    Enforcing in code, and handoff

    Before this: Lesson 1 (probabilistic behaviour) and Lesson 9.

    The story: a rule that sometimes got brokenEnforcing in code: the ideaHow it worksThe line: when prompt and when code?One message, several problemsHanding work to a human (handoff)
    15 min
  13. 13

    Hooks in the Agent SDK

    Before this: Lesson 12 and Lesson 7. Remember MCP from that lesson.

    The story: two faults a prompt cannot fixWhat a hook isRefusing above the capMaking the output uniformWhy a hook and not the other ways
    15 min
  14. 14

    Breaking work down: fixed chains versus dynamic splitting

    Before this: Lesson 6 (workflow versus agent) and Lesson 10.

    The story: two jobs, two failuresPrompt chaining: when the steps are knownDynamic decomposition: when the steps are not knownHow to chooseThe obvious way and why it breaks
    10 min
  15. 15

    Sessions: continue, resume and fork

    Before this: Lesson 2 (no memory), Lesson 3 and Lesson 7.

    The story: the agent and Friday's pictureWhat a session isThree ways backCarry on, or start fresh?Why not the other ways
    10 min
  16. 16

    Introduction: a tool is the model's user interface

    Before this: Lesson 5 and Lesson 7. Lesson 9 helps too, but you don't need it.

    The story: one line of text makes all the differenceA tool is the model's user interfaceA tool's life, and this domain's lessonsWeight in the exam
    10 min
  17. 17

    Tool descriptions and boundaries

    Before this: Lesson 5 and Lesson 16.

    The story: two tools, one descriptionWhy the description matters so muchWhat a good description containsOverlapping toolsWhy not the other routes
    10 min
  18. 18

    Structured errors in MCP

    Before this: Lesson 5 and Lesson 9. We introduced MCP in Lesson 7, and its details are in Lesson 20. Here it's enough to know that MCP is a standard...

    The story: three failures, one messageFour kinds of errorHow to tell the modelRecovery inside a subagentWhy not the other routes
    10 min
  19. 19

    Distributing tools, and tool_choice

    Before this: Lesson 5 and Lesson 17. We introduced subagents in Lesson 7.

    The story: the agent that can do everythingWhy too many tools is badWho decides? tool_choiceToday's alternatives
    15 min
  20. 20

    Connecting MCP

    Before this: Lesson 5 and the MCP section of Lesson 7.

    The story: the same tool, different on every laptopServers, tools and resources in plain wordsWhere each server is definedA secret is never committedResources in practiceWhy not the other routes
    15 min
  21. 21

    Choosing the built-in tools

    Before this: Lesson 3 and Lesson 5.

    The story: the agent that reads all the codeFive toolsWhy Edit needs unique textUnderstanding code, step by stepWhy not the other routes
    10 min
  22. 22

    Introduction: how Claude Code learns what your project is like

    Before this: Lesson 6 and Lesson 7. If you've never seen Claude Code or worked with git, that's fine: we explain from zero.

    The story: a brilliant colleague who forgets everything every morningWhat is Claude Code?What does a session look like?A few words you'll see all the time in this domainThree places for knowledge, two ways of working, one mode without youWeight in the exam
    10 min
  23. 23

    The CLAUDE.md hierarchy

    Before this: Lesson 22 and Lesson 3.

    The story: "it works for me"What is CLAUDE.md?How do they fit together?Writing it well and keeping it shortWhy not the other routes?
    10 min
  24. 24

    Commands and skills

    Before this: Lesson 23. For the context: fork setting, Lesson 10 helps too.

    The story: a checklist that is either forgotten or always in the wayWhat are skills and commands?How do we build one?Where do we put it?Why not the other routes?
    10 min
  25. 25

    Path-specific rules

    Before this: Lesson 23 and Lesson 24 (for what frontmatter means).

    The story: a rule scattered across thirty foldersThe right way: a rule that knows when it's neededWhat is a glob pattern?Which tool for which rule?
    10 min
  26. 26

    Plan mode or direct execution

    Before this: Lesson 22. Lesson 10 helps with the subagent section.

    The story: a migration that got stuck halfwayWhat is plan mode?When to use which?Exploring without filling the contextWhy not the other routes?
    10 min
  27. 27

    Iterative refinement

    Before this: Lesson 4 and Lesson 22.

    The story: three explanations, three interpretationsFour toolsWhy not the other routes?
    10 min
  28. 28

    Claude Code in CI

    Before this: Lesson 22 and Lesson 23. For what a hook is, Lesson 13, and for MCP, Lesson 7.

    The story: four failures in a rowFixing the first three failuresTwo things the script has to respectReview in a separate sessionWhy not the other routes?
    10 min
  29. 29

    Introduction: from "a good answer" to "output you can rely on"

    Before this: Lesson 4 and Lesson 5. Knowing Lesson 6 helps too.

    The story: an answer that was fine and still took the program downWhat does reliable output mean?How the lessons connectWeight in the exam
    10 min
  30. 30

    Explicit criteria to cut false positives

    Before this: Lesson 4.

    The story: a bot nobody looked at anymoreWhy "be careful" does not workThe right way: explicit criteriaWhy the other ways are wrong
    10 min
  31. 31

    Few-shot

    Before this: Lesson 4 and Lesson 30.

    The story: a review that fit two categoriesWhat does few-shot mean?How to write good examplesIn code review: a fixed format and fewer false alarmsIt works for data extraction tooWhy the other ways are wrong
    10 min
  32. 32

    Tool use and JSON schema

    Before this: Lesson 5 (tools and JSON Schema).

    The story: a page with no sizeA few words you needThe trick: a tool that only takes dataNow, how do we make sure this shape comes back?What does it not catch?Why the other ways are wrong
    15 min
  33. 33

    Validation and retries

    Before this: Lesson 32.

    The story: an invoice whose total did not add upWhat does validation mean?The right retry: send three thingsWhen does retrying help?Design the schema so it shows contradictions
    10 min
  34. 34

    Message Batches

    Before this: Lesson 2 and Lesson 5.

    The story: a report that cost too muchWhat do batch and SLA mean?How it worksWhy the other ways are wrong
    10 min
  35. 35

    Multi-instance and multi-pass review

    Before this: Lesson 3 and Lesson 30.

    The story: two reviews that caught nothingProblem one: the author is not a good reviewerProblem two: attention spreads thinOne more pass: a confidence for each findingWhy the other ways are wrong
    10 min
  36. 36

    Introduction: a system that behaves well on a bad day too

    Before this: Lesson 3 and Lesson 6. Wherever you reach a team of several agents, Lesson 10 helps.

    A bad day at our bookshopWhat does reliability mean?How do the lessons connect?Weight in the exam
    10 min
  37. 37

    Keeping facts in a long conversation

    Before this: Lesson 3 (tokens, the context window and compaction).

    The story: an amount that faded awayThe fix: a case facts blockHow does it work?Three more helpersWhy the obvious ways are not enough
    15 min
  38. 38

    When to escalate to a human

    Before this: Lesson 6. For the handoff summary, Lesson 12 helps, and for examples inside the prompt, Lesson 31.

    The story: three mistakes in one morningExplicit criteria instead of guessingHow do we give the agent these criteria?Why don't sentiment analysis and the model's confidence work?
    10 min
  39. 39

    Error propagation in a multi-agent system

    Before this: Lesson 10 (coordinator and subagent) and Lesson 18 (structured errors in tools).

    The story: a report that was confidently wrongA good error says four thingsWho does what with which error?Why are the other ways wrong?
    10 min
  40. 40

    Exploring a large codebase

    Before this: Lesson 3, Lesson 10 and Lesson 37.

    The story: an agent that forgot the classesFour ways, each for one problemWhy don't the obvious ways work?
    10 min
  41. 41

    Human review and calibration

    Before this: Lesson 32 (structured output) and Lesson 33 (validation).

    The story: a 97% that hid bad newsA worked example (made up, for illustration only)Confidence scores and calibrationWhy do we sample high-confidence cases too?How does the review queue work?Why are the other ways wrong?
    10 min
  42. 42

    Provenance and uncertainty

    Before this: Lesson 11 (what reaches a subagent) and Lesson 39.

    The story: a number nobody ownedWhat does provenance mean?The fix: a structured mappingWhen sources disagreeWhy are the other ways wrong?
    10 min
  43. 43

    Wrap-up: the exam's six scenarios

    The exam picks four of these six scenarios at random. Each scenario is a real system, and the questions come from the decisions inside it. For each...

    1. A customer support agent2. Code generation with Claude Code3. Multi-agent research4. Developer productivity tools5. Claude Code in CI6. Structured data extraction
    10 min
  44. 44

    The logic of the answers: eight rules

    Now that you know the topics, these eight rules settle most of the questions. The questions are not about memorising; they ask for judgement. The...

    How to answer a question
    10 min
  45. 45

    The exam versus today

    The exam guide we have seen lags behind the current documentation (November 2026). The version we compared is "Version 8, effective July 2026" (exam...

    Where they differ
    10 min
  46. 46

    Glossary

    Whenever you forget a word, look here. Each term links to the lesson that explains it in full.

    Glossary
    10 min
  47. 47

    The exam itself and its conditions

    Read this page when you are thinking about booking. It comes from the official exam guide (Version 8, effective July 2026) and the official FAQ....

    The exam at a glanceBefore you book
    10 min
Claude from Zero to Mastery Course: Hands-on, in 11 Languages | Engineering Courses