A Beginner's Guide to AI Agents: Two Learning Paths for Developers and Practitioners

AI Agents are undoubtedly one of the hottest technology trends of the past year or two. From office automation to complex task orchestration, Agents are reshaping how we interact with AI. Unlike traditional AI models (such as ChatGPT's single-turn Q&A), AI Agents possess the ability to autonomously plan, call tools, manage memory, and perform multi-step reasoning—they can break down a complex task into multiple subtasks, sequentially calling search engines, code interpreters, databases, and other tools to accomplish goals. This "perceive-think-act" loop enables Agents to evolve from "passive responders" to "active executors," and is widely regarded as one of the core paradigms for deploying large language models in real-world applications. But for beginners starting from zero, the overwhelming flood of tutorials and technical jargon can make it hard to know where to begin.

This article, based on the hands-on experience of a tech content creator on Bilibili, outlines a clear learning roadmap for AI Agents. The core idea is simple: First figure out who you are, then choose your path.

The First Step Before Learning AI Agents: Classify Yourself

Before diving in, you need to think clearly about one question: Do you want to be a developer or a practitioner?

The learning paths for these two roles are fundamentally different, and mixing them together will only waste time and lead you astray.

• Group One: Technical background, aiming to build at the infrastructure level. These people may need to port open-source projects, rewrite source code, or even develop their own Agent frameworks in the future—requiring a solid engineering foundation.
• Group Two: Pure practitioners who just want to build things for themselves. For example, quickly spinning up a project or assisting with daily work tasks—prioritizing efficiency over understanding underlying principles.

Getting this positioning right is the prerequisite for avoiding 99% of detours. Let's break down both AI Agent learning paths below.

The Developer Path: From Python Basics to Source Code Mastery

If you come from a programming background, or aspire to become a developer in the AI Agent space, this path requires steady, step-by-step progress.

Step 1: Build a Solid Python Foundation

Everything starts with Python. You need to master basic syntax, commonly used frameworks, and data processing capabilities. This is the foundation for all subsequent large model development—there are no shortcuts. Python has become the language of choice in AI not just because of its clean and easy-to-learn syntax, but because it has the largest AI/machine learning ecosystem—from data processing with NumPy and Pandas, to deep learning with PyTorch and TensorFlow, to LLM applications with LangChain and Transformers. Nearly all mainstream AI tools support Python as their primary language.

Step 2: Jump Straight into Large Language Models

Here's a noteworthy perspective—you can skip traditional NLP fundamentals and go directly into large model learning. For those whose goal is application development, rather than spending extensive time on word vectors, RNNs, and other classical NLP theory, it's better to quickly engage with the tech stack that's actually being used today. Traditional NLP involves tokenization, named entity recognition, syntactic parsing, and a series of other techniques. While these form the academic foundation of natural language processing, in the era of large models, many classical tasks have been unified under the Transformer architecture. For goal-oriented application developers, starting directly with large models is the more efficient strategy.

During the large model phase, focus on mastering the following:

• Transformers library: This is the core tool of the Hugging Face ecosystem and practically standard equipment for working with large models. The Transformers library provides a unified API interface supporting the loading and use of tens of thousands of pre-trained models (including BERT, GPT, LLaMA, Mistral, etc.), covering tasks like text generation, classification, translation, and summarization. The broader Hugging Face ecosystem also includes Datasets (dataset management), PEFT (parameter-efficient fine-tuning), Accelerate (distributed training acceleration), and Hub (model sharing platform), forming a complete toolchain from data preparation to model training and deployment.

• Model fine-tuning, quantization, and deployment: Learn how to run a large model, optimize it, and compress it to work within limited resources. Fine-tuning refers to secondary training of a pre-trained large model using domain-specific data to better adapt it to specific tasks. Current mainstream fine-tuning methods include full-parameter fine-tuning and parameter-efficient fine-tuning (such as LoRA and QLoRA), the latter adjusting only a tiny fraction of model parameters, dramatically reducing GPU memory requirements. Quantization compresses model parameters from high-precision floating point (e.g., FP16) to low-precision formats (e.g., INT8, INT4), reducing model size and inference resource consumption, enabling large models to run on consumer GPUs or even CPUs. Deployment involves using inference frameworks like vLLM, Ollama, and TGI to serve models as API services.

• Knowledge base construction (RAG): Retrieval-Augmented Generation capabilities that allow models to answer questions using external knowledge. RAG is a technical architecture that combines external knowledge retrieval with large model generation capabilities. Its core workflow is: first, enterprise documents and knowledge bases are chunked and converted into vectors (Embeddings), stored in vector databases (such as Milvus, Chroma, FAISS); when a user asks a question, the system first retrieves the most relevant knowledge fragments through semantic search, then feeds these fragments as context into the large model, which generates answers based on the retrieved factual information. RAG effectively mitigates the "hallucination" problem (fabricating facts) in large models and solves the knowledge cutoff date limitation, making it the most mainstream knowledge enhancement solution in enterprise AI applications today.

Step 3: Choose an Open-Source Agent Framework for Deep Study

After building a solid model foundation, it's time to enter Agent framework learning. The recommendation here is very clear: Choose an open-source framework, such as LangChain or other mainstream open-source ecosystems, and deeply study its architectural design.

LangChain is currently one of the most popular frameworks for building LLM applications. It modularizes and encapsulates LLM calls, prompt management, tool integration, memory mechanisms, and chain-based invocations, greatly lowering the barrier to building AI Agent applications. Beyond LangChain, mainstream open-source Agent frameworks include: LlamaIndex (excels at data indexing and RAG scenarios), AutoGen (Microsoft's multi-Agent collaboration framework), CrewAI (focused on multi-Agent role-playing and task division), and Dify (low-code AI application development platform). These frameworks each have their own strengths, but share a similar core philosophy—through a "planning-tool calling-reflection" loop, they transform large models from mere text generators into intelligent agents capable of autonomously completing complex tasks. Which framework you choose depends on your application scenario and technical preferences.

Why emphasize open source? Because as a developer, you'll most likely need to port open-source projects and transform them into your own solutions down the road. With closed-source tools, you can only stay at the "know how to use it" level without going deeper. The advantage of open-source frameworks is that you can see the implementation logic of every line of code, understand the trade-offs the authors made during design—this is crucial for developing architectural thinking and engineering capabilities.

Key Competency: Deep Source Code Reading

This step is most easily overlooked by beginners, yet it's the dividing line between developers and users. You need to not only learn how to use a framework, but dive into the source code level to understand the design philosophy.

Specifically, you need to figure out:

• What core algorithms does this framework's source code use? What problems are these algorithms solving? For example, Agent task planning typically involves the ReAct (Reasoning + Acting) pattern—having the model alternate between "thinking" and "acting," with each step deciding the next action based on the previous step's observations. Understanding the implementation details of these core patterns is essential for flexible application and customization in real projects.
• What modules has it designed? What's the responsibility of each module? A typical Agent framework usually includes a Planning module, Memory module, Tool Use module, and Reflection module. Understanding the boundaries and interactions between these modules is key to mastering the framework.
• If I need to modify it in the future, where should I start?

This process may take a lot of time, but it's absolutely worth it. Only by understanding the underlying design can you truly master and transform these tools, becoming a real AI Agent developer.

The Practitioner Path: Leverage AI Coding Tools for Quick Results

If you don't want to dig into underlying principles and just want to quickly build things for yourself, this path is much lighter—simply make good use of mature AI coding tools.

Here are two mainstream tools to choose from:

• Claude Code: A command-line AI programming assistant from Anthropic that can directly read your project codebase, understand context, and perform code writing, debugging, and refactoring operations. It has strong coding capabilities and is particularly good at handling complex development tasks in large code repositories.
• Codex: OpenAI's programming tool (presented as a code interpreter and programming assistant within ChatGPT), with powerful code generation and logical reasoning capabilities—another mainstream choice.

Beyond these two, the market also offers similar products like Cursor (an AI programming IDE based on VS Code), GitHub Copilot (code auto-completion tool), and Windsurf. Their common feature is: users only need to describe requirements in natural language, and the tool automatically generates runnable code, even performing multiple rounds of iterative modifications—enabling people without deep programming skills to quickly build applications.

Both tools work remarkably well in practice. Whether it's helping you write code, handle daily office tasks, process images, or edit videos, they've got you covered. The key is choosing the one that best fits your specific needs.

For practitioners, there's no need to reinvent the wheel. Putting your energy into "solving real problems with tools" is the most efficient path.

Summary: Find Your Position, and Learning AI Agents Becomes Much Smoother

Looking back at the entire learning roadmap, the core logic is very clear:

1. First identify your positioning: Developer or practitioner—this determines completely different learning directions.
2. Developers take the depth route: Python fundamentals → Large models (Transformers, fine-tuning, deployment, RAG knowledge bases) → Source-code-level study of open-source Agent frameworks.
3. Practitioners take the efficiency route: Choose either Claude Code or Codex, get started quickly, and solve real-world needs.

There's no single correct answer for learning AI Agents—the key is matching your goals. If you just want to boost efficiency, there's no need to drown in an ocean of source code; but if you want to go deep in this field, then reading source code and understanding principles are unavoidable required courses.

It's worth noting that these two paths aren't completely isolated. Many excellent practitioners gradually develop interest in the underlying mechanisms through using tools and transition to the developer path; many developers, after going deep into the technology, actually become better at using tools to quickly validate ideas. The key is finding the entry point that best suits you at your current stage—as your capabilities and interests evolve, you can always adjust direction.

Find your right positioning, choose the right tools and path, and you'll truly be able to avoid detours and efficiently get started with AI Agents.