This roadmap is designed for Chinese developers learning Agents:
learn-claude-codebreaks down the essence of an Agent through a minimal loop and tool calling, whilehello-agentsfills in the bigger picture with a complete Chinese tutorial covering frameworks, protocols, and hands-on projects. Together, they address three common pain points: getting started, gaining practical experience, and dealing with fragmented documentation. Keywords: Agent, open source tutorial, agent development.
The technical snapshot highlights the strengths of both projects
| Project | Primary Language | Key Protocols/Paradigms | Stars | Core Dependencies / Characteristics |
|---|---|---|---|---|
| learn-claude-code | Not explicitly specified; leans toward a script-based implementation | Agent Loop, Tool Calling, Context Compression, Multi-Agent Collaboration | 54.7k | Minimal code, Claude Code-inspired approach, Chinese documentation |
| hello-agents | Python-first tutorial stack | ReAct, Plan-and-Solve, MCP, A2A, Agentic-RL | 38.3k | Produced by Datawhale, fully Chinese tutorial, runnable examples |
These two projects define a high-leverage path for learning Agents
Many beginners dive straight into heavyweight frameworks when learning Agents. As a result, they memorize interface names without understanding why an Agent can plan, call tools, and execute iteratively. The real learning bottleneck is not that the model is too hard. It is that the abstraction layer is too high.
The two projects recommended in the original article neatly cover the two core stages of Agent learning: first, understand what a minimum viable Agent really is; then, learn how to build a practical engineering system around it. This path is more reliable than blindly chasing the latest framework.
AI Visual Insight: This image serves as the article cover and visually emphasizes the theme of going from zero background to systematic Agent learning. It communicates learning-path selection rather than specific architectural details, so it functions more like a course guide cover than a technical implementation diagram.
You should learn a minimal Agent first, then move to a complete engineering stack
A minimal implementation helps developers see the smallest closed loop of an Agent: receive a goal, generate a plan, call tools, read feedback, and continue the loop. An engineering-oriented tutorial then adds memory, protocols, evaluation, and multi-agent collaboration.
while True:
action = llm.plan(task, context) # Let the model decide the next step based on the task and context
result = tools.run(action) # Call external tools to execute the action
context.append(result) # Write the execution result back into the context
if action.is_done(): # Exit the loop when the task is complete
breakThis pseudocode captures the minimal working mechanism of an Agent: loop, tools, and feedback.
learn-claude-code is ideal for understanding the minimal essence of an Agent
The greatest value of learn-claude-code is not that it has many features. It is that it is deliberately restrained. Inspired by the interaction model of Claude Code, it strips away unnecessary abstractions so developers can face the Agent core loop directly.
For beginners, this kind of project is extremely important. Once you rely too early on highly abstracted frameworks such as LangChain, you can easily mistake “tuning the framework” for “understanding Agents.” This project emphasizes exactly the opposite: One loop & Bash is all you need.
AI Visual Insight: This image shows the project introduction interface and the main learning entry points, highlighting the course-like organization of the repository. For learners, that means it is not a single demo, but an experimental tutorial that incrementally breaks down mechanisms.
The three learning benefits of learn-claude-code are immediate and practical
First, it uses a progressive course structure. Across 12 lessons, each section introduces only one new mechanism at a time, such as tool calling, context compression, or multi-agent collaboration. This allows you to observe how each capability is layered onto the same core loop.
Second, it is friendly to Chinese developers. The original article explicitly notes that the project includes complete Chinese documentation. That means you can spend your cognitive effort on understanding the mechanism itself rather than translating terminology.
Third, it is especially effective at removing the mystique around Agents. You begin to see that many Agent capabilities do not require a massive framework. They come from a well-designed loop and tool interface.
# Clone the project and enter the directory
git clone https://github.com/shareAI-lab/learn-claude-code.git
cd learn-claude-code
# Install dependencies and run the example according to the project documentation
# Placeholder command shown here; follow the repository README for the actual steps
python main.pyThese commands show that the barrier to entry is low, making it suitable for quickly validating the core mechanisms hands-on.
hello-agents is better suited for building complete engineering understanding and practical skills
Once you understand the basic Agent loop, the next question is no longer “How does it run?” but “How does it run reliably, scalably, and in a way that can be evaluated?” That is exactly where hello-agents fits.
It is a systematic Agent tutorial for Chinese developers, covering foundational theory, classic paradigms, protocol communication, enterprise capabilities, and project delivery. Compared with a concise demo, it looks more like a complete course plus lab manual.
The value of hello-agents comes from system completeness rather than isolated tricks
The original content notes that this project spans five major modules: fundamentals, core practice, advanced topics, project delivery, and outcome validation. This structure is ideal for building a panoramic understanding rather than absorbing concepts in fragments.
It is especially worth noting that the project includes key topics for enterprise scenarios, such as MCP, A2A, memory retrieval, context engineering, and performance evaluation. That means it does not just teach you how to “write an Agent.” It trains you to “design a usable Agent system.”
AI Visual Insight: This image presents the modular tutorial structure and reflects a layered design that goes from foundational theory to project delivery. Technically, this shows that the project is not a collection of isolated examples, but a complete knowledge tree spanning paradigms, protocols, evaluation, and capstone work.
modules = [
"Fundamentals", # Build foundational understanding of LLMs and Agents
"Core Practice", # Implement classic Agent paradigms
"Advanced Topics", # Learn enterprise capabilities such as protocols, memory, and evaluation
"Project Delivery", # Complete development for real application scenarios
"Outcome Validation" # Verify mastery through a capstone-style project
]This structured list summarizes the curriculum design logic behind hello-agents.
The recommended four-week roadmap is easier for most developers to execute
If your goal is to quickly build transferable Agent development skills, the best strategy is not to browse ten projects at once. It is to move steadily along a single closed-loop path.
In Week 1, focus on learn-claude-code. The goal is not just to finish it, but to fully understand the evolution of the 12 mechanisms so you know why an Agent needs loops, tools, feedback, and context management.
The next three weeks should shift into systematic hands-on practice
From Week 2 to Week 4, switch to hello-agents. Prioritize completing at least one full example, and use the process to fill in environment setup, protocol understanding, and common troubleshooting. This gives you more than passive comprehension. It gives you the ability to reproduce a project independently.
study_plan = {
"Week 1": "Finish learn-claude-code and understand the minimal Agent closed loop",
"Weeks 2-4": "Study hello-agents and complete at least one hands-on project"
}This roadmap emphasizes understanding the essence first and then building engineering capability.
For Chinese developers, choosing the right tutorial matters more than chasing concepts
These two types of projects deserve priority not only because they have high star counts, but also because they solve three high-frequency pain points: not knowing how to start from zero, understanding concepts without being able to implement them, and struggling to learn consistently from fragmented English materials.
From a learning-efficiency perspective, learn-claude-code breaks down the foundational principles of Agents, while hello-agents builds the upper floors of systematic knowledge. Together, they form a clear main path from beginner to advanced practitioner.
FAQ
Q1: If I am a complete beginner, should I learn a framework first or a minimal implementation first?
Start with a minimal implementation. You need to understand the smallest Agent closed loop before looking at how frameworks package those capabilities. Otherwise, you can easily stop at “I can call the API” without understanding the mechanism.
Q2: What is the relationship between learn-claude-code and hello-agents?
The former focuses on breaking down first principles and helping you remove the mystique quickly. The latter focuses on system building and helps you fill in protocols, hands-on practice, evaluation, and project delivery skills. They are sequential and complementary, not substitutes.
Q3: Can I study only one of them?
Yes, but the outcome will differ. If you only want to quickly understand the essence of Agents, prioritize learn-claude-code. If your goal is to build complete projects independently, you should eventually continue with hello-agents.
Core summary: This article reconstructs two Agent learning projects that are well suited for Chinese developers. learn-claude-code helps you understand the essence of Agents through minimal code, while hello-agents systematically fills in engineering skills, protocol literacy, and project-based practice. Together, they form an efficient path from beginner to advanced.