awesome-ai-system-prompts — AI Agent 工作流中文教程

Synthesizing Best Practices: Key Takeaways for Builders

Analyzing these diverse prompts reveals a set of converging best practices for building reliable agentic AI systems:

1. Define the Agent Clearly: Start with an explicit role, purpose, and scope. Include contextual grounding like date or environment specifics.
2. Structure for Clarity: Break down complex instructions using headings, lists, or tags. Organize rules logically (e.g., group tool instructions, safety rules).
3. Be Explicit About Tools: Detail what each tool does, how to call it (syntax, parameters, format), and when (and when not) to use it. Provide examples. Embed usage policies directly.
4. Mandate Step-by-Step Execution: Encourage or enforce planning, iteration, and waiting for results/confirmation. Prevent the AI from attempting too much at once. Consider explicit thinking phases or loops.
5. Embed Domain Knowledge & Constraints: Include relevant style guides, library usage rules, file conventions, platform limitations, and best practices for the agent's specific domain.
6. Integrate Safety and Alignment: Define unacceptable requests and provide clear refusal protocols. Embed specific policies for sensitive operations (data handling, image generation).
7. Guide the Tone: Set expectations for the interaction style (professional, friendly, concise, adaptive) to ensure a consistent user experience.
8. Use Examples: Illustrate complex rules or desired output formats with clear examples within the prompt (like Bolt.new and v0 do extensively).

Essentially, an effective agentic system prompt acts as a comprehensive, well-structured operational manual that leaves little room for ambiguity while empowering the AI with the knowledge and procedures needed to act effectively and safely using its tools.

---

Conclusion: Building the Agentic Future

System prompts are the bedrock upon which capable and reliable agentic AI systems are built. As demonstrated by the examples from v0, same.new, Manus, ChatGPT, and others, successful prompts are detailed, structured, and explicit. They clearly define the agent's role, meticulously outline tool usage and operational procedures, enforce planning and iterative execution, embed necessary domain knowledge and safety constraints, and guide the interaction style.

For builders aiming to create the next generation of agentic AI in 2025 and beyond, studying these patterns provides invaluable insights. Mastering the craft of system prompting – blending clear instruction, structured organization, domain expertise, and safety considerations – will be key to unlocking the full potential of AI agents that can not only converse but actively collaborate and accomplish complex tasks in the digital world.

3. Explicit Tool Integration and Usage Guidelines

Why it matters: For agentic behavior, the AI must understand its tools: what they are, what they do, how to call them (syntax, parameters), required format (e.g., XML, JSON), and crucially, when and when not to use them. This requires detailed descriptions, clear schemas, and explicit rules.

Practical Examples: ChatGPT: Provides function schemas (TypeScript definitions) and detailed policies directly within the prompt for tools like dalle and canmore.

>     // Example for dalle tool policy within ChatGPT prompt
>     namespace dalle {
>     // Create images from a text-only prompt.
>     type text2im = (_: {
>     // The size of the requested image...
>     size?: ("1792x1024" | "1024x1024" | "1024x1792"),
>     // The number of images to generate...
>     n?: number, // default: 1
>     // The detailed image description...
>     prompt: string,
>     // If the user references a previous image...
>     referenced_image_ids?: string[],
>     }) => any;
>     } // namespace dalle
>     

Source: ChatGPT/4-5.md same.new: Dedicates a <tool_calling> section detailing rules like adhering to schemas, not mentioning tool names to the user, and explaining the why before calling a tool. References functions-schema.json (not shown in full, but implied structure).

>     <tool_calling>
>       ...
>       1. ALWAYS follow the tool call schema exactly...
>       3. **NEVER refer to tool names when speaking to the USER.**...
>       5. Before calling each tool, first explain to the USER why you are calling it.
>     </tool_calling>
>     

Source: same.new/same.new.md | Schema: same.new/functions-schema.json Manus: Defines tools externally in tools.json (schema provided) and includes rules in Modules.md like prioritizing data APIs over web search.

