Comparative Analysis of AI System Prompts

This section provides a detailed comparison of the prompting styles, underlying philosophies, methodologies, and evaluation approaches used by different AI products. It also offers an assessment of which product demonstrates the most sophisticated prompt engineering techniques.

Prompting Styles Across AI Products

Each AI system in our analysis employs distinct prompting styles that reflect their intended use cases and design philosophies:

Cursor 8.0/10

Prompting Style: Cursor employs a highly structured, code-centric prompting style with extensive use of conditional logic and specialized instructions for different programming languages and development environments.

Key Characteristics:

Heavy emphasis on code understanding and generation
Detailed instructions for handling different file types and programming paradigms
Extensive use of semantic search capabilities for codebase navigation
Specialized instructions for IDE integration and editor operations

Example Pattern:

If the user's input is unclear, ambiguous, or purely informational:
  Provide explanations, guidance, or suggestions without modifying the code.
  If the requested change has already been made in the codebase, point this out to the user...
Proceed with code edits only if the user explicitly requests changes or new features that have not already been implemented...

Source: Cursor system prompt - <making_code_changes> section

Devin 8.5/10

Prompting Style: Devin uses a comprehensive software engineering-focused prompt style that emphasizes autonomous problem-solving and system interaction capabilities.

Key Characteristics:

Detailed instructions for software development workflows
Strong emphasis on autonomous planning and execution
Extensive guidelines for system interaction and tool usage
Structured approach to debugging and problem diagnosis

Example Pattern:

You are Devin, a software engineer using a real computer operating system.
You have access to a terminal, web browser, and code editor.
When solving problems:
1. Break down complex tasks into smaller steps
2. Plan your approach before implementation
3. Test your solutions thoroughly
4. Document your work clearly

Source: Devin system prompt - Opening identity statement

Lovable 7.5/10

Prompting Style: Lovable employs a web development-focused prompting style with custom markup language for specific operations and strong emphasis on user experience design.

Key Characteristics:

Custom markup language for file operations (<lov-code>, <lov-write>, etc.)
Detailed instructions for web application development
Framework-specific guidelines (React, Next.js, etc.)
Strong focus on responsive design and user experience

Example Pattern:

Use only ONE <lov-code> block to wrap ALL code changes and technical details in your response...
Use <lov-write> for creating or updating files...
Use <lov-rename> for renaming files...
Use <lov-delete> for removing files...

Source: Lovable system prompt - File operation instructions

Manus 9.5/10

Prompting Style: Manus uses a highly modular, agent-based prompting style with extensive use of XML-style semantic markup and function-based agency model.

Key Characteristics:

Comprehensive modular design with 20+ distinct functional components
Detailed event stream processing architecture
Extensive tool definitions with formal parameter specifications
Clear separation between different operational domains

Example Pattern:

<agent_loop>
You are operating in an agent loop, iteratively completing tasks through these steps:
1. Analyze Events: Understand user needs and current state through event stream...
2. Select Tools: Choose next tool call based on current state...
3. Wait for Execution: Selected tool action will be executed...
4. Iterate: Choose only one tool call per iteration...
5. Submit Results: Send results to user via message tools...
6. Enter Standby: Enter idle state when all tasks are completed...
</agent_loop>

Source: Manus agent_loop.txt - Agent loop definition

Underlying Philosophies and Methodologies

The system prompts reveal distinct philosophical approaches to AI assistant design:

Cursor: Tool-Augmented Specialist

Philosophy: Cursor's prompts reflect a philosophy that AI should be deeply integrated with existing developer tools and workflows, serving as an extension of the developer's capabilities rather than a replacement.

Source: Derived from Cursor's prompt emphasis on IDE integration and specialized code editing instructions

Methodology:

Deep integration with IDE and development environment
Specialized knowledge of programming languages and paradigms
Context-aware assistance based on current code state
Incremental improvement of existing code rather than wholesale generation

Evaluation Approach:

Cursor appears to be evaluated primarily on:

Accuracy of code modifications
Relevance of suggestions to the current context
Ability to understand and navigate complex codebases
Quality of explanations for code-related concepts

Devin: Autonomous Problem Solver

Philosophy: Devin's prompts embody a philosophy that AI can function as an autonomous software engineer, capable of understanding, planning, and executing complex development tasks with minimal human intervention.

Source: Directly stated in Devin's prompt with emphasis on autonomous planning and execution

Methodology:

Comprehensive planning before execution
Systematic debugging and problem diagnosis
Autonomous exploration of solution spaces
Self-evaluation and iterative improvement

Evaluation Approach:

Devin appears to be evaluated on:

End-to-end task completion capability
Problem-solving effectiveness
Autonomy in planning and execution
Quality and maintainability of produced code

Lovable: User-Centered Creator

Philosophy: Lovable's prompts reflect a philosophy centered on creating user-friendly web applications with a focus on both technical correctness and user experience.

Source: Evident in Lovable's prompt focus on web development and user experience design

Methodology:

Structured approach to web application development
Framework-specific best practices
User experience and design considerations
Standardized patterns for common web development tasks

Evaluation Approach:

