@XAMTO_AI: Guys, still learning AI Agent in bits and pieces? Check this out! A 22-chapter skeleton course on building a production-grade Agent system from 0 to 1. Tool calling, Agent loop, memory system, multi-Agent collaboration, human-machine interaction, backend architecture, observability, cost optimization, security... The coolest part is the core gameplay — using Agent to teach Agent. The author only provides the skeleton, and the AI assistant fills in the code and details. Learn by doing. This is the learning style for 2026; the era of rote memorization is over.
Summary
A 22-chapter skeleton course on building production AI agents, using an innovative approach where the AI partner fills in details. The course covers tool calling, agent loops, memory, multi-agent collaboration, and more.
View Cached Full Text
Cached at: 06/16/26, 01:13 AM
Folks, are you still learning about AI Agents in bits and pieces? Check this out!
A 22-chapter skeleton course that teaches you how to build a production-grade Agent system from 0 to 1.
- Tool calling, Agent loops, memory systems
- Multi-agent collaboration, human-in-the-loop
- Backend architecture, observability, cost optimization, security
The coolest part — the core play: using an Agent to teach an Agent. The author only provides the skeleton; your AI assistant fills in the specifics and code. You learn by doing, on the fly.
This is how you should be learning in 2026. The era of rote memorization is long gone.
https://github.com/bryanyzhu/agentic-ai-system-course…
bryanyzhu/agentic-ai-system-course
Source: https://github.com/bryanyzhu/agentic-ai-system-course
Agentic System Course - Use Agent to Learn Agent
Join the discord channel (https://discord.gg/dWSnHAFdpb) if you want to learn and build together!
This is a 22-chapter skeleton course on how to design, build, and operate production AI agents — written to be read with your own AI partner at your side. An agentic system is an AI system that can autonomously pursue goals by planning, making decisions, using tools, adapting based on feedback, having memory, etc — instead of only responding to a single prompt. Similar to Andrej Karpathy’s idea file on LLM-wiki (https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f), this course is giving you the skeleton and your agent will help you put the muscles on it.
This course is:
- A skeleton — load-bearing topics, patterns, and decisions, with trade-offs.
- Written to age slowly. Framework specifics rot fast; architectural patterns do not.
- A file pair (course + AGENTS.md) designed for AI consumption as much as human reading.
This course is not:
- A step-by-step tutorial. There is no walked-through project.
- Tied to one stack. The course never says “use LangChain” or “use Pydantic AI.” Your AI partner suggests the stack that fits your project.
- A reference manual. When you need an exact API signature, ask your AI or read the docs.
How to start
Clone the repo, open it in your usual IDE to view course content. At the same time, point your AI agent (Claude code/Codex) at the project root, and try one of these prompts when you study a chapter:
- “Give me three real-world examples of where this matters.”
- “Suppose you are interviewing me, quiz me on this topic with five follow-up questions, easy to hard.”
- “What’s a question I should be asking that I haven’t?”
- “I just read about [pattern X]. I am building [your project]. Translate the pattern into the smallest version that works in whatever language and tools fit, and explain each piece as you write it.”
- “Forget my project for a moment — show me how OpenCode (or Hermes Agent, or any leading coding agent) handles this, and what we should borrow from it.”
You can also just point your agent at Ch.22’s design canvas and walk through it with your specific project in mind — that’s the fastest path from “I have an idea” to “I have a spec.”
Built-in skills
agentic-system-reviewer
Reviews PRDs, design docs, implementation plans, or agent code against the course. You can run this skill on any agentic system to get course-grounded feedback — your own project, an open-source agent you’re studying, a PRD before any code exists, or a coworker’s repo you want a second opinion on. The skill calibrates scope first (hobby / team tool / customer-facing), picks the chapters that matter for your archetype, reads them, and produces a findings-first report with severity, evidence, course citations, and concrete fixes — not a generic “looks good” or “add safety” review.
In Claude Code, just describe what you want — “review this against the course”, “is this agent design good?”, “what chapters does this miss?” — while the agent is pointed at the target repo or doc. The skill auto-loads when its description matches your intent.
Codex users: use Codex’s official skill-creator skill to port this skill over.
Course structure
| Chapters | Theme |
|---|---|
| Ch.00 | How to use this course with your AI partner |
| Ch.01–04 | Foundations: one tool call → the loop → tools as contract → prompts & cache |
| Ch.05–08 | Memory and state: short-term → long-term → writing & curation → persistence |
| Ch.09–11 | Coordination: planning → multi-agent delegation → the harness |
| Ch.12–14 | External surface: human-in-the-loop → connectors/MCP → skills/MCP/subagents |
| Ch.15–17 | Production scale: backend → observability → cost, latency, model strategy |
| Ch.18–19 | Quality and ops: safety/adversarial inputs → operations and forward-deployed |
| Ch.20–21 | Agency: proactive agents → self-evolving agents |
| Ch.22 | Design canvas: designing your own agent |
The chapters are ordered so each one only assumes what came before. If you have a clear project, skim chapters that do not apply yet and come back when they do. Suggested learning paths by project shape (coding agent, personal assistant, multi-tenant tool, research agent, just exploring) are in CLAUDE.md.
The goal is not to finish the course. The goal is to ship something you wanted to ship anyway, and to understand every line of it.
Optional: reference systems
The course occasionally points at four open-source systems for grounded examples:
- OpenCode — coding agent (terminal-first, typed tools, sessions, compaction)
- Hermes Agent — personal assistant (memory, skills, cron, channels)
- OpenClaw — self-hosted personal-assistant gateway (channel adapters)
- Paperclip — workflow control plane (multi-agent orchestration, durable Postgres state)
You do not need to clone any of these to get value from the course, these four are sanity checks. If you find yourself wanting grounded answers (“how does X actually do Y in code?”), your AI partner will offer to clone the relevant repo on demand, or you can run setup beforehand:
bash ./setup.sh
This clones all four reference repos to references/. Idempotent (safe to re-run). Env-var-overridable if you want to point at forks or pinned commits. See the script for details.
If you want to ask questions about other sources, feel free to put them under references/ and chat about it.
Repository layout
course/ — 22 chapters (read-only by design — this is the skeleton) CLAUDE.md — Behavioral guide for your AI partner (read by Claude Code) AGENTS.md — Same content as CLAUDE.md, named for Codex / Cursor / other agents README.md — This file setup.sh — Optional: clone the four reference repos .claude/skills/ — Built-in skills your AI partner can invoke (reviewer; more coming) docs/ — Written notes your AI partner produces on request (created on demand) questions/ — Daily Q&A log your AI partner writes automatically (created on demand) workspace/ — Code, exercises, and project builds (created on demand) references/ — The four reference repos if you (or your agent) clone them
CLAUDE.md and AGENTS.md are duplicates — same content under two filenames because different agents look for different files by default. Both are structured the same way the course is: a durable, opinionated file any AI assistant can read in one pass and turn into useful behavior.
One last thing before you start
You do not need permission to start. You do not need to read every chapter before opening your agent. You do not need to know which framework you will end up using. The first thing you build will be small enough that none of those decisions matter — and once it’s in front of you, working, the next decision becomes obvious.
The people shipping the most interesting agentic systems today are not the ones with the most experience. They are the ones who got into a tight loop with their AI partner first and stayed in it longest. This course exists so that when you are in that loop, you know what to ask.
License
See LICENSE. The course content is open for educational use. Reference systems retain their original licenses.
Similar Articles
@gyro_ai: Most people learn about agents either staying at the conceptual level or jumping directly into frameworks, leaving the middle layer—"why design it this way"—empty. On GitHub, the book "Building Agents from Scratch" by Datawhale covers 16 chapters from basics to multi-agent systems, with its own HelloAgents framework to learn by doing…
Datawhale's open-source tutorial "Building Agents from Scratch" covers memory systems, RAG, context engineering, etc. in 16 chapters, including the HelloAgents framework, suitable for learners who want to deeply understand the internal mechanisms of agents.
@vintcessun: Tonight I came across a learning roadmap project that redefined where to start learning Agent. I used to think Agent was just a pile of tools and frameworks, but its core is the "observe-think-execute" loop and the harness engineering's organization of permissions, state, and backtracking. It breaks down learning into building a minimal Agent loop from scratch all the way to deploying a real Agent, with 8 stages, each with clear deliverables and recommended resources — not just links but an actionable todo list. This systematic approach made me realize my previous learning was too fragmented.
An open-source learning roadmap project called Agent-Learning-Hub, which breaks down AI Agent learning into 8 stages from building a minimal Agent loop to production deployment, providing executable todo lists and recommended resources, maintained by members of the Datawhale community.
@FakeMaidenMaker: Full-Stack AI Engineer Roadmap: From Zero to Math, LLMs, and Agents – Covers Everything. There’s tons of AI material online, but it's all fragmented—one article on fine-tuning, another agent demo, every search yields "Build a RAG in 5 minutes" fast food. A coherent system from math to LLM to agent is nearly impossible to find.
A free, open-source AI engineering curriculum that covers math, LLMs, and agents across 20 phases and 435 lessons in Python, TypeScript, Rust, and Julia, designed to fill gaps in fragmented AI tutorials.
This article systematically reviews AI Agent architecture and engineering practices, covering control flow, context engineering, tool design, memory, multi-agent organization, evaluation, tracing, and security. It is based on the OpenClaw implementation and emphasizes the critical role of Harness (testing and validation infrastructure) for system stability.
This article systematically reviews AI Agent architecture and engineering practices, covering control flow, context engineering, tool design, memory, multi-agent organization, evaluation, tracing, and security. It is based on the OpenClaw implementation and emphasizes the critical role of Harness (testing and validation infrastructure) for system stability.
@GitTrend0x: AI Agent from Newbie to Master Pro-Grade Artifact https://github.com/pguso/ai-agents-from-scratch… This is ai-agents-from-scratch, a 3.9k star hit that 'truly explains AI Agent…'
Introduces a 3.9k star open-source tutorial project, ai-agents-from-scratch, which builds AI Agents from scratch using local LLM and Node.js, covering core concepts such as system prompts, tools, memory, and reasoning patterns.