Prompt Engineering for Beginners: From Prompts to a Systematic Approach

Many people think a prompt is just a message you send to an AI, but the first lesson in this prompt engineering tutorial on Bilibili offers a more systematic explanation. It breaks the core conceptual questions into four parts: what a prompt is, the essential difference between prompts and prompt engineering, why it's worth learning now, and what unavoidable limitations prompts have. The value of this framework is that it doesn't teach a "universal template"—it helps you build the right expectations for working with AI.

What Exactly Is a Prompt

The tutorial gives a very straightforward definition: a prompt is the instruction you give the AI. Whether it's a question, a description, or a request, any text you send to the AI counts. It's more like "the neural signal you send to the AI"—whatever signal you send, that's the direction the AI will think in.

Behind this analogy is a key judgment: with the same AI, some people can only use it to write elementary-school essays, while others can produce professional industry reports. The difference isn't in the AI itself, but in the input instructions.

The tutorial summarizes the role of prompts into four levels:

• Communication bridge: translates the vague ideas in your head into language the AI can understand. It's like ordering takeout—you can't just say "bring me some food"; you need to specify the dish, the spice level, and whether you want extra rice.
• Task navigation: tells the AI specifically what to do. Instructions like "help me handle this file" leave the AI to pick a random direction, which is probably not what you want.
• Style control: lets the AI write commentary in Lu Xun's style, write a diary in an elementary schooler's tone, or write a paper in rigorous academic language. This step can save a great deal of post-editing time.
• Boundary constraints: one of the most effective ways to address AI "nonsense." For example, when analyzing industry data, if you specify looking only at a certain quarter's financial report, it won't drift into macro policy.

The course uses "writing about spring" as a comparison: a basic prompt only says "write an article about spring," so the AI can only guess at region, genre, length, and style; the optimized prompt gives a role (essay writer), word count (800 words), setting (spring in Jiangnan), and stylistic requirements (beautiful language, lyrical, misty water-town imagery), and the output quality immediately differs.

How Prompts Differ from Prompt Engineering

This is the most critical distinction in the entire lesson. The tutorial clearly states that the difference between the two is very large.

A prompt is single-use, like writing one line of code and executing it once, solving one problem. If it works this time, it may not work for a different problem. There is no such thing as a "universal prompt"—only prompts suited to specific scenarios.

Prompt engineering is a process, relying not on inspiration but on method. It starts from analyzing the problem, then goes through designing solutions, executing tests, evaluating results, iterating strategy, and finally distilling reusable solutions. It solves not one problem, but a class of problems.

The tutorial breaks the prompt engineering process into six steps: needs breakdown, solution design, execution testing, effect evaluation, strategy iteration, and distillation for reuse. This process is very similar to software development, except what you're writing isn't code—it's natural language.

Prompt engineering ultimately points to four goals:

1. Improve accuracy—what the AI says is exactly what you want
2. Reduce hallucinations—make it fabricate less nonsense
3. Enhance stability—no matter who uses it or when, the results are roughly the same
4. Reduce cost—get the best results with the fewest tokens

These four goals are also the criteria for evaluating whether a prompt engineering solution is well done.

Token is a key concept for understanding cost issues. Large language models don't process text directly; they first split text into individual tokens—roughly understandable as "word fragments." An English word may be one or two tokens, and a Chinese character is usually about one token. The context length a model can handle and its billing method are both measured in tokens. This explains why longer prompts cost more: both input and output are billed by token count, and if a prompt is stuffed with a large amount of repeated background or redundant examples, you pay for that content on every call. In high-frequency calling scenarios, a prompt that saves a few hundred tokens can produce a significant cost difference, which is also why "getting the best results with the fewest tokens" is one of the engineering goals.

Why Prompt Engineering Is Worth Learning Now

The reason the tutorial gives is very direct: AI capabilities are already very strong, but most people don't know how to use them. Data shows that more than 90% of users only use AI for basic Q&A, equivalent to buying a sports car but only driving in first gear.

The barrier to learning prompt engineering is extremely low—you don't need to know programming, you don't need to understand algorithms, you just need to be able to speak and express things clearly. The most direct benefit is efficiency improvement: what used to take a day may now be completed in an hour. It can also solve many problems AI previously couldn't handle, such as writing professional reports and doing complex data analysis.

