Bilibili Hit Tutorial: Prompt Engineering from Beginner to Practical — A Complete Breakdown

Prompt Engineering is often made out to be mysterious, but a tutorial on Bilibili brings it back down to earth: from definitions to techniques, to the divide between reasoning models and general-purpose models, explained plainly and systematically. This article is based on the core structure of that tutorial, combined with multiple hands-on screenshots, to lay out a reusable learning path for prompting—no jargon stacking, with a focus on clearly explaining "why writing it this way works."

What Exactly Is a Prompt: "Programming" a Model in Natural Language

The tutorial doesn't open by throwing out concepts directly; instead, it uses Doubao for a "dimensionality-reduction explanation": a prompt is simply the sentence you send to the model, the text fragment you provide to guide it toward generating a specific output. For simple tasks like "how do I make braised pork," one sentence is enough; for complex tasks, you need to add task context so the model accurately understands your intent.

The more fundamental definition is: a prompt is "programming" a large model in natural language. The word programming is in quotes here—it's not about modifying model weights with Python or Java, but about precisely guiding semantics to activate model capabilities, reduce hallucinations, and stabilize outputs.

The tutorial mentions a classic characteristic: the primacy and recency effect, meaning models are more sensitive to the beginning and end of a prompt. Therefore, core instructions and key constraints should be placed at the start and end, with secondary information in the middle. However, the tutorial also admits that as model capabilities improve, this effect is no longer as pronounced as it once was—no need to over-mystify it.

Why Prompts Directly Determine Output Quality

With the same model, different people get wildly different results—the root cause is often the prompt. The tutorial uses a product copywriting example that builds layer by layer:

• Layer one: "Help me write some product copy"—it can write something, but it probably won't meet your needs, because you haven't even said what the product is.
• Layer two: "Write copy for wireless earbuds, highlighting battery life and noise cancellation"—now there's direction, but no mention of the platform where it will be published.
• Layer three: "You are a seasoned digital product voiceover copywriting master. Help me write three short wireless earbud scripts suitable for Douyin. The target audience is commute workers. Core highlights are 12-hour battery life and subway noise cancellation. Each script should be about 30 characters, conversational, with a call to action at the end"—targeting and usability are on a completely different level.

The tutorial summarizes the importance of prompts into four points: directly determining output quality; activating model capabilities at near-zero cost (compared to training from scratch costing tens of millions, or fine-tuning requiring GPU costs, optimizing prompts is essentially free); reducing hallucination risk (providing reference text, limiting output boundaries, guiding reasoning steps); and adapting to real business scenarios—the foundational step for deploying AI products.

The tutorial also cites six strategies proposed by OpenAI as a reference: write clear instructions, provide reference text, split complex tasks into simpler subtasks, give the model time to think, use external tools, and test changes systematically. The author believes these strategies still apply today and maps them to specific techniques like few-shot prompting, COT (Chain-of-Thought), Function Calling, and MCP.

Few-shot Prompting refers to giving the model a small number (usually 1-5) of input-output examples in the prompt, allowing the model to recognize task patterns through In-Context Learning and imitate the generation. It doesn't require updating model weights—examples alone can significantly improve format adherence and style consistency, making it especially suitable for tasks like classification, extraction, and fixed-template writing. Compared to Zero-shot, few-shot can reduce ambiguity, but example quality is crucial: examples need to cover typical cases, maintain consistent formatting, and avoid having incorrect demonstrations imitated by the model.

COT (Chain-of-Thought) is a technique that has the model explicitly output reasoning steps before giving an answer, typically triggered by "let's think step by step" or by providing step-by-step examples. It significantly improves accuracy on multi-step math, logical reasoning, and complex question answering, because intermediate steps give the model more computational space. COT is divided into zero-shot COT (just adding a guiding phrase) and few-shot COT (providing examples with reasoning processes). For general-purpose models, COT needs to be explicitly written into the prompt; for reasoning models, COT has been internalized as implicit thinking and no longer needs user guidance.

Reasoning Models vs. General-Purpose Models: Completely Different Prompting Approaches

This is the most informative part of the tutorial. The author emphasizes that choosing the wrong model type or strategy can mean twice the effort for half the result.

General-purpose models (chat models) are optimized for everyday conversation, pursuing speed, fluency, and low cost. They output token by token without additional internal deliberation or self-checking, making them suitable for writing, translation, information retrieval, and daily Q&A.

