AI Learning Roadmap: From LLM to AI Agent, then to Skills

Many people learning AI start directly with tool usage: ChatGPT, Claude, Gemini, Cursor, Claude Code, Codex, OpenRouter, and various tools tried in rotation. This is certainly useful, at least it lets you quickly feel AI’s capabilities.

But if you stay at the level of “can use tools,” you will hit a bottleneck quickly: you know AI is powerful but do not know why it is; you know agents are hot but do not know how they actually execute tasks; you see Skills, MCP, workflow automation, but do not know how they relate to each other.

I recommend breaking AI learning into a clear roadmap:

Understand LLM → learn how to invoke models → learn Agents → master tool calling → establish workflows → distill Skills.

The focus of this roadmap is not to chase trends, but to build capabilities layer by layer. You do not need to train your own large model, and you do not need to build complex frameworks at the start, but you should at least know what problem each layer solves.

This article organizes a route suitable for everyday learners: from LLM fundamentals, to model applications, then AI Agent, and finally Skills and reusable workflows.

1. Clarify a Few Core Concepts First

Before formal learning, let’s sort out several concepts that are often confused.

1. LLM is the Foundational Capability

LLM means Large Language Model, which refers to large language models. Products like ChatGPT, Claude, Gemini, Qwen, and DeepSeek are all fundamentally built on LLM capabilities.

Learning LLM does not mean training a hundred-billion-parameter model from the start. At minimum, you should understand:

• Why text is split into tokens;
• What problems Transformer and attention roughly solve;
• Why a model can continue writing, summarize, translate, and generate code;
• Why context window limits a model’s memory;
• What pretraining, fine-tuning, RAG, and inference mean;
• Why hallucinations happen and why the model should not be treated as a search engine.

You can skip all the mathematical details at first, but you should build a mental map. Otherwise, when you later study agents, tool calling, and context management, you may only memorize terms without understanding the core logic.

2. Model Applications Is about Integrating LLMs into Real Tasks

After understanding LLMs, the next step is not immediately to study complex agents. You should first learn how to call models.

Basic model applications include:

• Calling APIs;
• Setting system prompts;
• Controlling parameters such as temperature and max tokens;
• Handling input and output;
• Performing text classification, summarization, translation, information extraction;
• Using a tokenizer to estimate tokens;
• Loading models with open-source model libraries and running inference.

This layer may look simple, but it is very important. Many agent-related problems are not about how sophisticated the agent is, but that basic input/output, context, and format constraints were not done right.

3. Agent Is an Execution System with Goals and Tools

A regular chatbot mainly answers questions, while an AI Agent focuses more on “executing tasks around a goal.”

A simplest Agent loop usually includes:

1. Receive user task; 2. Understand the goal; 3. Select tools; 4. Execute actions; 4. Observe results; 5. Adjust again based on results; 6. Continue until the task is completed or it is judged no longer possible to continue.

Tool calling, function calling, ReAct, planning, memory, context compression, multi-agent collaboration—these all unfold around this loop.

You can understand Agent as this: LLM is no longer just “talking,” but starts to “read files, call tools, run commands, modify code, and produce results.”

4. Skills Is the Distillation of Experience into Reusable Capability

Skills can be understood as “specialized instructions, scripts, templates, and resources prepared for AI use.”

If Tool Calling solves “how a model calls one tool,” Agent solves “how a model takes sustained action toward a goal,” then Skills solve “how to let AI repeatedly reuse a mature process for a class of tasks.”

For example:

• Resume writing can have a resume skill;
• PPT creation can have a slides skill;
• Excel handling can have a spreadsheet skill;
• Editing MDX articles can have a content editing skill;
• Gathering web sources can have a research skill;
• Analyzing divination cases and generating structured reports can also be distilled into your own specialized skill.

A good skill does not have to be complex, but it must be specific enough. It should solve a clear task type, instead of putting everything into one universal instruction manual.

2. Phase One: Learn LLM Fundamentals

The goal of the first phase is not to become a model training expert, but to build basic understanding of large language models.

