From zero to a complete agentic system
One conceptual foundation, ten operational modules, 48 lessons and 11 labs. Follow the path in order or open exactly what you need.
- 0085 min · 8 lessons
Before Claude Code: AI, LLM, agents and tools
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
- 0145 min · 4 lessons
Thinking in an agentic way
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
- 0250 min · 4 lessons
Environment, access and first program
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
- 0360 min · 4 lessons
Exploring, Fixing, Refactoring, and Using Git
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
- 0455 min · 4 lessons
Context engineering, memory and planning
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
- 0555 min · 4 lessons
Reusable commands, Skills, and plugins
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
- 0655 min · 4 lessons
MCP: Connect tools and sources
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
- 0750 min · 4 lessons
Hooks and controlled local automation
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
- 0865 min · 4 lessons
Specialized agents and collaboration
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
- 0960 min · 4 lessons
Non-interactive CLI, JSON, and pipelines
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
- 1065 min · 4 lessons
Remote sessions, asynchronous routines and final project
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
The program is free. Your progress is yours.
Register to open labs, quizzes and exercises and recover all your progress online.
Create your free account