A collection of prompting techniques from real Cursor IDE conversations

This guide documents prompting patterns discovered while using Cursor IDE for backend development, specifically working with microservices, protocol implementations, and architectural challenges.

What this is: One developer's systematic approach to AI-assisted backend development. The patterns worked consistently in this specific context.

What this isn't: A comprehensive guide to all AI development, frontend patterns, or a guarantee these will work in every situation.

Who might find this useful:

• Backend developers using Cursor IDE
• Teams working with microservices architectures
• Developers looking for systematic approaches to AI prompting
• Anyone curious about practical AI development patterns

The Core Insight

After analyzing dozens of development conversations, one thing became clear: effective AI development follows identifiable patterns. Instead of random trial-and-error, you can approach AI assistance systematically.

A Note on Limitations

These patterns come from:

• ✅ Backend development (Node.js, microservices)
• ✅ System architecture and protocol implementation
• ✅ Working with existing codebases

They haven't been tested for:

• ❌ Frontend-heavy development
• ❌ Data science or ML workflows
• ❌ Greenfield projects with no existing patterns
• ❌ Other AI models beyond Claude

The 8 Core Patterns

Through real development work, these distinct patterns emerged:

Foundation Patterns

1. Complete Context Sharing - Give AI the full picture
2. Progressive Problem Exploration - Let AI investigate systematically
3. Reference-Based Development - Build on existing patterns

Coordination Patterns

4. Iterative Feature Building - Break complex features into chunks
5. Multi-System Coordination - Handle frontend-backend-protocol alignment

Advanced Patterns

6. Architecture-First Design - Plan before implementing
7. Safe System Refactoring - Move code without breaking things
8. Root Cause Investigation - Debug the development process itself

Pattern 1: Complete Context Sharing

When to use: Any time you're asking AI for help
The principle: AI can only help with what it can see

Real Examples

Example 1: Simple Error Fix

[Error] Access-Control-Allow-Origin cannot contain more than one origin.
[Error] Fetch API cannot load http://127.0.0.1:4000/ai-agent-conversations/blue-gifts-invent/agui due to access control checks.

Why it worked: Included the exact error message, not a paraphrase.

Example 2: Complex Validation Error

Tool results: 1 results received
Error in generateConversation: {
  error: InvalidToolArgumentsError [AI_InvalidToolArgumentsError]: Invalid arguments for tool createNode: Type validation failed: Value: {"nodeData":{"node_type":"agent","name":"Idea Generator","config":{"instruction":"You are an agent specializing in creative brainstorming...","position":{"x":-200,"y":150}}},"parentNodeId":"agent_nodes:c1f2yieit65lox3j4f7o"}.
  Error message: [
    {
      "code": "invalid_type",
      "expected": "object",
      "received": "undefined",
      "path": [
        "nodeData",
        "position"
      ],
      "message": "Required"
    }
  ]

Why it worked: Included the full stack trace, actual data values, and validation details.

Key Principles

• Copy error messages exactly (every character matters)
• Include full stack traces, not summaries
• Show the actual data causing issues
• Don't pre-filter what you think is relevant

Pattern 2: Progressive Problem Exploration

When to use: Understanding complex systems or debugging vague issues
The principle: Let AI explore your codebase systematically

Real Examples

Example 1: Understanding Tool Metadata

I think we are logging results of tool calling in meta data of a2a protocol, can you give me detailes, so i can pass it to client so it can consume it properly

Result: AI systematically explored the codebase, found the implementation, documented the metadata structure, and provided client consumption guidelines.

Example 2: Vague Bug Report

there a bug here, this is not using agentId

Result: Despite the minimal information, AI searched the codebase, found the problematic function, and identified it was fetching all nodes instead of filtering by agent.

Key Principles

• Describe the area you want to understand
• Explain your end goal
• Let AI explore rather than guessing yourself
• Ask for examples of how to use what you find

Pattern 3: Reference-Based Development

When to use: Implementing features that should follow existing patterns
The principle: Consistency comes from following what already works

Real Examples

Example 1: Record ID Pattern

See how we are handling recordid in ai-agent nodes

Why it worked: Referenced existing working code and implied need for consistency.

Example 2: Message Streaming Implementation

Help me implement this message/stream endpoint (/:agent_handle/message/stream), only focus on this endpoint. (Inside ai-agent-to-agent service)

Take reference from /ai-agent-conversations/:agent_handle/agui endpoint, we have to use same ai sdk here, but the change is input and output protocol, we are using a2a protocol here

Result: AI studied the existing endpoint and implemented the new one following the same patterns but with protocol adjustments.

Key Principles

• Point to working examples: "See how we handle X in Y"
• Specify what's different: "Same pattern but different protocol"
• Focus on consistency: "Follow the same patterns as..."

Pattern 4: Iterative Feature Building

When to use: Building complex features that touch multiple systems
The principle: Break overwhelming requirements into manageable chunks

Real Example

Complex Tool Integration

add tools to streamText, for now these tools will be imported from nodeCommand, like create node, update node, delete node, list nodes, link nodes and unlink nodes ..

Result: AI created comprehensive tool definitions with:

• Zod validation schemas
• Proper error handling
• Async execution patterns
• Complete CRUD operations

Key Principles

• Define clear boundaries: "only focus on X"
• Build incrementally: one piece at a time
• Test each piece before moving on
• Reference existing patterns for consistency

Pattern 5: Multi-System Coordination

When to use: When changes span frontend, backend, and protocols
The principle: Coordinate changes systematically across systems

Real Examples

Example 1: Protocol Integration

Integrate AI UI protoocol (refer docs) to our ai streaming, integrating tools is not required, but add support for basic conversations

Result: AI implemented event types (RUN_STARTED, TEXT_MESSAGE_CONTENT, etc.) while maintaining compatibility with existing systems.

Example 2: Frontend State Management

When an agent is selected in sidebar, then currentagent need to be set to the respective agent.

[Later] Now integrate the chat with this api, it's a streaming api. Also the agent_handle, is available in the agent object from server, substitute that in the path

Result: Proper state management connected to UI updates and dynamic API calls.

Key Principles

• Handle one system at a time
• Test integration points carefully
• Maintain backward compatibility
• Document protocol differences

Pattern 6: Architecture-First Design

When to use: Before building any complex system
The principle: Design the complete architecture before writing code

Real Example

Tool Management System Design

Here's what I want to do, tell me the approach to go about it.
I want to make it seamless for my agent builder to add api tools to agents. where AI can scan through docs and make a curl template.

Implement this in tools service, follow the same patterns as in ai-agent-nodes, the jsonrpc handlers. Refer there to avoid mistakes.

Result: AI provided a complete architectural plan with:

• Placeholder grammar design
• Endpoint structure
• Parsing logic
• End-to-end flow
• Extension points

Key Principles

• Ask for approach first: "tell me the approach"
• Explain the bigger picture
• Specify architectural constraints
• Get the plan before coding

Pattern 7: Safe System Refactoring

When to use: Moving functionality between services or removing services
The principle: Understand dependencies before making changes

Real Example

Service Migration

Move generateConversation to ai-agent-to-agent any other dependecies "ai-agent-to-agent " needs because we are removing "ai-agent-conversations" service/folder

Result: AI analyzed dependencies, moved the function with all required types and imports, and ensured the destination service had necessary packages.

Key Principles

• Specify source and destination clearly
• Ask for dependency analysis
• Move incrementally
• Validate the system still works

Pattern 8: Root Cause Investigation

When to use: When you have recurring issues or mysterious failures
The principle: Fix the cause, not just the symptoms

Real Example

Schema-Prompt Misalignment

[Validation error showing position field required but AI sending it inside config]

Discovery: The root cause was a mismatch between the validation schema (position required at top level) and system prompt guidance (position inside config).

Result: Fixed both the schema and prompt to align, preventing future similar issues.

Key Principles

• Document all symptoms completely
• Look for patterns in failures
• Fix the root cause systematically
• Create prevention strategies

Putting It Into Practice

Start Small

1. Practice complete context sharing on your next bug
2. Let AI explore when you're unsure how something works
3. Reference existing patterns when building new features

Build Systematically

1. Break complex features into chunks
2. Design architecture before implementation
3. Coordinate multi-system changes carefully

Think Long-term

1. Investigate root causes, not just symptoms
2. Create reusable patterns for your team
3. Document what works in your context

Final Thoughts

These patterns aren't universal truths - they're practical techniques that worked in one specific context. The real value comes from:

1. Recognizing that AI development can be systematic rather than random
2. Adapting these patterns to your own context and technology stack
3. Building your own pattern library based on what works for you

The goal isn't to follow these patterns blindly, but to develop your own systematic approach to AI-assisted development.

Your Next Steps

• Test these patterns in your own work
• Document what works and what doesn't
• Share your findings with your team
• Build on what's useful, discard what isn't

Remember: The best patterns are the ones that consistently solve your specific problems.

This is a living document. As AI tools evolve and we learn more about effective patterns, these approaches will need to evolve too.