At least you should know: the model is not a database, answer generation is not table lookup; context window is not long-term memory; tokens are not normal characters; model output is not inherently reliable truth, but probabilistic text generation.

1. Recommended Resource: Happy-LLM

Happy-LLM is a systematic LLM learning tutorial from Datawhale, suitable for Chinese readers to start learning. It starts from NLP fundamentals and gradually covers LLM architecture, training process, mainstream frameworks, and application directions.

Its advantage is complete Chinese material and a clear path; it does not throw beginners into papers and English docs from the start.

Key topics to focus on:

• NLP and Transformer basics;
• LLM architecture and training process;
• core concepts such as tokenizer, embedding, attention;
• application directions including fine-tuning, RAG, Agent;
• transitioning from theoretical understanding to code practice.

If you are a beginner, do not try to finish everything at once. Establish a general framework first. It is enough to understand 60% on the first pass, then revisit details when doing projects.

2. Recommended Resource: minGPT

minGPT is a minimalist GPT implementation by Andrej Karpathy. It is not for engineering performance, but to let learners understand GPT’s core structure.

Compared with large frameworks, minGPT’s code is shorter and cleaner, suitable for understanding the core processes of Transformer, attention, training loops, and text generation.

Key topics to focus on:

• minimal GPT implementation;
• code structure of a Transformer block;
• how token input becomes a probability distribution of the next token;
• training loop and inference generation;
• the model is not magic, but a decomposable computation structure.

If you already know some Python and PyTorch, minGPT is worth studying. You do not need to reproduce training fully, but at least you should know what GPT’s core code looks like.

3. Practice Tasks in This Phase

In this phase, do not just collect resources. Do a few small exercises:

• Explain what a token is in your own words;
• Draw a simplified diagram of Transformer flow;
• Run a minimal text generation demo;
• Change temperature once and observe output variation;
• Compare how the same question behaves in short context vs. long context;
• Write up notes on why LLMs generate hallucinations.

The biggest risk when learning AI is reading concepts without practicing. Even just running a small demo is more useful than saving ten tutorials.

3. Phase Two: Learn Model Application and Engineering Invocation

After understanding LLM fundamentals, the second phase is to learn how to integrate models into real tasks.

The key here is not “training models,” but “using models.” For most regular developers, content creators, and independent site owners, what is truly useful is: how to call models, constrain output, connect tools, process files, and complete business workflows.

1. Recommended Resource: Hugging Face Transformers

Hugging Face Transformers is a widely used open-source model library covering text generation, classification, question answering, translation, speech, vision, and many other models. It is suitable for learning how to load models, use tokenizers, call pipelines, and integrate open-source models into your own projects.

Key topics to focus on:

• tokenizer and model loading;
• quick inference with pipeline;
• running models locally;
• model input/output formats;
• basics of fine-tuning and deployment.

In the official Hugging Face documentation, pipeline is designed as a relatively simple inference interface, making it easy for beginners to complete tasks like text classification, QA, and summarization quickly. The tokenizer docs are also worth reading, because many issues about context length, cost estimation, and truncation are fundamentally token handling issues.

2. Learn API First, then Agent

Many people want to build all-in-one Agents right away, yet still have not clarified basic API calls, message formats, and structured output. This easily becomes a “looks sophisticated but is actually fragile” project.

In this phase, at least master:

• how to send a model request;
• how to set system, user, and assistant messages;
• how to make the model output JSON;
• how to handle model outputs that do not match the format;
• how to calculate token cost;
• how to persist conversation history;
• how to segment, summarize, and merge in long-text tasks.

These are foundational but critical. The essence of Agent is not magic—it is still built on repeated model calls.

3. Practice Tasks in This Phase

You can build several practical mini projects:

• Write an article summarizer;
• Write a Markdown heading generator;
• Write a web content structured extraction tool;
• Write a tool that converts job descriptions into resume optimization suggestions;
• Write a script that splits long articles, summarizes, and merges;
• Write a simple cost tracker that records how many tokens each call consumed.

These projects are not flashy, but highly practical. After doing these, you will understand much better why context, state, tools, and structured output are so important when you start learning Agents.