The tutorial also mentions the business value level: helping enterprises optimize prompts, using AI-generated content for side businesses, one person completing the work of an entire team, and self-media going from ten articles a month to dozens. These directions reposition prompt engineering from a skill to an opportunity.

The Limitations of Prompts: It's Not a Master Key

This part is the most easily overlooked in the entire lesson, but it's also where pitfalls are most likely in actual use. The tutorial unfolds it from three levels.

Hard Boundaries at the Capability Level

Prompts cannot break through the AI's own capability ceiling. Training data has a cutoff date, so it doesn't know about things that happened afterward; complex math problems can't be solved no matter how much you optimize the prompt. Unstable output is also normal—changing one word can produce a completely different result, and if the prompt is too long, the AI will "forget things." The hallucination problem can only be reduced, not completely eliminated.

Hallucination refers to content generated by a model that appears plausible but is actually wrong or fabricated out of thin air. It is not the model "deliberately lying," but a byproduct of its working mechanism: a large language model is essentially predicting the next most likely token, pursuing linguistic coherence and plausibility rather than factual accuracy. When it lacks relevant knowledge, or when a question exceeds the scope of its training data, it will still follow language patterns to fabricate a fluent answer. This is also why optimizing prompts can only "reduce" rather than "eliminate" hallucinations—by limiting the data range, requiring cited sources, and clearly stating when it is uncertain, the probability can be lowered, but it cannot be eradicated mechanically. When key facts are involved, manual verification is still indispensable.

Three Limitations at the Technical Foundation

• Context length limitation: the AI's memory capacity is fixed, so after chatting too long it will forget the initial requirements
• Instability on complex tasks: single-step tasks are fine, but multi-step calculations easily skip steps and break logic, so they need to be broken into smaller tasks first
• No true long-term memory: every conversation is brand new, and it cannot remember your preferences or previous background, which can only be solved through external databases

These three problems are determined by the technical foundation; prompts can only optimize and alleviate them, not cure them.

Context window refers to the maximum number of tokens a model can "remember" in a single conversation, including all the content you input and the content it has already generated. Early information beyond this window gets pushed out, which is why "after chatting too long, it forgets the initial requirements." Different models vary greatly in window size, from a few thousand to hundreds of thousands of tokens, but no matter how large, it is still limited. It should be emphasized that the context window is not equal to long-term memory: it is only valid within a single session and is cleared once the conversation ends. If you want the AI to remember your preferences, historical background, or proprietary knowledge, you usually need external databases, retrieval augmentation (RAG), or memory systems to supplement it. This is also one of the practical roots of the tutorial's point that "pure prompts cannot be engineered."

Pitfalls You Only Encounter in Deployment

Safety and alignment restrictions are the AI's underlying red lines, but sometimes completely legitimate needs may also be misjudged and blocked. Pure prompts cannot be engineered—using them yourself is fine, but turning them into a product for hundreds or thousands of people won't work, because there is no version management or issue tracing, and it can't withstand large-scale batch tasks. Cost traps are also very real: AI charges by token, and the longer the prompt, the more expensive it is, and not in a linear way. In high-frequency calls, hidden costs can become frighteningly high.

The attitude the tutorial finally gives is: prompts are indeed useful, but they are not a master key. Things that should be done manually still have to be done manually. Understanding these pitfalls in advance helps you avoid detours.

The value of this first lesson isn't in teaching you specifically how to write prompts, but in helping you build the right cognitive framework—knowing what it can do, what it cannot do, and at what stage you should upgrade from "writing prompts" to "doing prompt engineering."

One-line Summary

A prompt is a single instruction to an AI, while prompt engineering is a complete process for solving a class of problems.

Paragraph Summary

This article outlines the core framework of the first lesson in the Bilibili prompt engineering tutorial. It first distinguishes prompts from prompt engineering: the former is a single instruction that solves a single problem, with no universal template; the latter is a complete process from needs breakdown, solution design, execution testing, effect evaluation, and strategy iteration to distillation for reuse, solving a class of problems. The role of prompts is summarized into four levels: communication bridge, task navigation, style control, and boundary constraints, while the engineering goals are to improve accuracy, reduce hallucinations, enhance stability, and lower costs. The article also explains that the value of learning lies in unlocking the underestimated capabilities of AI, and systematically reveals three layers of limitations: the AI capability ceiling, technical constraints such as context length and the lack of long-term memory, and deployment pitfalls such as safety-alignment misjudgments and token costs.