Question → answer
Useful for explaining and proposing. It does not change the outside world on its own.
Free course · in English · for complete beginners
The free agentic AI course for observable, verifiable workflows
Build verifiable agentic workflows with LLMs, tools, Claude Code, MCP and controlled automation. You learn by doing, without mistaking a confident answer for evidence.
Free. No card required. You create your email and password here.01Goal
Observable result
02Context
Facts and constraints
03Action
Authorised tools
04Evidence
Diff, tests, output
A course about agents, built with agents.
This free multilingual course was produced through an Agentic AI workflow for research, instructional design, writing, review, verification and translation, under the direction and supervision of Nello Castellano.
48lessons
11labs
10h45guided path
33questions with feedback
FREEfull access
Beyond prompts
A chat answers. An agent observes, acts and proves.
Goal → loop → evidence
It uses tools within explicit permissions and checks the result against observable criteria.
Concrete outcomes
From essential vocabulary to an operational workflow
Every outcome is tied to an exercise, a simulation and immediate feedback.
- 01Understand LLMs, agents, tools and their limits
- 02Write assignments with goals, boundaries and evidence
- 03Work with the terminal, Git and Claude Code
- 04Design context, memory, commands and Skills
- 05Connect MCP, Hooks and controlled subagents
- 06Build recoverable pipelines and asynchronous routines
Try it now
Put the agentic loop back in motion
Select the steps in the correct order. The feedback explains why the sequence matters.
Goal: replace one heading in a small local app.
Complete program
Absolute foundations plus ten operational modules
The program is public. Activities and personal progress unlock after free registration.
00Before Claude Code: AI, LLM, agents and tools85 min · 8 lessons
Explain in your own words what an LLM and an agent are, recognize tools and permissions and design a first simulated local micro-mission with boundaries and tests.
- The map: AI, machine learning, LLM and Claude Code
- How a response is generated: tokens, probabilities, and limits
- Prompt, context, window and memory are not the same thing
- Hallucinations, uncertainty and evidence
- From chatbot to agent: who decides and who acts
- Tools, permissions and security boundaries
- Files, folders, the terminal, and Git: your workspace
- The first guided mission, from observation to test
01Thinking in an agentic way45 min · 4 lessons
Turn a vague request into a testable assignment, with explicit boundaries and evidence.
- From response to workflow
- The operational assignment
- Autonomy proportionate to risk
- Evidence beats certainty of tone
02Environment, access and first program50 min · 4 lessons
Navigate between terminal, editor, web and API, diagnose the environment and run the first script.
- Four surfaces, different responsibilities
- Read the terminal without fear
- Credentials and environment variables
- The first execution–error–correction cycle
03Exploring, Fixing, Refactoring, and Using Git60 min · 4 lessons
Follow a bug from reproduction to commit, keeping the change small and verifiable.
- Build a map before editing
- From symptom to hypothesis
- Bug fixes and refactoring are not synonymous
- Git as a readable safety net
04Context engineering, memory and planning55 min · 4 lessons
Build a small and reliable context, separating stable rules, memory, references and plan.
- Four practical sources of context
- Project instructions that really help
- Compact without losing the contract
- Plan before execution
05Reusable commands, Skills, and plugins55 min · 4 lessons
Choose the correct level of reuse and define tools with clear inputs, permissions, outputs and tests.
- Built-in Commands, Skills and Plugins
- Input and output before instructions
- Anatomy and test of a skill
- Provenance and permissions
06MCP: Connect tools and sources55 min · 4 lessons
Design a local or remote MCP connection with verifiable capabilities and least privilege.
- Clients, servers, tools, resources and prompts
- Local or remote: a trust decision
- Minimum scope and tokens
- Handshake, minimal test, and diagnosis
07Hooks and controlled local automation50 min · 4 lessons
Design pre- and post-hooks that are deterministic, observable, and recoverable.
- The life cycle of an event
- Pre-hook: Secure the boundary
- Post-hook: observe what has already happened
- Idempotence, recursion and failure
08Specialized agents and collaboration65 min · 4 lessons
Decompose a result, assign ownership and use parallelism only when it really saves time.
- Decompose by result, not by label
- Dependencies and real parallelism
- File ownership and conflicts
- Evidence-based synthesis
09Non-interactive CLI, JSON, and pipelines60 min · 4 lessons
Build a reproducible local stream with structured output, gates and limited permissions.
- Interactive and non-interactive
- JSON as contract, not decoration
- Gate and failure propagation
- Auto mode and operating range
10Remote sessions, asynchronous routines and final project65 min · 4 lessons
Design an asynchronous routine with checkpointing, limited retry, approval, and observable recovery.
- The state of a session
- Idempotent schedules
- Remote control and human checkpoints
- Capstone: full system, not full autonomy
Workshop method
Understand, visualise, apply, verify
Substantial explanations
Progressive concepts, examples and procedures that never assume you know the jargon.
Explanatory visuals
Flows, matrices and maps make relationships and control points visible.
Interactive labs
Every module includes a simulation that reacts to your decisions without taking external action.
Evidence of mastery
Checklists, artefacts and quizzes measure what you can apply, not time spent.
Who built the course
Nello Castellano
More than twenty-five years across software architecture, SaaS and APIs; today he applies LLMs and coding agents to products that must be verifiable, maintainable and production-ready.
He brings a builder’s approach to the workshop: the model proposes, the system measures and a person remains accountable for the result.
Meet the author and learn about his method →Frequently asked questions
Before you begin
Do I need to know how to code?
No. Module 00 starts with AI, LLMs, agents, files and the terminal. Activities become gradually more technical, and you may skip or resume any lesson.
Is the course really free?
Yes. All 48 lessons, 11 labs, exercises and quizzes are available without a credit card after registration.
Why do I need to register?
Your account saves progress online and restores your path across sessions. You choose your own email and password; the newsletter remains a separate, revocable choice.
Is this a prompt-engineering course?
It goes beyond prompts: you learn operational loops, controlled tool use, permissions, verification, context, MCP, Hooks, subagents and pipelines.
Must I follow the modules in order?
No. The path is open: choose a module or an individual lesson and return later. Completion measures mastery; it is not a gate.
Start with the foundations. Take away a system, not a collection of prompts.
Create your free accountNewsletter consent is optional and can be withdrawn.