The Most Complete Agent App Development Roadmap on Bilibili: Five Steps from Zero to Engineering-Grade

AI is devouring almost every industry at ten times the speed of the internet. For ordinary programmers, the question is no longer "should I learn AI" but "how do I start from zero and actually be able to build AI projects." A Bilibili tutorial series billed as a complete 748-episode Agent application development course tries to answer this with a five-stage roadmap. Its core logic is simple: first get a nautical chart, then row the boat yourself — an unclear roadmap is the biggest reason people never start.

Why Ordinary Programmers Must Take the "Engineering Track"

This tutorial divides learning goals into three tiers: beginner, engineering, and research. It explicitly recommends that the vast majority of people focus only on the second tier — the engineering track. The reason is straightforward: the competency requirement for this tier is "able to modify, tune, build RAG, fine-tune, and build Agents," which corresponds to real job openings in companies, not publishing papers.

The beginner tier stays at calling APIs and running demos; the research tier requires solid math and experimental skills, and its return on investment isn't friendly to ordinary developers. The engineering tier sits in the middle, exactly where AI implementation currently lacks the most people: it doesn't require deriving backpropagation, but you can't just copy and paste either.

The tutorial repeatedly stresses one judgment: hesitation and waiting are the biggest costs of this era. AI knowledge is expanding exponentially, and every day you delay, the cost of catching up rises. There's an element of fear-mongering in this, but for those who have already decided to learn, scanning the whole picture first and then going deep is indeed a more time-efficient path.

Agent is the form that upgrades a large model from "passively answering questions" to "actively completing tasks." The formula the tutorial gives is "LLM + tools + planning": the LLM provides understanding and decision-making, tools let the model actually read files, query databases, send requests, and operate browsers, and planning lets the model break a big goal into multiple steps and execute them one by one. A typical Agent loop is "observe → think → act → observe again." For example, after receiving the task "help me organize this sales data," the model will decide on its own to first read the file, then call a calculation tool, and finally generate a report. Compared with an ordinary chatbot, the key difference of an Agent is that it can call external tools and adjust its next step based on the results, so it can handle real tasks that require multi-step collaboration — this is also the hottest area in AI application development today and the direction with the fastest-growing job demand.

The Five-Stage Roadmap: From Math to Agent Practice

The entire roadmap is split into five stages, and the tutorial's advice is to "run through it quickly first, then go back and fill in as needed," rather than grinding one stage to perfection.

Stages One and Two: The Fundamentals of Math and Deep Learning (Three Days Each)

Learn only the math you need: matrices, the intuition of gradient descent, probability and noise. The goal is to build intuition, not to grind problem sets. The deep learning fundamentals are likewise compressed to three days, focusing on three things — the essence of neural networks, the training loop, and a minimal CNN. This "minimum viable configuration" mindset runs through the entire process: get it running first, understand later.

Stage Three: Core Model Literacy

This stage covers CNN, RNN, Transformer, and Diffusion. The tutorial clearly states that the Transformer is the stock price of the LLM and is most worth your time. In other words, the earlier models just need to be understood, but the Transformer must be thoroughly mastered, because it directly determines whether you can understand the behavior of large models later.

The Transformer is an architecture proposed in the 2017 paper "Attention Is All You Need." It replaces the recurrent structure of RNNs with a self-attention mechanism, allowing the model to process an entire sequence in parallel and capture dependencies between any positions. Almost all current mainstream large language models (GPT, Claude, DeepSeek^Ad, Llama, etc.) are based on it, which is why the tutorial says "the Transformer is the stock price of the LLM." To understand it, you must at least grasp three concepts: attention (assigning weights to different positions in a sequence), multi-head (attending to different patterns in parallel from multiple subspaces), and positional encoding (injecting order information into the model). In addition, you need to distinguish the three variants — encoder, decoder, and encoder-decoder — and understand why it can keep improving performance as parameters and data grow. Master these, and you won't be confused when looking at large-model behaviors such as context, attention windows, and emergent abilities.

Stage Four: The Three Pillars of LLM Engineering

This is the hardest-core part of the whole roadmap and the core competitiveness of the engineering track.

• Fine-tuning: bias the model toward your style and data
• RAG: let the model know about your company's matters; the tutorial says it's enough for 80% of enterprise Q&A
• Inference deployment: the gateway into engineering-grade work

These three correspond to the three most common types of enterprise needs: customized output, private knowledge Q&A, and deployable services. Master them, and you basically have the ticket to build real AI projects.

