Learning Agent Development from Scratch: Breaking Down Bilibili's 100-Episode Course

Large model courses are everywhere, but systematic tutorials that truly focus on Agent development are scarce. A 100-episode AI Agent development course on Bilibili attempts to take absolute beginners to the point where they can independently ship projects, using three modules. Is it marketing talk or does it actually deliver? This analysis starts from the course design logic and breaks down its value and limitations.

Why Agent Development Has Become a Dividing Line

The course opens with a judgment: basic RAG and simple API calls are no longer enough. This claim deserves unpacking. Over the past two years, the core work of many AI application roles has been "call the model + wire up an interface + stuff in a vector store"—the technical barrier isn't high. But as large model capabilities gradually become platformized, companies' expectations of developers have shifted upward—whether you can design an Agent system that plans, calls tools, has memory, and collaborates across multiple turns has become the de facto standard separating "AI application engineers" from "AI parameter tuners."

This course uses that shift as its entry point, emphasizing that "independently developing intelligent Agents is the core competency." Though the phrasing carries a certain promotional flavor, the trend it points to is real: Agent development involves planning modules, memory modules, tool calling, and multiple other subsystems, and the complexity is genuinely an order of magnitude higher than a single API call.

RAG (Retrieval-Augmented Generation) is the key background for understanding this judgment. Its basic idea is: before the model generates an answer, retrieve relevant document fragments from an external knowledge base, splice the retrieval results into the prompt, and let the model answer based on that material. This alleviates problems like the model's knowledge cutoff, hallucinations, and inability to access private data, and it has been the most common technical approach for enterprise AI applications over the past two years.

But RAG is essentially a one-shot "retrieve—generate" process: no task planning, no state memory, and no ability to adjust subsequent actions based on results. Agents split these capabilities into independent modules: a planning module breaks down goals, a memory module preserves history and context, and a tool-calling module lets the model read from and write to external systems. It's precisely because of these extra subsystems that Agents are regarded as a higher-level engineering form than RAG, and have become the dividing line in developer capability.

Course Structure: A Three-Stage Format of Basics, Advanced, and Hands-On

The course is divided into three major modules, logically progressive.

Basics section focuses on laying conceptual groundwork, covering the core definition of an Agent, the role of large models within it, the planning module, the memory module, and the basic mechanisms of tool calling. The goal at this stage is to help developers with no prior exposure to Agents build an underlying cognitive framework.

Advanced section moves into operating principles and classic paradigms, including ReAct, CoT, multi-agent collaboration, and prompt tuning. This part is the technical core of the course—only after understanding how an Agent plans tasks, selects and calls tools, and distributes responsibilities among multiple agents can you really be considered to have gotten started.

Hands-on section wraps up with three projects: an intelligent decision assistant, an automated office Agent, and a multi-agent collaboration system. The project choices lean toward general scenarios, with the aim of letting learners produce presentable work for job hunting or client projects.

ReAct and CoT are the two paradigms in the advanced section that most need prior understanding. CoT (Chain-of-Thought) means letting the model generate intermediate reasoning steps before giving a final answer, thereby improving accuracy on complex tasks, usually guided through prompts like "let's think step by step" or examples.

ReAct (Reasoning + Acting) goes a step further on top of CoT: the model not only outputs reasoning but also outputs an action to execute, such as calling a search tool or calculator, then continues reasoning based on the tool's returned result, looping until the task is complete. You can think of it as an alternating process of "think while acting, and think again after acting," which is also the underlying logic of most modern Agent frameworks. Understanding these two paradigms is necessary to grasp the design motivations behind role division and message passing in later multi-agent collaboration.

Where This Course Stands Out

The course creator mentions that after studying a large number of related tutorials on Bilibili, he found two common problems: knowledge points are scattered and unsystematic, and courses either only discuss concepts or only teach tools. This observation is fairly accurate. In the Chinese-language community today, Agent-related content is indeed polarized—academic-oriented content discusses papers and paradigms, while tool-oriented content teaches operational steps for LangChain or Coze, with little connection between the two.