Reasoning models generate extensive invisible thinking steps internally before outputting the final answer—deliberating, trial-and-error, verification, and correction—i.e., internalized COT (implicit chain-of-thought). They sacrifice speed and cost in exchange for accuracy on tasks like multi-step mathematical reasoning, logical proofs, and complex code debugging.

The tutorial points out that in earlier periods (such as OpenAI's GPT series vs. O series, DeepSeek^Ad's Chat vs. R1), the two product lines were clearly distinct; but today mainstream flagship models are generally moving toward unified architecture plus adaptive reasoning—it's no longer about which model to choose, but the same model controlling thinking mode and thinking intensity through parameters.

Taking DeepSeek's API documentation as an example, the model supports both non-thinking and thinking modes, toggled via the Thinking parameter, with low/medium/high controlling thinking intensity. Comparing update logs in the tutorial, earlier versions distinguished R1 (reasoning) from V3 (chat), but now they've been merged into different modes of the same model.

This change directly alters how prompts should be written:

• Reasoning models: prompts should be more concise—just clearly state the task and requirements. The model has already internalized reasoning logic; forcibly breaking down steps may actually limit its reasoning ability. Role-playing is also not recommended for overuse, as it can easily interfere with the main logical thread.
• General-purpose models: reasoning steps need to be explicitly guided (like COT), otherwise the model tends to skip steps and make errors; it's best to set a role to quickly align on tone and style, and any missing reasoning guidance should be added.

In terms of applicable tasks, reasoning models are suitable for mathematical proofs, complex code, and deep logical analysis; general-purpose models cover article writing, copywriting, daily conversation, and knowledge Q&A. The tutorial reminds: don't use a model just because it was recently updated—task fit matters more than model hype.

Function Calling is about enabling the model to recognize scenarios in a conversation where external tools need to be called, and to output structured invocation parameters (such as JSON), which the application layer executes and returns the results to the model to continue generation. It allows the model to check weather, query databases, send emails—breaking through the limitations of pure text generation. Clearly describing tool names, purposes, and parameter formats in the prompt is key to improving invocation accuracy.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic to standardize how models connect to external data sources and tools. Think of it as the "USB interface for AI applications": developers expose resources (files, databases, APIs) according to the protocol, and the model side can uniformly discover and invoke them, reducing the cost of writing separate adapter code for each tool. MCP and Function Calling are complementary—the latter is the mechanism by which the model initiates calls, while the former standardizes how tools are described and integrated.

Five Principles for High-Quality Prompts

The tutorial concludes with five directly actionable principles:

1. Be specific, not vague: Avoid abstract expressions; clarify boundaries and standards. For example, instead of writing "write a poem," write "write a four-line seven-character quatrain on the theme of AI development, in a bold and heroic style."
2. Sufficient context: Explain the task background, user identity, and usage scenario. Instead of asking "how do I improve my English score," say "I'm the parent of a five-year-old kindergartener who can't write yet—how do I make English learning fun for them?"
3. No ambiguity: Chinese has many synonyms; key concepts need clear definitions to avoid vague expressions.
4. Logical coherence: Instruction order should follow cognitive logic—role first, then task, then requirements, and finally examples. The tutorial adds that role and requirements aren't mandatory; examples are used to provide one or two correct answers as guidance when results aren't satisfactory.
5. Concise, not redundant: Put core information first; remove irrelevant information. Overly long context not only distracts the model's attention but is also limited by the model's context window.

Context Window refers to the maximum number of tokens a model can process in a single pass, including both input prompts and output content. It determines how much background material, examples, and conversation history you can fit in. Content exceeding the window will be truncated or throw an error, so "concise, not redundant" is not just an attention issue but also subject to hard capacity limits. Even with a sufficiently large window, overly long context can cause the model to pay less attention to middle information (the "Lost in the Middle" phenomenon), so putting core instructions first and removing irrelevant information remains necessary practice.

Final Thoughts

The value of this tutorial isn't in listing techniques, but in establishing the correspondence between "model type—prompting strategy—task scenario." As reasoning models become more widespread, the old step-by-step guidance approach may not apply everywhere; conversely, general-purpose models still need explicit COT. Understanding this distinction will help you avoid detours more than memorizing templates.