RAG (Retrieval-Augmented Generation) means that before calling a large model, you first retrieve snippets relevant to the question from an enterprise's private knowledge base (documents, databases, tickets, etc.), splice these snippets into the prompt, and hand them to the model together, so the model answers based on real materials. Its value is that without retraining the model, it can answer private information it originally didn't know, while reducing hallucinations. The typical process is "document chunking → vectorization and indexing → vectorize the user's question → similarity retrieval → concatenate context → generate answer." Compared with fine-tuning, RAG only needs to replace the index to update knowledge, with low cost and traceability, so it has the widest coverage in scenarios such as enterprise Q&A, customer service, and internal knowledge assistants. This is why the tutorial says it can cover 80% of enterprise Q&A needs.

Inference deployment refers to actually running a trained or fine-tuned model to provide external services, involving engineering issues such as model quantization, memory optimization, concurrent scheduling, batching, and latency-throughput trade-offs. It's a different matter from "running a demo locally": a demo only cares whether the result is correct, while deployment cares about how many requests can be served per second, how fast a single response is, what the cost is, and what to do if the service goes down. Common inference frameworks include vLLM, TensorRT-LLM, Ollama, etc., while quantization commonly uses methods like INT8 and INT4 to compress model size. For engineering positions, being able to run a model stably and economically in production is often rarer than knowing how to call APIs, which is why the tutorial lists it as the gateway into engineering-grade work.

Stage Five: Agent Practice

The Agent formula is simplified into one sentence: LLM plus tools plus planning, so the model doesn't just talk but actually does things. This is currently the hottest direction in AI application development and the landing point of "Agent application development" in the title of this tutorial series. The earlier model literacy and the three engineering pillars are all paving the way for this step.

The Most Pitfall-Filled Way to Learn: Only Consuming Content, Never Experimenting

The most direct warning in the tutorial is: if you don't install PyTorch and don't write code, you haven't learned AI. It calls out the most pitfall-filled way to learn — only watching videos, only bookmarking tutorials, only reading other people's summaries, never running anything yourself.

The accompanying methodology is also very concrete:

• Don't struggle to read DeepSeek or GPT on your own; it is your 24/7 teacher
• If it can't teach you, make it speak plain language
• Build a minimal demo and read the errors line by line
• The more specific your question, the faster you improve

The essence of this approach is to treat AI as the learning tool itself, rather than the object of study. When you encounter code, errors, or concepts you don't understand, directly ask the model to explain, rewrite, or give examples — much faster than digging through documentation. The premise is that you have to start doing things first, so the problem becomes specific enough to ask about.

Who This Roadmap Is For, and Who It Isn't

Frankly speaking, this roadmap involves clear trade-offs. It sacrifices depth in math and theory in exchange for speed of getting started, making it suitable for developers who are already writing code and want to transition to AI engineering positions as quickly as possible. If your goal is to read papers and do research, three days of math is obviously not enough.

Also, "from beginner to master in seven days" is typical clickbait. A quick run through the five stages may only take a few weeks, but the "engineering-grade" ability at each stage needs repeated refinement in real projects. A roadmap can solve the problem of "not knowing what to learn"; it can't solve the problem of "whether you've practiced enough."

The judgment truly worth remembering comes from the end of the tutorial: not everyone will make money from this wave, but those who seriously invest will be pushed forward. Once the direction is clear, all that's left is to row.

One-line Summary

A 748-episode Agent tutorial on Bilibili offers ordinary programmers a five-stage AI engineering learning roadmap

Paragraph Summary

This article introduces a 748-episode Agent application development tutorial on Bilibili. Its core claim is that ordinary programmers should focus on the "engineering track" rather than the beginner or research track, aiming to be able to modify, tune, build RAG, fine-tune, and build Agents. The tutorial splits the learning path into five stages: minimum math, deep learning fundamentals (three days each), core model literacy, the three pillars of LLM engineering, and Agent practice, emphasizing a quick first pass followed by filling in as needed, with the Transformer most worth your time. The article also points out that the most pitfall-filled way to learn is only consuming content without experimenting, and suggests treating GPT as a 24-hour teacher and building a minimal demo to debug line by line. Finally, it frankly acknowledges that this roadmap sacrifices theoretical depth for speed of getting started, making it suitable for developers who want to move into AI engineering roles, and that "becoming a master in seven days" is clickbait.