This course positions itself as building a bridge in the middle: from concepts to principles, then from principles to code and projects. The images it provides also emphasize "truly understanding how Agents plan, call tools, and solve complex tasks." If the course content can deliver on this promise, it genuinely saves self-learners the time cost of piecing together scattered materials.

LangChain and Coze represent two mainstream paths in current Agent development, and understanding their differences helps clarify the course's middle-ground positioning. LangChain is an open-source framework in the Python/JavaScript ecosystem that abstracts components such as model calls, prompt templates, tools, memory, and retrieval into composable modules, suitable for developers who need deep customization and code-level control. Coze is a low-code/no-code platform launched by ByteDance that quickly builds Bots through visual drag-and-drop and a plugin marketplace; it has a low barrier to entry but relatively limited flexibility and portability.

The common problem with both is: tools become outdated, but paradigms remain relatively stable. If you only learn LangChain's API or Coze's operational steps, your accumulated knowledge easily depreciates once the framework upgrades or the platform strategy changes. The course tries to first explain concepts such as planning, memory, and tool calling that don't change with the tool, and then move to concrete implementation. This is exactly the trade-off a long-term learning roadmap should make.

Who It's For, and Who It's Not For

Judging from the course positioning, it best suits two groups: developers with no Agent development experience at all but with basic knowledge of large models; and engineers who want to move from a purely application layer to an Agent architecture layer. The three-stage structure is relatively friendly to absolute beginners, and the hands-on projects can directly enrich a portfolio.

But if you already have Agent project experience, or have practical coding understanding of paradigms like ReAct and CoT, parts of the basics and advanced sections may feel too shallow. At that point, what's more valuable is the multi-agent collaboration system in the hands-on section, and whether the course covers engineering details in production environments such as error handling, cost control, and evaluation schemes—none of which were elaborated on in the original introduction.

Agent engineering details in production environments often create a bigger gap than prototype development. Common topics include: error handling and retry mechanisms, because tool calls may time out, return malformed output, or trigger rate limiting; cost control, because multi-turn reasoning and frequent tool calls significantly amplify token consumption, requiring caching, pruning, and tiered model strategies; and evaluation schemes, because an Agent's output is not a single answer but a trajectory of actions, which must be measured with metrics such as task success rate, step efficiency, and tool-call accuracy.

It also involves observability (recording each step of reasoning and action for troubleshooting), security boundaries (preventing tool misuse or prompt injection), and concurrency and state management. These topics are usually not covered in depth in introductory courses, but for developers who truly want to ship projects, they are precisely what determines whether an Agent can run stably.

Judging the Practical Value of a Free Course

This course is released for free on Bilibili, and the accompanying "leave 111 in the comments to get materials and source code" is a common lead-generation tactic that does not affect access to the main course content. For self-learners on a budget, using a structured free course to build a complete cognitive map of Agent development and then diving deeper into weak areas is a cost-effective path.

One thing to note: the course title's "become a master in a week" is clearly marketing rhetoric. The breadth of knowledge involved in Agent development—from prompt engineering to tool orchestration to multi-agent coordination—is hard to truly digest in a week. But as a starting point and roadmap for systematic learning, its module division and knowledge coverage are reasonable. The key is whether, after finishing, you can build a complete, usable Agent on your own—that is the only standard for testing learning outcomes.

One-line Summary

Breaking down the module design, differentiated value, and applicability boundaries of Bilibili's 100-episode AI Agent course.

Paragraph Summary

The article analyzes a 100-episode AI Agent development course released for free on Bilibili. The course opens by arguing that basic RAG and simple API calls are no longer enough, and that Agent development is becoming a dividing line in developer capability. It uses a three-stage structure: basics, advanced, and hands-on. The basics section builds a conceptual framework; the advanced section focuses on paradigms such as ReAct, CoT, and multi-agent collaboration; the hands-on section produces presentable work through three projects. Its differentiation lies in filling the gap between conceptual explanation and tool operation. The article notes the course suits beginners or developers moving toward Agent architecture, but experienced developers may find it shallow; production engineering details such as error handling, cost control, and evaluation schemes are not reflected in the introduction. "Become a master in a week" is marketing rhetoric, but as a systematic learning roadmap its structure is reasonable.