Switched from Claw to Cursor because of random LSP crashes, my benchmarks

Hey everyone, I've been living in the Claw editor for the better part of two years, deeply entrenched in my database and ETL workflows. But I finally hit a breaking point last month: persistent, random LSP crashes that would leave me with no IntelliSense for Python and SQL until a full editor restart. It was especially brutal during complex migration script writing.

So, I made the jump to Cursor. I wanted to share not just the emotional relief, but some concrete, totally unscientific but hopefully useful benchmarks from my local setup. My hope is this helps others who might be wrestling with similar instability.

**My Environment & Key Plugins:**
* **OS:** macOS Sonoma 14.5
* **Hardware:** M1 Max, 64GB RAM
* **Core Workloads:** SQL (MySQL, PostgreSQL dialect), Python (PySpark, SQLAlchemy), YAML (Kubernetes, Docker), Markdown.
* **Claw Setup (Former):** The LSP stack was the heart of it:
* `clangd` for C++
* `pyright` & `jedi` for Python
* `sqlls` (SQL Language Server) for generic SQL
* `mysqls` for MySQL-specific
* `lemminx` for YAML/XML
* Plus treesitter for all the above, and a suite of UI plugins (theme, statusline, etc.).
* **Cursor Setup (Current):** It's essentially VSCode under the hood, so:
* Built-in Python, Pylance, Jupyter extensions.
* Official MySQL, PostgreSQL extensions.
* Docker, Kubernetes extensions.
* GitHub Copilot deeply integrated.

**The Pain Point & Benchmarks:**
In Claw, the LSP processes, especially `pyright` and `sqlls`, would sporadically die. A `:LspInfo` would show them as inactive. Memory usage would sometimes spike but wasn't the consistent culprit. The real cost was time and flow.

I timed a few routine tasks across a week in both editors, same project (a data pipeline with ~50 Python files and ~20 SQL migration files).

| Task | Claw (Avg) | Cursor (Avg) | Notes |
| :--- | :--- | :--- | :--- |
| **Cold Start to Editable** | 1.8s | 2.9s | Claw wins, but Cursor's start is consistent. |
| **Full LSP Initialization** | 4.5s | 3.1s | Cursor's parallel loading is faster here. |
| **Time to First Crash** | ~6-8 hrs of active use | N/A (stable so far) | This was the deal-breaker. |
| **Memory (Idle)** | ~450MB | ~680MB | Cursor uses more, but it's a trade-off. |
| **Memory (Large SQL File)** | ~1.2GB (spiky) | ~950MB (stable) | Cursor handled a 3000-line migration better. |
| **"Go to Definition" across virtual env** | 0.8s (when working) | 0.3s | Cursor's LSP feels more responsive. |

**Key Takeaways & Migration Pitfalls:**
* **The Stability Trade-off:** I traded some raw startup speed and lower idle memory for not having my tools vanish mid-thought. For me, it's worth it.
* **Configuration Shift:** Moving from `init.lua` to `settings.json` was a mindset change. Cursor's settings feel more centralized but also more "magical" – less granular control over individual LSP server args.
* **The Copilot Effect:** This isn't just about LSP. Having Copilot natively integrated without a separate plugin chain is a huge performance *and* cognitive win. In Claw, I had `copilot.lua` & `cmp` which added another layer.
* **SQL Specifics:** The dedicated MySQL/Postgres extensions in Cursor are fantastic. They provide connection-aware completion and schema exploration that my `sqlls` + `mysqls` setup in Claw struggled with reliably.

Here's a snippet of what my Claw LSP config looked like for SQL – a lot of manual wiring:

```lua
local sql_config = {
name = "sqlls",
cmd = { "sql-language-server", "up", "--method", "stdio" },
filetypes = { "sql", "mysql" },
root_dir = util.root_pattern(".git", "queries"),
settings = {},
}

local mysql_config = {
name = "mysqls",
cmd = { "mysqls", "--stdio" },
filetypes = { "mysql" },
root_dir = util.root_pattern(".git", "migrations"),
settings = {},
}
-- And then making them play nice... sometimes.
```

In Cursor, it's just enabling the official extension and connecting to my DB. The LSP is bundled and managed.

I miss the purity and keyboard-driven flow of Claw, but for my specific mix of database work and scripting where LSP reliability is critical, Cursor has been a smoother daily driver. Has anyone else made a similar switch, or found ways to stabilize the Claw LSP stack under heavy, multi-language use? I'd love to hear your stories.

—B