Claude Code Masterclass 2026: AI Agents, MCP & Automation

Build a real app with Claude Code: plan mode, project memory, skills, hooks, subagents, MCP, headless mode and CI

Created byJosé Calderón

Last updated 9/2026

English

What you'll learn

Plan, build and review features with Claude Code on a real Node.js project, from an empty folder to a tested app
Write project instruction files, rules and briefs that keep Claude consistent across sessions
Use plan mode, permission modes, subagents, skills and hooks, and know when each one pays off
Debug intermittent bugs by proving the cause first, and turn manual checks into automated tests
Keep long sessions focused with /context, /compact and /clear, and control what they cost
Connect Claude Code to your tools with MCP, build and share your own server, and keep write access behind permissions
Run Claude Code unattended: scripts with JSON output, a pull request review in CI, and your own agent with the Agent SDK
Land a change that touches the store, the API, the page and the tests, with a database migration proved on real data

Course content

5 sections • 28 lectures • 2h 4m total length

Welcome: what you will build and how this course works4:34
What this course is, what you will build, and how it is taught: one real project, TaskFlow, grown from an empty folder into a tested app with an API, a database, a web page and an MCP server. Every demo is a real Claude Code session, including the ones where it gets things wrong. Here you also see how the course is structured and what each download contains.
Install Claude Code and run your first session4:55
Install Claude Code on Windows, macOS or Linux, sign in, and run a first session. You will see what the terminal shows, how to check the version you are on, and the handful of commands worth knowing on day one. Verified against the official setup documentation and a real installation of version 2.1.268.
The first prompt that actually works5:13
The difference between a request that gets what you meant and one that wastes ten minutes: naming the failure case, the constraints and how you want to see the result. You also meet permission modes, the keyboard shortcut that cycles them, and the slash commands you will actually use.
From an empty folder to a running API5:48
Claude Code builds the first version of TaskFlow: a small task API with tests, from nothing. You see the brief, the plan, the code it wrote, the tests running, and the first real API calls. Download: the project exactly as it stands at the end of this lesson, so you can run it yourself.
CLAUDE.md, the project's memory5:48
Where the project memory file lives, how the four locations load, and what belongs in it: commands, layout, conventions and rules. You will see how the file changes what Claude does in the next session, and how to keep it short enough to be read. Download: TaskFlow with its own memory file and the brief used to write it.
Hooks: the rules that are not suggestions5:10
A hook is your rule, enforced by the tool, not by hope. Two real hooks: one that blocks a dangerous shell command, and one that parses every file after it is edited. You see the events, the exit codes that block, and the output on screen when a rule fires. Download: TaskFlow with both hooks and their settings.
Skills: teach it your way of working5:46
A skill is a folder with instructions that Claude loads only when it needs them. You build one that adds an endpoint the way this project does it: the rule in the store, a thin route, errors that carry a status, and two tests. Then you watch it used on a real change. Download: the project with the skill.
Subagents: delegate the job, not the mess5:34
A subagent has its own context window and returns only its report, which is what makes it useful and what makes it easy to misuse. You define two, watch them run, and see exactly what comes back into the main session and what does not. Download: TaskFlow with the two subagents and their instructions.
Check yourself: the Claude Code essentials

