Prompt Engineering in Practice: From Model Selection to Five Golden Principles

As large model capabilities iterate rapidly, the value of prompt engineering has not faded—it has actually become more nuanced due to the evolution of model architectures. This tutorial from a Bilibili creator systematically organizes the core concepts of prompts, model selection strategies, and the principles for building high-quality prompts, packed with practical insights throughout. This article builds on that foundation with extended analysis to help readers establish a deployable prompt engineering methodology.

What Is a Prompt: Programming Large Models with Natural Language

A prompt is simply the message you send to a model. This definition sounds simple, but it carries a profound essence: a prompt is programming a large model using natural language—the word "programming" here is in quotes. It differs from writing code in Python or Java; instead, it involves precisely guiding semantics to activate model capabilities, reduce hallucinations, and stabilize output.

The purpose of a prompt is to provide task context for the model so it can more accurately understand user intent. A simple task (like "How do I make braised pork?") requires just one sentence, but complex tasks need more complete contextual descriptions. Understanding this is the foundation for all the techniques that follow.

Why Prompts Directly Determine Output Quality

With the same model and the same task, different people may get vastly different results.

Take product copywriting as an example:

• Vague version: "Help me write some product copy"—the model can write something, but it likely won't match your needs.
• Advanced version: "Help me write product copy for wireless earbuds, highlighting battery life and noise cancellation"—more targeted, but what platform is it for? Douyin, Bilibili, or Xiaohongshu? Who is the audience? Without this information, the results still fall short.
• High-quality version: "You are a senior digital product voiceover copywriting master. Help me write three short scripts suitable for Douyin about wireless earbuds. The target audience is commuting office workers. Core highlights: 12-hour battery life and no noise interference on the subway. Each script should be around 30 characters, conversational, with a call to action at the end"—this is a truly usable prompt.

The importance of prompts is also reflected in three aspects. Low-cost activation of model capabilities: without fine-tuning or training from scratch, prompt optimization alone can significantly improve task accuracy—this is currently the most cost-effective way to boost model performance. Reducing hallucination risk: by providing reference text, limiting output boundaries, and guiding reasoning steps, you can greatly reduce the probability of the model "confidently making things up." Adapting to real business scenarios: standardized prompt design is a core part of deploying AI products.

OpenAI's Six Strategies: Still Applicable Today

OpenAI once proposed six prompt design strategies: write clear instructions, provide reference text, split complex tasks into simpler subtasks, give the model time to think, use external tools, and systematically test changes.

These strategies remain applicable today. For example, "provide reference text" corresponds to Few-Shot prompting, and "use external tools" has evolved from early Function Calling to the MCP protocol. The strategies themselves are stable; what changes are the implementation methods.

Few-Shot Prompting refers to providing the model with a small number (usually 1–5) of input-output examples in the prompt, allowing the model to quickly learn the task format and style through pattern recognition without retraining. It is the most direct implementation of the "provide reference text" strategy and stands in contrast to Zero-Shot prompting (giving instructions without examples). When the model's output format is unstable or the task is unusual, Few-Shot is often the most effective remedy.

Function Calling allows the model to output structured parameters when generating responses, calling external APIs or tools to obtain real-time information, thereby breaking through the timeliness limitations of training data. MCP (Model Context Protocol) is an open standard proposed by Anthropic that unifies the way models connect to external data sources and tools—think of it as the "USB interface for AI applications." It moves previously proprietary Function Calling solutions toward standardization, greatly reducing the development cost of tool integration.

General Models vs. Reasoning Models: Choosing the Right Strategy Matters More Than Choosing the Newest Model

Before writing prompts, you must first understand what type of model you're dealing with, because different model types require completely different prompt design strategies.

Core Differences Between the Two Model Types

General models (chat models) are optimized for everyday conversation scenarios, pursuing response speed and language fluency, outputting token by token without additional internal deliberation or self-checking. They are suitable for writing, translation, information retrieval, and daily Q&A.

Reasoning models generate extensive invisible thinking steps internally before outputting the final answer, performing deduction, trial and error, verification, and correction. They sacrifice speed and cost for accuracy on complex tasks—with clear advantages especially in multi-step mathematical reasoning, logical proofs, and complex code debugging.

