12 Core Rules for the Evolution of AI Agent Prompt Engineering

As the underlying architecture and training paradigms of large language models (LLMs) continue to evolve, a new generation of AI models equipped with extended thinking capabilities has fundamentally changed the rules of prompt engineering. If you are still writing prompts for AI the way you did six months ago, you are likely providing the model with redundant instructions it no longer needs. Worse, these outdated instructions not only fail to improve results but can also slow down your AI agent, increase token consumption costs, and even cause it to exit prematurely before completing complex tasks.

Today, AI models designed for long-running agent coding, knowledge work, complex research, and multi-step workflows have been significantly optimized for output speed and token utilization. Their default reasoning depth is typically set to a medium level, and the “thinking” function is always enabled at the foundational level. This means developers must shift their prompt design focus from “controlling the thought process” to “defining the target outcome.” Here are 12 new rules for prompt engineering that developers should master.

Part 1: Goal Orientation and Boundary Definition

1. Define What “Done” Actually Means
This is perhaps the most critical rule for autonomous agents. Ambiguous instructions can cause the model to spin in infinite loops or end hastily without meeting objectives. Instead of simply saying “migrate the authentication system to the new protocol,” you must define the acceptance criteria for “done”:

• All authentication endpoints have been switched to the new protocol.
• All existing test cases pass.
• The new authentication flow has been written and passed automated tests.
• The old authentication implementation code has been completely removed.
• Related API documentation has been updated.
• Pause and request assistance only when encountering blocking issues that require human decision-making.

2. Stop Micromanaging the Model’s Thinking
This is one of the biggest changes in the new era of prompt engineering. In the past, developers habitually emphasized phrases like “think carefully before answering,” “think step by step,” or “consider every possibility deeply” in their prompts. However, in models with built-in reasoning capabilities, these natural language instructions are unnecessary. Attempting to control underlying reasoning logic via natural language can actually interfere with the model. It is recommended to use system-level “effort” parameters to control reasoning depth rather than rambling in the text.

3. Define Clear Error Handling and Fallback Mechanisms
In multi-step workflows, the model will inevitably encounter tool call failures or missing data. The prompt must clearly define exception handling strategies: retry, skip, log the error, or stop immediately? Defining these boundaries effectively prevents the agent from getting stuck in infinite loops.

4. Strictly Constrain Task Scope
Autonomous agents are prone to “over-engineering” or “opportunistically fixing unrelated bugs” during execution. The prompt should clearly define the scope of files allowed to be modified and the categories of APIs allowed to be called, prohibiting the model from performing unauthorized refactoring outside the task boundaries.

Part 2: Parameter Tuning and Process Control

5. Start with “Medium” Effort and Reasoning Depth
In testing and production, do not immediately max out the model’s “effort” or compute depth. Start with medium default values and evaluate the balance between output speed, token consumption, and result quality. Reduce the effort level for simple text processing to save costs, and increase parameters only when complex code refactoring is required.

6. Avoid Reverse Natural Language Instructions Like “Think Less”
If you want a faster response, do not write “think less, just answer” in the prompt. Such instructions will conflict with the model’s underlying reasoning mechanism. The correct approach is to adjust system-level compute allocation via the interface, allowing the model to decide on the compression of its reasoning path at the foundational level, rather than forcibly truncating it at the semantic level.

7. Separate System Instructions from Context Data
As context windows grow, developers may mix all information together. The new rules require strict separation of “execution instructions” from “background data.” Use explicit XML tags or specific delimiters to separate codebases and log files from core task instructions, ensuring the model can precisely focus during reasoning.

Part 3: Output Quality and Efficiency Management

8. Require Decision Evidence and Justification
To prevent autonomous agents from hallucinating during long-workflow tasks, prompts should mandate the output of decision rationales at key nodes. For example: “Before modifying core configurations, you must output the original line numbers from the codebase and the reason for the modification.” This not only enhances traceability but also prompts the model to conduct more rigorous logical verification.

9. Standardize Idempotency Requirements for Tool Calls
When an agent continuously calls external interfaces (such as object storage, message queues, or container platform APIs), the prompt must remind the model to ensure operation idempotency. Require the model to perform a state query before executing write or deploy operations, avoiding system state corruption caused by duplicate executions.

10. Specify Structured Output Formats
Do not let the model decide the format of the final report. For agents that need to interface with downstream systems, strictly require the use of JSON, XML, or Markdown tables for output. Specify mandatory fields (such as “task status,” “modified file list,” “remaining issues”) to improve the robustness of data parsing.

11. Remove Redundant Polite or Explanatory Constraints
In the old era, developers often added pleasantries or role settings like “please,” “thank you,” or “as a professional developer.” In agent scenarios, these texts not only waste tokens but also distract the model. Direct, objective, verb-led imperative sentences are the most efficient form of instruction.

12. Establish Context Compression and Self-Summarization Mechanisms
For long-running agents, the original context will quickly be filled with massive amounts of data returned by tools. Prompts should include context management strategies, such as: “When the log returned by a tool exceeds a specific length, first extract the core error information, discard redundant stack traces, and summarize the current progress before proceeding to the next step.”

Conclusion

Prompt design for the new generation of AI models is undergoing a profound shift from “babysitting guidance” to “goal-oriented delegation.” Developers need to realize that the model’s own reasoning and planning capabilities have matured. Our core responsibility is no longer to teach the model how to think, but to set clear finish lines, strict boundaries, and quantifiable acceptance criteria. Only by adapting to this technological evolution can we fully unleash the potential of autonomous agents and build efficient, stable, and cost-controllable intelligent applications.