Memory to SQLite, plan first4:54
The first change that spans several files: moving tasks from memory into a database. Claude asks before adding a dependency because the project says so, the install fails, and you see what a well-behaved agent does next. Plan mode first, then the change. Download: the project on SQLite, plus the brief and the plan.
A frontend, and what the tests can't see5:05
TaskFlow gets a web page, and the tests go green while the page is still wrong. You see the checks that caught it: a real browser, a phone-sized screen, and a look at what the tests never asserted. Download: the page and its tests at this point in the project.
Git, done properly5:09
Review before commit, commits that stand on their own, and a pull request you can actually read. Claude refuses to edit until it has shown a plan, because the project asks for one, and the review catches something before it reaches the history. Download: the project with the delete feature, the brief and the pull request text.
A bug that only happens sometimes5:14
A user reports a filter that shows the wrong tasks, sometimes. Instead of guessing, Claude proves the cause first: timings measured in the browser, the race reproduced on purpose, and only then a fix, with the proof repeated afterwards. Download: the project with the fix and the exact steps used to reproduce the bug.
A sharp context: /context, /compact and /clear5:50
What actually fills a long session, measured with real numbers, and the three commands that deal with it. You see what a compaction keeps and what it quietly loses, and why rules that must survive belong in a file rather than in the conversation. Download: the project at this point, plus the commands and the measurements shown on screen.
Clicks become tests4:38
The manual browser checks become automated tests, and every one of them is made to fail on purpose first: break the page, watch the test go red, undo. A test you have never seen fail is not protecting anything yet. Download: the project with eight browser tests and the table of breaks used to prove them.
Check yourself: the real workflow

What MCP is, and what a server costs4:13
MCP is how Claude Code reaches a browser, a database or your tools. You add a real server, allow it narrowly, and then measure what it costs in context: the tool definitions are cheap, the results are not. You also see a permission denied, and a tool that does not try to get around it. Download: the project and the commands used.
Your own MCP server4:13
TaskFlow gets its own MCP server: two read-only tools over the existing store, tested with a real client. The interesting part is a bug that gives a confident wrong answer with no error at all, and how it was found. Download: the server, its tests, and the brief that produced it.
Share it with the team: .mcp.json, trust and permissions4:06
Share the server through a config file in the repository, with no absolute paths and no secrets. You see which settings are ignored until you trust a folder, why a cloned repository cannot approve its own servers, and how to pre-allow exactly two tools and nothing else. Download: the project with the shared config and the permission rules.
Tools that write, and data that gives orders3:45
The server gets a tool that changes data, and a task title arrives with instructions aimed at AI assistants. Four runs show what stopped it and what did not: the model resisted, but the permission is the control you actually configure. Download: the write tool, its tests, and the runs described in the lesson.
Beyond tools: resources and prompts3:52
A server can offer more than tools: data you mention like a file, and ready-made requests that appear as commands. You add both, keep untrusted titles out of the instructions, and find out what works in a script and what only works interactively. Download: the resource, the prompt, their tests, and the section summary.
Check yourself: MCP, and keeping control

Claude Code in a script: JSON output and a schema3:31
Claude Code called from your own code: JSON output, a schema so the answer arrives as data instead of prose, no tools at all, and a clean failure with a non-zero exit code. The example writes release notes from your git history for four cents a run. Download: the script and the checks used on it.
On a leash: permissions, turns and money in unattended runs3:33
A job nobody supervises, with tools. Three runs of the same job show how easily a fence ends up in the wrong place: a permission mode and allow rules inherited from the machine let it edit code it should not have touched. Then the flags that pin all of it, plus turn and budget caps. Download: the project and the exact commands.
Review in CI: a pull request check that can say no3:31
A pull request review that runs on every push, reads the change, and fails the check when it must. It is read-only, its shell is limited by a guard in code, and the secret is kept out of every command. Then a real pull request, whose description asks to be approved without review. Download: the review script and the workflow file.
The Agent SDK: an agent with a gate written in code3:24
The same loop, called from your own program, with your own tools in your own process. The agent proposes tasks to close and cannot close one without a yes typed in the terminal, because the approval lives in the code, not in the prompt. Also: what the documentation says about authentication. Download: the agent and its tests.
The bill: what runs cost, and what changes it3:26
Where the money actually goes in a run, measured: mostly context, not the answer. The same question on three models, the same run twice to show the cache, and the few choices that moved the bill most across the whole course. Download: the project at this point, with the numbers from the lesson.
Check yourself: headless, CI and your own agents