4. Phase Three: Learn AI Agent

Once you can call models, you can enter the Agent phase.

The challenge of an Agent is not to make the model “talk smarter,” but to make it reliably complete tasks. It should know when to call tools, when to read files, when to continue, when to stop, when to confirm with the user, and when to admit failure.

1. Recommended Resource: Hello-Agents

This site also has a companion guide: “Hello Agents: Build an AI Agent from Scratch”, which adds practical operational explanations.

Hello-Agents is an open-source agent learning tutorial by Datawhale, aimed at helping learners understand and build AI Agents from scratch. It emphasizes core principles, architecture patterns, and hands-on implementation instead of only teaching you to use ready-made platforms.

Key topics to focus on:

• basic Agent concepts;
• tool calling and task execution;
• ReAct thinking and action loop;
• memory and context management;
• multi-agent collaboration;
• paths from demo to application system.

If you want to truly understand Agents, rather than only dragging a few nodes around, this kind of tutorial is more valuable than using platforms only.

2. Recommended Resource: OpenAI Agents SDK

OpenAI Agents SDK is an agent development framework provided by OpenAI, suitable for learning how to more systematically organize Agents, tools, handoff, guardrails, tracing, and structured output.

Several concepts are especially important:

• handoffs: let one Agent transfer a task to another more specialized Agent;
• guardrails: add safety and format constraints to inputs, outputs, or tool calls;
• tracing: record model calls, tool calls, handoffs, and other execution events to aid debugging and observability;
• structured output: make model output more stable as data structures.

The value of such frameworks is not fewer lines of code; it is that the agent execution process becomes easier to debug, maintain, and scale.

3. Recommended Resource: LangGraph

LangGraph is an Agent orchestration framework in the LangChain ecosystem, suitable for building stateful, iterative, and branching complex Agent workflows. It abstracts agent execution into graph structures, making it suitable for multi-step tasks, long-running state, human intervention, and complex automation flows.

Key topics to focus on:

• graph-based workflow;
• state management;
• nodes and edges;
• loops, conditional branching, and resumability;
• multi-agent collaboration flows.

If a simple Agent is one loop, LangGraph is better for splitting complex tasks into multiple nodes: searching, reading, analyzing, writing, reviewing, editing, outputting. Each node handles one task, and state is passed across nodes.

4. Common Pitfalls When Learning Agents

The most common mistakes when learning Agents are:

• building an all-in-one Agent right away;
• not logging tool call results;
• no error handling;
• no tool permission restrictions;
• no stop conditions;
• no context length management;
• no separation between planning, execution, and checking;
• no logging or tracing;
• writing long prompts without structured flow.

Useful Agents are usually not “can do everything,” but “can stably complete work within a clearly defined scope.”

5. Practice Tasks in This Phase

Start with small Agents:

• File organization Agent: read file names and classify by rules;
• Web summary Agent: search sources, organize key points, output a summary;
• Code review Agent: read a file and find obvious issues;
• Resume optimization Agent: read JD and resume, then output improvement suggestions;
• Article editing Agent: polish MDX articles according to fixed rules;
• Research Agent: search, extract, synthesize, and generate reference sources.

Each Agent should define clear inputs, outputs, tools, constraints, and stop conditions. Do not chase multi-agent collaboration at first; first run a single Agent loop reliably.

5. Phase Four: Learn Skills and Workflow Distillation

Once you can build some small Agents, you will notice one problem: many tasks repeat.

For example, every time you write an article, you need to check frontmatter, heading hierarchy, SEO description, reference links, and body formatting. Every time you process a resume, you need to check job match, project expression, keywords, and quantified outcomes. Every time you handle spreadsheets, you need to check fields, format, metrics conventions, and output templates.

If these repeated experiences are described with ad hoc prompts each time, it gets tiring. The value of Skills is here: distill a category of task into a fixed capability, so AI can use a more mature process automatically when similar tasks reoccur.

1. Recommended Resource: Anthropic Skills

For practical usage scenarios of Skills, you can refer to “Skill Topic Introduction: From Prompts to Reusable AI Workflows”.

Anthropic has published public Agent Skills materials and examples. These materials show that Skills are usually organized as folders and can include documentation, scripts, templates, and other resources, allowing Claude to load relevant capabilities for specific tasks.

The key takeaway from Anthropic’s explanation is that Skills are not just prompts; they can include instructions, code, and resources as capability packages. They help AI perform more stably on tasks like document processing, data analysis, brand guidelines, and professional workflows.

Key topics to focus on:

• how Skills are triggered;
• how to write SKILL.md or instructions;
• how to specify applicable scenarios clearly;
• how to include scripts, templates, and references into a Skill;
• how to avoid skills that are too big and too generic;
• how to handle safety and permissions.

2. Recommended Resource: awesome-skills-cn

awesome-skills-cn is a Chinese Skills resource collection project that gathers and organizes content related to Claude Skills, OpenClaw Skills, and general Agent Skills.

It is useful for seeing how others design Skills: directory structure, instruction writing, task boundary definition, and script/template organization.

But do not only collect resources. The truly effective way to learn is to reference others’ structures and then write a Skill for your own real tasks.

3. What a Good Skill Should Look Like

A good Skill usually includes:

• clear applicable scenarios: when to use it;
• clear inputs: what users need to provide;
• clear outputs: what should be generated;
• stable steps: what to do first, then next;
• format requirements: titles, tables, JSON, Markdown, file naming, etc.;
• constraints: what cannot be done, which information must be retained;
• examples: provide AI with a reference template;
• required scripts: hand deterministic and repetitive work to code.

A Skill should never be written as a “universal workflow.” The more universal it is, the easier it is to lose control. A truly useful Skill is usually small and specialized.

4. Practice Tasks in This Phase

Pick one task from your actual workflow:

• MDX article polishing Skill;
• Resume optimization Skill;
• SEO title generation Skill;
• Web source organization Skill;
• Excel data cleaning Skill;
• Project README generation Skill;
• Divination case structured report Skill;
• Job application email drafting Skill.

It is best to first write a minimal version that solves one clear problem. Once it runs smoothly, add templates, scripts, and validation rules gradually.

6. Recommended Learning Order

If you are a beginner, follow this order:

1. Week 1: Build an LLM Map

Use Happy-LLM to build overall understanding, with focus on NLP, Transformer, token, training, and inference basics.

Do not try to master all details in the first week. The goal is to understand what modules exist in the field and how they relate.

2. Week 2: Study a Minimal GPT Implementation

Use minGPT to observe core GPT structure. The key is not to memorize code, but to understand: how input becomes embedding, what attention broadly does, and how the model outputs the probability of the next token.

If you cannot understand all the code, that is fine. Focus on the overall structure first, then gradually strengthen PyTorch basics.

3. Week 3: Practice Model Invocation

Use Hugging Face Transformers or model APIs to complete a few small tasks, such as summarization, classification, translation, information extraction, and headline generation.

This week should focus on understanding input/output, tokens, context length, structured output, and error handling.

4. Week 4: Learn the Basic Agent Loop

Use Hello-Agents to understand the Agent task execution flow. Focus on tool calling, observing results, continued decision-making, and stopping conditions.

You can also write a minimal Agent: make it read a text file, summarize content, and generate a Markdown output.

5. Week 5: Learn Engineering-Oriented Agent Frameworks

Study OpenAI Agents SDK or LangGraph. The former helps you understand engineering concepts like Agent, tools, handoff, guardrails, tracing; the latter helps with state machines, graph structures, and multi-step orchestration.

Do not dive deep into both at the same time. First make one run through successfully, then learn the other.

6. Week 6: Turn Repetitive Tasks into Skills

Choose a task you do often and write it as a Skill. For example, turn “MDX article polishing rules” into fixed instructions: how to write frontmatter, how to number headings, how to format body content, how to place references.

This is the step that helps you truly understand that AI capability is not just temporary conversation—it can be organized, reused, and standardized.

7. The Starter Stack I Personally Recommend

If you are only picking a few projects to start, I recommend this stack:

If you have no foundation at all, follow Happy-LLM → Hugging Face Transformers → Hello-Agents first. After you gain some code and API experience, add minGPT, OpenAI Agents SDK, LangGraph, and Skills.

8. Don’t Let Your Learning Path Drift

A few practical judgments to close with.

1. Most People Do Not Need to Train Their Own Large Model at the Start

Training models is important, but for most learners, the most useful first step is mastering invocation, composition, and engineering application. The capability you can use immediately is integrating large models into your workflow, not imagining you can build your own ChatGPT from day one.

2. Don’t Obsess Over Toy Projects

There are many cool demos in the AI era: auto-book writing, auto-earning, fully automated companies, general-purpose Agents. Some are inspiring, but many are unstable and not worth the amount of time most people should invest.

To judge whether a project is worth learning, check three points:

• whether the core principle can be explained;
• whether it can run a real task;
• whether it can be transferred into your workflow.

If a project only looks good in screenshots but does not distill capability, it is not worth spending much time on.

3. The Most Important Thing Is to Build Your Own Workflow

The true value of AI learning is not how many model leaderboards you collect or how many new terms you memorize, but gradually forming your own workflow.

For example:

• While writing articles, AI helps you research, structure, and refine language;
• while learning programming, AI helps you explain code, generate tests, and fix bugs;
• while building websites, AI helps you write components, check SEO, and organize content;
• while job hunting, AI helps you analyze JDs, optimize resumes, and prepare interviews;
• while doing research, AI helps you gather sources, synthesize viewpoints, and generate citation lists.

When these processes stabilize, you are no longer just “using AI,” but building your own AI work system.

9. Conclusion: From User to Builder

The core of this roadmap can be summarized in one sentence:

First understand the model, then call the model; first do simple tools, then build Agents; first complete tasks, then distill Skills.

Do not rush to chase every new concept. AI changes quickly, but the underlying capability chain is clear: understand LLMs, use APIs, do tool calling, manage context, design workflows, and distill experience into Skills.

By following this path, you will move from being just an AI user to becoming an AI application builder.

FAQ

Do you need programming foundations to learn AI?

Not necessarily. Understanding LLM concepts, learning API calls, and mastering Agent principles require basic Python; but if you want to implement custom Agents or write Skills, being able to read code will significantly improve your learning efficiency. The recommended path is to start with concepts and tool usage, then gradually build programming skills.

What is the difference between LLM and AI Agent?

LLM is a foundational language model that handles understanding and generating text; AI Agent adds goal setting, tool calling, memory, and multi-step reasoning on top of an LLM, forming an execution system. To put it simply: LLM is the “brain,” and Agent is the “executor that uses tools to complete tasks.”

What is the difference between Skill and a prompt?

A prompt is a one-time input instruction that solves “how to say it this time.” A Skill is a reusable capability package, usually containing documentation, scripts, templates, and so on, which solves “how to stably reuse this for similar future tasks.” Their uses differ; a Skill is closer to an installable workflow module.

Where should I start this learning roadmap?

Start with Phase One (LLM fundamentals) and Happy-LLM, first building an overall conceptual framework; one pass understanding 60% is enough. Then move to model applications (API invocation) → the basic Agent loop (Hello-Agents) → Skills distillation, with practical exercises at each phase for best results.

References

• Datawhale Happy-LLM: Build Large Models from Scratch
• Andrej Karpathy minGPT: Minimal GPT Implementation
• Hugging Face Transformers Quickstart
• Hugging Face Transformers Pipeline Documentation
• Hugging Face Transformers Tokenizer Documentation
• Datawhale Hello-Agents: Build Agents from Scratch
• OpenAI Agents SDK: Handoffs
• OpenAI Agents SDK: Guardrails
• OpenAI Agents SDK: Tracing
• LangGraph GitHub: Build resilient agents
• LangGraph Official Introduction
• Anthropic: Equipping agents for the real world with Agent Skills
• Anthropic Skills GitHub
• Claude Agent Skills Official Course
• Agent Skills Overview
• awesome-skills-cn: Chinese Skills Resource Collection