Lovable appears to be evaluated on:

Functional correctness of web applications
User experience quality
Adherence to modern web development standards
Visual design and responsive behavior

Manus: Modular Agent Framework

Philosophy: Manus's prompts represent a philosophy that AI assistants should operate as modular, tool-using agents with clear operational frameworks and specialized capabilities for different domains.

Source: Evident in Manus's extensive modular design and agent loop architecture

Methodology:

Modular design with specialized components
Event-driven processing architecture
Tool-based agency model with formal parameter specifications
Iterative task completion through agent loops

Evaluation Approach:

Manus appears to be evaluated on:

Task completion effectiveness across diverse domains
Appropriate tool selection and usage
Adherence to operational frameworks
Quality of user interaction and communication

Sophistication Assessment

Based on our analysis of the leaked system prompts, we can assess the relative sophistication of each product's prompt engineering techniques:

Manus: 9.5/10

Manus demonstrates the most sophisticated prompt engineering techniques, with:

Comprehensive modular design with clear separation of concerns
Extensive use of XML-style semantic markup for structured instructions
Formal function definitions with JSON Schema parameter specifications
Detailed event stream processing architecture
Specialized modules for different operational domains

Source: Analysis of Manus prompt.txt, agent_loop.txt, modules.txt, and tools.json

Devin: 8.5/10

Devin shows highly sophisticated prompt engineering, particularly in:

Comprehensive instructions for autonomous software development
Detailed guidelines for system interaction and tool usage
Structured approach to planning and problem-solving
Effective use of markdown-style formatting for clarity

Source: Analysis of Devin system prompt

Cursor: 8.0/10

Cursor demonstrates sophisticated prompt engineering in its domain, with:

Highly specialized instructions for code understanding and generation
Detailed guidelines for different programming languages and paradigms
Effective use of conditional logic for different scenarios
Clear integration with IDE and development environment

Source: Analysis of Cursor system prompt

Lovable: 7.5/10

Lovable shows good prompt engineering techniques, particularly in:

Custom markup language for file operations
Detailed instructions for web application development
Framework-specific guidelines
Focus on user experience and design considerations

Source: Analysis of Lovable system prompt

Methodological Innovations

Each product introduces unique methodological innovations in prompt engineering:

Manus: Event Stream Processing

Manus introduces a sophisticated event stream processing architecture that allows the AI to process and respond to a chronological stream of events, including messages, actions, observations, plans, and knowledge items.

<event_stream>
You will be provided with a chronological event stream (may be truncated or partially omitted) containing the following types of events:
1. Message: Messages input by actual users
2. Action: Tool use (function calling) actions
3. Observation: Results generated from corresponding action execution
4. Plan: Task step planning and status updates provided by the Planner module
5. Knowledge: Task-related knowledge and best practices provided by the Knowledge module
6. Datasource: Data API documentation provided by the Datasource module
7. Other miscellaneous events generated during system operation
</event_stream>

Source: Manus prompt.txt - Event stream processing architecture

Devin: Autonomous Planning Framework

Devin introduces an autonomous planning framework that enables the AI to break down complex tasks, plan approaches, and execute solutions with minimal human intervention.

When solving problems:
1. Break down complex tasks into smaller steps
2. Plan your approach before implementation
3. Test your solutions thoroughly
4. Document your work clearly

For complex tasks, create a plan with specific steps before executing. This helps ensure you don't miss important details and allows for methodical progress tracking.

Source: Devin system prompt - Autonomous planning framework

Cursor: Context-Aware Code Assistance

Cursor introduces a context-aware code assistance model that enables the AI to understand and modify code based on the current state of the codebase and the user's intent.

When making code changes:
1. First understand the current state of the code and the user's intent
2. Consider the broader context of the codebase
3. Make minimal, focused changes that address the user's request
4. Explain your changes and reasoning

If the requested change has already been made in the codebase, point this out to the user rather than making redundant changes.

Source: Cursor system prompt - Context-aware code assistance model

Lovable: Custom Markup Language

Lovable introduces a custom markup language for file operations that enables the AI to clearly indicate different types of actions in its responses.

Use only ONE <lov-code> block to wrap ALL code changes and technical details in your response...
Use <lov-write> for creating or updating files...
Use <lov-rename> for renaming files...
Use <lov-delete> for removing files...

Source: Lovable system prompt - Custom markup language for file operations

Conclusion

Our comparative analysis reveals that while each AI product employs distinct prompting styles and philosophical approaches tailored to their specific domains, Manus demonstrates the most sophisticated prompt engineering techniques overall, with its comprehensive modular design, XML-style semantic markup, formal function definitions, and event stream processing architecture.

Devin follows closely with its autonomous planning framework and comprehensive software engineering guidelines, while Cursor excels in its specialized domain with context-aware code assistance. Lovable, while less sophisticated overall, introduces innovative approaches to web development with its custom markup language.

These differences reflect the diverse approaches to AI assistant design and highlight the rapid evolution of prompt engineering as a discipline. By understanding these different approaches, developers can make more informed decisions about which techniques to adopt for their own AI applications.