停止像2024年那样提示
人工智能领域，尤其是大型语言模型（LLMs）的发展速度令人惊叹。曾经被视为尖端的技术如今已变得司空见惯，而随着这种快速发展，我们与这些强大工具的交互方式也随之转变。在人工智能的早期，重点往往在于构思完美的提示——一个神奇的句子或短语，似乎让模型变得更聪明或更有能力。然而，随着我们进一步进入2020年代，人们已经意识到这种方法是过时的。真正的挑战不在于寻找能让模型智能化的魔法词语，而在于构建我们的提示以确保清晰度、效率和可靠性。
编码代理的演变
编码代理尤其经历了显著的改进。过去那种简单的提示只会得到模糊或错误的回应的日子已经一去不复返了。现代编码代理远比以往更复杂，能够理解上下文、生成代码，甚至调试。尽管取得了这些进步，但许多人仍然陷入寻找那个能让模型发挥奇迹般作用的完美提示的陷阱。这种方法不仅效率低下，而且常常导致挫败和失望。
到2026年，思维方式已经转变。人们不再寻找魔法句子，而是专注于让任务本身尽可能清晰和无歧义。目标是创建难以误解、难以操纵、易于验证的提示。这种方法不仅更有效地利用了现代LLMs的功能，而且确保了结果的连贯性和可靠性。
十种提示模式
在多年使用LLMs处理实际代码库后，我确定了十种提示模式，这些模式始终能带来最佳结果。这些模式并非关于寻找完美的词语，而是关于以模型能够轻松理解和执行的方式构建任务。
1. 称其为“初稿”并着手处理
最有效的模式之一是将其任务框架为“初稿”。这种方法承认初始输出可能并不完美，并为迭代改进设定了预期。通过将输出视为起点，你鼓励更灵活和开放心态的评估过程。
提示示例：
"编写一个计算数字阶乘的Python函数的初稿。专注于清晰度和正确性，但不用担心性能优化。"
这种模式之所以有效，是因为它降低了风险。你不再期望立即获得完美的解决方案，而是允许改进的可能性。这种思维方式的转变可以带来更具创造性和更有效的结果。
2. 将复杂任务分解
复杂任务通常需要将其分解为更小、更易于管理的子任务。这种方法不仅使任务更容易理解，还简化了验证过程。通过分解问题，你可以提供更具体的反馈，更有效地指导模型。
提示示例：
"编写一个Python脚本，读取CSV文件、处理数据并输出报告。首先，概述读取文件所需的步骤。然后，为每个步骤提供代码。"
这种模式对于需要全面解决方案的大型项目特别有用。通过分解任务，你可以系统地处理每个部分。
3. 提供上下文和示例
上下文对于任何任务都至关重要，尤其是在使用LLMs时。提供相关的上下文和示例有助于模型理解期望的结果，避免需要大量澄清。这种方法对于编码任务特别有效，其中项目和现有代码库的上下文会显著影响输出的质量。
提示示例：
"编写一个验证电子邮件地址的JavaScript函数。如果电子邮件有效，函数应返回true，否则返回false。以下是一个有效的电子邮件示例：'example@example.com'。"
通过包含示例，你为模型提供了一个清晰的参考点，使其更容易生成准确和相关的响应。
4. 使用清晰简洁的语言
在构思提示时，清晰度和简洁性是关键。模糊或过于复杂的语言会导致误解和结果不佳。目标是使用直白的语言，不留任何解释空间。
提示示例：
"编写一个SQL查询，从'users'表中选择所有'状态'列值为'active'的记录。"
这种模式确保模型专注于任务本身，而不会被不必要的细节所困扰。
5. 指定输出格式
输出格式会显著影响其可用性。通过指定所需格式，你可以确保结果以易于理解和集成的方式呈现。这对于编码任务尤其重要，其中代码的格式会影响其可读性和可维护性。
提示示例：
"编写一个计算数字阶乘的Python函数。函数应以整数形式返回结果。"
指定格式有助于模型生成满足你特定需求的输出。
6. 要求分步推理
对于复杂任务，要求分步推理可以提供宝贵的洞察，了解模型的思考过程。这种方法不仅有助于理解模型如何得出结论，还允许更针对性的反馈和改进。
提示示例：
"计算前10个质数的和。为计算的每一步提供分步推理。"
这种模式在教育目的和理解模型的决策过程方面特别有用。
7. 结合迭代反馈
迭代反馈对于改进LLMs的输出至关重要。通过提供对初始响应的反馈，你可以引导模型走向更准确和完整的解决方案。这种方法涉及多轮交互，其中每一步响应都建立在之前的响应之上。
提示示例：
"编写一个对数字数组进行升序排序的JavaScript函数。以下是初始函数：
```javascript
function sortArray(arr) {
return arr.sort();
}
该函数未能正确处理负数。修改函数以确保它能正确排序数组。"
这种模式利用了LLMs的交互性质，通过持续反馈改进输出。
### 8. 定义约束和边缘情况
指定约束和边缘情况有助于模型理解任务的边界，避免生成不现实或错误的响应。这种方法对于编码任务尤其重要，因为边缘情况会显著影响代码的功能。
```markdown
提示示例：
"编写一个计算数字阶乘的Python函数。函数应通过返回None处理负数。确保函数能够处理大数字而不出现性能问题。"
通过定义约束和边缘情况，你可以确保模型生成健壮可靠的解决方案。
9. 使用版本控制和文档
对于大型项目，使用版本控制和文档可以显著提高输出效率和可靠性。通过向模型提供现有代码库和文档的访问权限，你可以确保生成的代码与项目的其余部分无缝集成。
提示示例：
"在以下代码库中为'user'模块编写一个新函数：
```python
# user.py
class User:
def __init__(self, name, email):
self.name = name
self.email = email
def get_email(self):
return self.email
该函数应检索具有特定电子邮件域的所有用户并返回他们的名字。"
这种模式利用了模型理解并能在现有代码库的上下文中工作的能力。
### 10. 结合多种模式
最后，最有效的策略是结合多种提示模式。通过利用不同方法的优点，你可以创建既全面又有效的提示。这种方法允许你根据任务的特定需求定制提示，确保模型能生成最佳输出。
```markdown
提示示例：
"为加入'project-x'团队的新开发者编写一份综合指南。指南应包括：
1. 项目简介。
2. 关键模块及其功能。
3. 设置开发环境的分步说明。
4. 常见问题和解决方案。
以Markdown格式提供指南，包含清晰的标题和示例。"
总结
LLMs的演变已经将重点从寻找完美的提示转变为以最大化清晰度、效率和可靠性的方式构建任务。通过采用本文中概述的十种提示模式，你可以充分利用现代编码代理的潜力，生成高质量的成果。关键要点是有效的提示并非关于寻找魔法句子，而是关于创建难以误解、难以操纵、易于验证的任务。这种方法不仅提高了输出的质量，还增强了与LLMs合作的整体体验。
Stop Prompting Like It's 2024
The landscape of artificial intelligence, particularly large language models (LLMs), has evolved at an astonishing pace. What was once considered cutting-edge is now commonplace, and with this rapid development comes a shift in how we interact with these powerful tools. In the early days of AI, the focus was often on crafting the perfect prompt—a magical sentence or phrase that somehow made the model smarter or more capable. However, as we move further into the 2020s, it's become clear that this approach is outdated. The real challenge isn't finding the right words to magically enhance the model's intelligence but in structuring our prompts to ensure clarity, efficiency, and reliability.
The Evolution of Coding Agents
Coding agents, in particular, have seen significant improvements. Gone are the days when a simple prompt would yield a vague or incorrect response. Modern coding agents are far more sophisticated, capable of understanding context, generating code, and even debugging. Despite these advancements, many of us still fall into the trap of trying to find that one perfect prompt that will make the model perform miracles. This approach is not only inefficient but often leads to frustration and disappointment.
In 2026, the mindset has shifted. Instead of searching for magical sentences, the focus is on making the task itself as clear and unambiguous as possible. The goal is to create prompts that are hard to misunderstand, hard to game, and easy to verify. This approach not only leverages the capabilities of modern LLMs more effectively but also ensures that the results are consistent and reliable.
The Ten Prompting Patterns
After years of using LLMs on real codebases, I've identified ten prompting patterns that consistently yield the best results. These patterns are not about finding the perfect words but about structuring the task in a way that the model can easily understand and execute.
1. Call It a "First Draft" and Attack It
One of the most effective patterns is to frame the task as a "first draft." This approach acknowledges that the initial output may not be perfect and sets the expectation for iterative refinement. By treating the output as a starting point, you encourage a more flexible and open-minded evaluation process.
Prompt Example:
"Write a first draft of a Python function that calculates the factorial of a number. Focus on clarity and correctness, but don't worry about optimizing for performance."
This pattern works because it lowers the stakes. Instead of expecting a flawless solution immediately, you allow for the possibility of improvement. This mindset shift can lead to more creative and effective results.
2. Break Down Complex Tasks
Complex tasks often require breaking them down into smaller, more manageable subtasks. This approach not only makes the task easier to understand but also simplifies the verification process. By breaking down the problem, you can provide more specific feedback and guide the model more effectively.
Prompt Example:
"Write a Python script that reads a CSV file, processes the data, and outputs a report. First, outline the steps required for reading the file. Then, provide the code for each step."
This pattern is particularly useful for large projects where a comprehensive solution is needed. By breaking down the task, you can ensure that each part is addressed systematically.
3. Provide Context and Examples
Context is crucial for any task, especially when working with LLMs. Providing relevant context and examples helps the model understand the desired outcome and avoids the need for extensive clarification. This approach is particularly effective for coding tasks, where the context of the project and the existing codebase can significantly influence the quality of the output.
Prompt Example:
"Write a JavaScript function that validates an email address. The function should return true if the email is valid and false otherwise. Here is an example of a valid email: 'example@example.com'."
By including examples, you give the model a clear reference point, making it easier to generate accurate and relevant responses.
4. Use Clear and Concise Language
Clarity and conciseness are key when crafting prompts. Ambiguous or overly complex language can lead to misunderstandings and subpar results. The goal is to use straightforward language that leaves no room for interpretation.
Prompt Example:
"Write a SQL query that selects all records from the 'users' table where the 'status' column is 'active'."
This pattern ensures that the model focuses on the task at hand without getting bogged down by unnecessary details.
5. Specify the Format of the Output
The format of the output can significantly impact its usability. By specifying the desired format, you can ensure that the results are presented in a way that is easy to understand and integrate. This is particularly important for coding tasks, where the format of the code can affect its readability and maintainability.
Prompt Example:
"Write a Python function that calculates the factorial of a number. The function should return the result as an integer."
Specifying the format helps the model generate output that meets your specific needs.
6. Request for Step-by-Step Reasoning
For complex tasks, requesting step-by-step reasoning can provide valuable insights into the model's thought process. This approach not only helps in understanding how the model arrives at its conclusions but also allows for more targeted feedback and refinement.
Prompt Example:
"Calculate the sum of the first 10 prime numbers. Provide step-by-step reasoning for each step of your calculation."
This pattern is particularly useful for educational purposes and for understanding the model's decision-making process.
7. Incorporate Iterative Feedback
Iterative feedback is essential for refining the output of LLMs. By providing feedback on the initial response, you can guide the model towards a more accurate and complete solution. This approach involves multiple rounds of interaction, where each response is built upon the previous one.
Prompt Example:
"Write a JavaScript function that sorts an array of numbers in ascending order. Here is the initial function:
```javascript
function sortArray(arr) {
return arr.sort();
}
The function does not handle negative numbers correctly. Modify the function to ensure it sorts the array correctly."
This pattern leverages the interactive nature of LLMs to refine the output through continuous feedback.
### 8. Define Constraints and Edge Cases
Specifying constraints and edge cases helps the model understand the boundaries of the task and avoid generating unrealistic or incorrect responses. This approach is particularly important for coding tasks, where edge cases can significantly impact the functionality of the code.
```markdown
Prompt Example:
"Write a Python function that calculates the factorial of a number. The function should handle negative numbers by returning None. Ensure the function can handle large numbers without performance issues."
By defining constraints and edge cases, you can ensure that the model generates robust and reliable solutions.
9. Use Version Control and Documentation
For larger projects, using version control and documentation can significantly improve the efficiency and reliability of the output. By providing the model with access to the existing codebase and documentation, you can ensure that the generated code integrates seamlessly with the rest of the project.
Prompt Example:
"Write a new function for the 'user' module in the following codebase:
```python
# user.py
class User:
def __init__(self, name, email):
self.name = name
self.email = email
def get_email(self):
return self.email
The function should retrieve all users with a specific email domain and return their names."
This pattern leverages the model's ability to understand and work within the context of an existing codebase.
### 10. Combine Multiple Patterns
Finally, one of the most effective strategies is to combine multiple prompting patterns. By leveraging the strengths of different approaches, you can create prompts that are both comprehensive and effective. This approach allows you to tailor the prompt to the specific needs of the task, ensuring that the model can generate the best possible output.
```markdown
Prompt Example:
"Write a comprehensive guide for a new developer joining the 'project-x' team. The guide should include:
1. A brief overview of the project.
2. Key modules and their functionalities.
3. Step-by-step instructions for setting up the development environment.
4. Common issues and their solutions.
Provide the guide in Markdown format, with clear headings and examples."
Takeaway
The evolution of LLMs has shifted the focus from finding the perfect prompt to structuring the task in a way that maximizes clarity, efficiency, and reliability. By adopting the ten prompting patterns outlined in this article, you can leverage the full potential of modern coding agents and generate high-quality results. The key takeaway is that effective prompting is not about finding magical sentences but about creating tasks that are hard to misunderstand, hard to game, and easy to verify. This approach not only improves the quality of the output but also enhances the overall experience of working with LLMs.