COT (Chain of Thought) refers to the technique of guiding a model to output intermediate reasoning steps before giving a final answer. The classic approach is to add "let's think step by step" to the prompt, or to show the complete reasoning process in Few-Shot examples. For general models, COT can significantly improve accuracy on complex tasks like math and logic, because step-by-step output essentially externalizes internal implicit computation into explicit tokens, reducing skipped steps and calculation errors. For reasoning models, however, they have already completed large-scale chain-of-thought reasoning internally. Externally requiring step-by-step thinking can cause redundant reasoning, waste tokens, and even interfere with their own reasoning paths. Therefore, reasoning models typically do not need explicit COT.

Architectural Trend: From Dual Product Lines to Unified Models

Between 2024 and 2025, reasoning models and general models were clearly two product lines. But by 2026, mainstream flagship models have largely shifted to unified architecture with adaptive reasoning.

Take DeepSeek^Ad as an example: models on its API platform now control whether thinking mode is on or off and its intensity (low/medium/high) through parameters, rather than releasing two separate models. This means users no longer need to "choose a chat model or a reasoning model"—instead, they decide whether to enable reasoning mode on the same model.

Adaptive Reasoning refers to a model's ability to automatically decide whether to enter deep reasoning mode and how much thinking budget to allocate based on task complexity. Users can adjust this through parameters (such as thinking intensity low/medium/high) or let the model judge on its own. The benefit of this architecture is that simple questions get quick answers, saving cost, while complex questions automatically switch to long thinking, balancing efficiency and accuracy. For developers, this also means prompts should no longer be hardcoded for "a certain type of model," but should focus on the task itself, letting the model choose the appropriate reasoning depth.

The Divergence in Prompt Strategies

This architectural change directly affects how prompts should be written:

• Reasoning models: prompts should be more concise, focusing on goals and requirements. The model has already internalized reasoning logic, and 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 models: explicit reasoning steps (such as COT chain-of-thought) are needed, otherwise they tend to skip steps and make errors. Role-playing, on the other hand, is very effective for quickly aligning role cognition and communication style.

The core principle of model selection is based on task requirements, not model popularity. The newest model is not necessarily the most suitable for your current task.

Five Core Principles of High-Quality Prompts

Specific, Not Vague

Avoid abstract expressions; clarify boundaries, requirements, and standards. Don't say "write a poem"; instead say "write a four-line seven-character quatrain on the theme of AI development, in a bold and heroic style."

Complete Context

Clearly explain the task background, user identity, and usage scenario. Don't ask "how to improve English grades"; instead say "I'm the parent of a five-year-old kindergartener who can't write yet, and I want to make English learning fun and introductory." The latter will obviously get a more targeted response.

Unambiguous Semantics

Chinese is rich in synonyms, and meanings can differ across contexts. Key concepts should be clearly defined to avoid vague expressions.

Logical Coherence

Organize prompts in the order of "role → task → requirements → examples," which follows cognitive logic. Of course, you don't have to include all of them—no role setting is fine, and letting the model improvise without requirements is also acceptable. Examples (Few-Shot) are the most effective remedy when results are unsatisfactory.

Concise, Not Redundant

Put core information upfront and remove irrelevant information. Overly long context dilutes the model's attention and affects final output quality.

Final Thoughts

Prompt engineering is not a fixed set of templates but a way of thinking. Understand the type of model you're using, clarify task requirements, and follow the basic principles of clarity, specificity, and context—then you can consistently obtain high-quality output across different scenarios. Models evolve, and prompt strategies need to adjust accordingly—but the core of "precisely expressing requirements" will never go out of style.

One-line Summary

Prompts are natural-language programming for large models; strategies must adapt to model type, following five core principles.

Paragraph Summary

The article systematically organizes the core methodology of prompt engineering. First, it clarifies that the essence of a prompt is programming a large model using natural language, using precise semantic guidance to improve output quality and reduce hallucinations. Second, it reviews OpenAI's six strategies, noting that the strategies are stable but implementation methods are evolving, such as Few-Shot and MCP. The core change lies in model architecture: by 2026, mainstream models have shifted from dual reasoning/general product lines to unified architecture with adaptive reasoning, and prompt strategies diverge accordingly—reasoning models should be concise and goal-focused, while general models need explicit COT and role-playing. Finally, it presents five principles of high-quality prompts: specific not vague, complete context, unambiguous semantics, logical coherence, and concise not redundant, emphasizing that prompt optimization is the most cost-effective way to boost model performance.