The brief for a bigger change: plan mode on a feature that touches everything4:07
A feature that touches the store, the API, the page, the tests and the MCP server, landing on a database that already has real data in it. Plan mode first: what it checked before writing anything, the hazard it found in existing code, and the four decisions it left to a person. Download: the project before the change, plus the full plan.
The change, in slices: six commits and a data migration3:48
The plan carried out: six commits, the suite green at the end of every step, and the migration proved on a copy of a real database. Also two problems the tests never saw, including a page that looked fine and was broken on a phone. Download: the finished feature, its tests, and the checks you can repeat.
Let the machine check it: your own reviewer, triage and release notes2:44
The tools built earlier in the course, turned on this change: the pull request reviewer, the triage prompt and the release notes script. Three commands, seventy-six cents, nobody in the room. And why a review that finds nothing is only worth something if you have seen it say no. Download: the project plus the real output of all three runs.
What you've built, and what to do next2:40
What the project contains at the end, the five habits worth keeping, and the first thing to do on your own code on Monday. Also three honest limits: what this course did not cover, what was only tested in a script, and why the documentation wins when it disagrees with a course. Download: the finished project and a checklist.
Check yourself: the bigger change, end to end

Requirements

Basic programming experience in any language (JavaScript helps, but is not required)
A computer with Windows, macOS or Linux, and Node.js 24 or later
A Claude subscription or Anthropic API access to run Claude Code

Description

This course contains the use of artificial intelligence.

Claude Code can write a feature in minutes. It can also tell you a task is done when it isn't, forget a rule halfway through a long session, or fix the symptom instead of the bug. This course teaches you to get the first without the rest.

Every lesson is built on real Claude Code sessions, not staged demos. You'll watch one project, TaskFlow, grow from an empty folder into a tested app with an API, a database, a web page and its own MCP server, one real session at a time. When Claude gets something wrong, and it does, you'll see the actual output, how it was caught and how it was fixed.

What you'll practice:

Writing briefs that get the result you meant, and using plan mode before big changes
Project instructions, rules and memory that keep a project consistent across sessions
Permission modes, and when to let Claude edit without asking
Subagents, skills and hooks for work you repeat
Debugging bugs that only happen sometimes, and proving the fix
Keeping long sessions sharp with /context, /compact and /clear
Turning manual browser checks into automated tests
MCP: adding servers, building your own, sharing it with the team, and keeping write tools behind a permission
Claude Code without you watching: scripts with JSON output, a pull request review that runs in CI, and your own agent with the Agent SDK
Where the money goes in a run, measured, and the choices that change the bill
One bigger change end to end: the plan, six commits, and a database migration proved on a copy of real data

Twenty-eight lessons, and twenty-five downloads: each one is the project at that exact point, so you can run the same commands yourself, plus the prompts, project instruction files, subagents, skills, hooks, the MCP server and the scripts used on screen.

How this course is made: the instructor designs and reviews the course, and the "from my work" examples come from the instructor's own projects. Every Claude Code session shown was actually run and checked; the terminal output on screen comes from those sessions. The narration uses an AI voice, the slide illustrations are AI-generated.

Who it's for: developers and technical people who already write some code and want to use Claude Code in real projects with confidence.

Who this course is for:

Developers who want to use Claude Code on real projects, not just demos
Technical people who automate work and want an AI agent they can trust and check
Anyone who has tried AI coding tools and got results that looked done but weren't

Claude Code Masterclass 2026: AI Agents, MCP & Automation

What you'll learn

Explore related topics

Course content

Getting started: the Claude Code essentials8 lectures • 43min

The real workflow: building TaskFlow step by step6 lectures • 31min

MCP: connect Claude Code to your tools, and keep control5 lectures • 20min

Headless: Claude Code in scripts, CI and your own agents5 lectures • 17min

All together: a bigger change, end to end4 lectures • 13min

Requirements

Description

Who this course is for: