So much time can be saved when compiling (coding SwiftUI) if Cursor’s Claude could learn to always check property, method, protocol names before coding instead of just guessing at them. I know this must be a limit of LLMs but those agents in the background one of them could surely have the job of checking dependencies for proper names and passing them to the Apply Model…?
Just sure would be nice!
1. **Symbol & Dependency Validation**
- Before suggesting code, validate all:
- Property names and method signatures
- Protocol definitions and framework types
- Imported dependencies and modules
- SDK version compatibility
- Leverage background agents for real-time verification
- Cache validated symbols for improved performance
- Flag potential naming errors proactively
2. **Code Clarity & Precision**
- Present only relevant code modifications
- Use clear demarcation for unchanged sections (`// ... existing code ...`)
- Always specify file paths and language contexts
- Maintain consistent formatting and indentation
- Include full context for method/class relationships
3. **Contextual Intelligence**
- Parse existing project structure
- Maintain awareness of:
- Custom types and extensions
- Available protocol conformances
- Build target requirements
- Minimum deployment targets
- Cross-reference symbols across relevant files
4. **Truthful & Direct Communication**
- Never fabricate information or capabilities
- Acknowledge limitations transparently
- Provide accurate, verifiable responses
- Maintain intellectual honesty
- Suggest alternatives when exact matches fail
5. **Technical Excellence**
- Format all responses in proper markdown
- Tag code blocks with language identifiers
- Default to Windows/PowerShell path conventions
- Support multilingual interactions
- Provide documentation links for ambiguous cases
6. **Performance Optimization**
- Prioritize frequently used framework components
- Queue validation requests during code generation
- Cache common symbol validations
- Minimize compile-time errors through proactive checking
Do you find this works? I have tried variations of “check X first before doing Y” and it almost never seem to adhere to it. I put your rules for AI in started a fresh composer:
There it goes…
hey SF here too.
I used this composition as reference in my rule set. Trying to evaluate the difference in importing and syncing the test as a local reference, siply putting the URL in the rule set and the plaint copy pasting in the rule set.
Either way, good coding principles are the key.
It does not seem to be bound by length of input. So I just put in the entire GNU Coding Standards Manual Directly in the rule set
Dope.
Ive been working on Agent Orchitration Control Plane App all day.
Here is an earlier today version of my readme…
Its taking on a scope_kreep in just this afternoon and evening that its super fun and crazy.
Developing with YOLO is so fn fantastic.!!!
(also not that when you hit the “25 call limit” stall-warning:
EDIT, HAHA did it again:
A PostgreSQL-based control plane that enables multiple Cursor IDE instances to work together seamlessly, sharing context, commands, and workspace state across machines.
Imagine running Cursor on multiple machines, each instance aware of the others, sharing context, and working together seamlessly. That’s what the Cursor Agent Control Plane enables - a distributed system where Cursor instances become collaborative agents.
graph TB
subgraph "Control Plane"
PG[("PostgreSQL<br/>Source of Truth")]
subgraph "Core Services"
CMD["Command Queue"]
SYNC["Sync Manager"]
LOCK["Lock Manager"]
CTX["Context Manager"]
end
subgraph "Monitoring"
HEALTH["Health Check"]
METRICS["Metrics"]
LOGS["Event Log"]
end
end
subgraph "Agent 1 (Machine A)"
A1["Cursor Instance"]
A1_WS["Workspace"]
A1_COORD["Coordinator"]
end
subgraph "Agent 2 (Machine B)"
A2["Cursor Instance"]
A2_WS["Workspace"]
A2_COORD["Coordinator"]
end
A1_COORD --> PG
A2_COORD --> PG
PG --> CMD & SYNC & LOCK & CTX
CMD & SYNC & LOCK & CTX --> HEALTH & METRICS & LOGS
| Feature | Description | Implementation |
|---|---|---|
| Agent Discovery | Automatic discovery and registration of Cursor instances | PostgreSQL-based session tracking with heartbeats |
| Command Queue | Cross-instance command execution | Priority-based queue with ACID guarantees |
| Workspace Sync | File synchronization and conflict resolution | Content hashing and version tracking |
| Shared Context | Distributed knowledge sharing | JSONB-based context store with versioning |
| Resource Locking | Distributed locking mechanism | Row-level locks with timeout management |
| Event Logging | Comprehensive audit trail | Structured logging with context preservation |
sequenceDiagram
participant A1 as Cursor Agent 1
participant DB as PostgreSQL
participant A2 as Cursor Agent 2
Note over A1,A2: Agent Discovery
A1->>DB: Register session
A2->>DB: Register session
Note over A1,A2: Command Execution
A1->>DB: Enqueue command
A2->>DB: Poll commands
A2->>DB: Execute command
A2->>DB: Update status
Note over A1,A2: Workspace Sync
A1->>DB: Log file change
A2->>DB: Detect change
A2->>A2: Apply change
-- Agent session management
CREATE TABLE cursor_control.agent_sessions (
session_id UUID PRIMARY KEY,
machine_name TEXT,
workspace_path TEXT,
capabilities JSONB,
last_heartbeat TIMESTAMPTZ
);
-- Command queue
CREATE TABLE cursor_control.command_queue (
command_id UUID PRIMARY KEY,
source_agent UUID,
target_agent UUID,
command_type TEXT,
payload JSONB,
status TEXT
);
class CursorPgCoordinator:
"""PostgreSQL-based coordinator for Cursor agents"""
def enqueue_command(self, target: str, command: str, payload: dict):
"""Send command to another agent"""
def get_pending_commands(self) -> list:
"""Get commands waiting for execution"""
def update_workspace_state(self, changes: list):
"""Sync workspace changes"""
Seamless Collaboration
Robust Architecture
Developer Experience
| Scenario | Description | Benefit |
|---|---|---|
| Multi-Machine Development | Work across desktop and laptop | Seamless context switching |
| Team Collaboration | Share debugging sessions | Real-time assistance |
| Resource Distribution | Distribute compute-intensive tasks | Better resource utilization |
| Knowledge Sharing | Share discoveries and insights | Improved team efficiency |
Prerequisites
Quick Setup
# Clone the repo
git clone https://github.com/yourusername/cursor-control-plane
# Setup control plane
cd cursor-control-plane
.\scripts\setup_control_plane.ps1
# Start coordinator
python .control_plane/agents/pg_coordinator.py
Enhanced Features
Community Contributions
I’m excited to share this project with the Cursor community and would love to hear your thoughts:
Let’s build a more connected Cursor ecosystem together! 
Note: This is an open-source project in development. Contributions and feedback are welcome!
This is off topic. Try to keep responses withing the topic of the post.
In my mind it was on topic — as I am struggling to keep the agents on directive and following rulesets and what not – and its quite difficult - and Ive been trying a bunch of methods that are similar to other agentic orchestration projects seem to be doing…
We all seem to be circling the same drain in the time-sink that is AI agentic coding loops.
I have a new nickname for you , you should be called the yolo master. Lol 
…Kidding, but you know how to maximize the potential of the tool. Great post btw
I really like this feature idea. IS there a dedicated discussion on this topic?
It reminds me of crewai, but in cursor which is great!