>     // Snippet from Manus/tools.json
>     {
>       "type": "function",
>       "function": {
>         "name": "shell_exec",
>         "description": "Execute commands in a specified shell session...",
>         "parameters": { ... }
>       }
>     }
>     

Source: Manus/tools.json | Rules: Manus/Modules.md Cline & Augment: Integrate detailed tool descriptions, parameters, and usage examples directly into the main system prompt using XML-like tags or structured text.

>     // Cline example tool definition
>     ## execute_command
>     Description: Request to execute a CLI command...
>     Parameters:
>     - command: (required) The CLI command...
>     - requires_approval: (required) A boolean indicating...
>     Usage:
>     <execute_command>
>     <command>Your command here</command>
>     <requires_approval>true or false</requires_approval>
>     </execute_command>
>     

Source: Cline/system.ts Bolt.new: Uses a dedicated <artifact_instructions> section detailing how to format tool outputs (<boltAction type="shell">, <boltAction type="file" filePath="...">) within a main <boltArtifact> tag. Source: Bolt.new/prompts.ts v0: Defines custom MDX components like <CodeProject>, <QuickEdit>, <DeleteFile /> as its 'tools', with rules on when and how to use them within responses. Source: v0/v0-tools.md

5. Environment and Context Awareness

Why it matters: Agents operate within specific environments (OS, IDE, browser sandbox, specific libraries). Providing this context allows the AI to generate compatible code, use appropriate commands, and understand limitations.

Practical Examples: Cline: Includes a SYSTEM INFORMATION section.

>     SYSTEM INFORMATION
>
>     Operating System: ${osName()}
>     Default Shell: ${getShell()}
>     Home Directory: ${os.homedir().toPosix()}
>     Current Working Directory: ${cwd.toPosix()}
>     

Source: Cline/system.ts Bolt.new: Provides detailed <system_constraints> about the WebContainer environment.

>     <system_constraints>
>       You are operating in an environment called WebContainer... It does come with a shell that emulates zsh... Available shell commands: cat, chmod, cp...
>     </system_constraints>
>     

Source: Bolt.new/prompts.ts Manus: Details the sandbox environment.

>     <sandbox_environment>
>     System Environment:
>     - Ubuntu 22.04 (linux/amd64), with internet access
>     - User: `ubuntu`, with sudo privileges
>     ...
>     Development Environment:
>     - Python 3.10.12...
>     - Node.js 20.18.0...
>     </sandbox_environment>
>     

Source: Manus/Modules.md same.new: Notes the OS and specific IDE context.

>     The OS is Linux 5.15.0-1075-aws (Ubuntu 22.04 LTS). Today is Tue Apr 08 2025.
>     You are pair programming with a USER in Same.
>     USER can see a live preview... in an iframe...
>     

Source: same.new/same.new.md

Vercel v0: UI Generation & Component Tooling

Relevant File: v0/v0.md | v0/v0-tools.md

Vercel's v0 agent specializes in generating UI components and full-stack Next.js applications based on user requests, often including image or screenshot inputs.

Distinctive Features:

• MDX Components as Tools: Instead of traditional function calls, v0's "tools" are specific MDX component tags like <CodeProject> (for wrapping generated code), <QuickEdit /> (for small code modifications), <DeleteFile />, and <MoveFile />. The prompt dictates exactly when and how to use these output formats.
• Heavy Domain Specificity: The prompt is rich with rules specific to Next.js App Router, Tailwind CSS, shadcn/ui, and Vercel's platform constraints (e.g., no package.json, how to handle environment variables, pre-installed libraries).
• Implicit Planning via <Thinking>: Mandates a planning phase using <Thinking> tags before generating a <CodeProject>, encouraging structured thought.
• Emphasis on Style & Best Practices: Includes rules for file naming (kebab-case), responsiveness, accessibility (semantic HTML, ARIA, alt text), and even color palette preferences (avoiding indigo/blue unless requested).

Example Snippet (Tooling via Components):

> v0 ALWAYS uses <QuickEdit> to make small changes to React code blocks...
> v0 can delete a file in a Code Project by using the <DeleteFile /> component.
>